diff --git a/quiche/common/quiche_feature_flags_list.h b/quiche/common/quiche_feature_flags_list.h
index 48bd038..b4f0c7b 100755
--- a/quiche/common/quiche_feature_flags_list.h
+++ b/quiche/common/quiche_feature_flags_list.h
@@ -31,6 +31,7 @@
 QUICHE_FLAG(bool, quiche_reloadable_flag_quic_disable_version_q046, false, true, "If true, disable QUIC version Q046.")
 QUICHE_FLAG(bool, quiche_reloadable_flag_quic_disable_version_rfcv1, false, false, "If true, disable QUIC version h3 (RFCv1).")
 QUICHE_FLAG(bool, quiche_reloadable_flag_quic_discard_initial_packet_with_key_dropped, false, true, "If true, discard INITIAL packet if the key has been dropped.")
+QUICHE_FLAG(bool, quiche_reloadable_flag_quic_ecn_in_first_ack, false, false, "When true, reports ECN in counts in the ACK of the a client initial that goes in the buffered packet store.")
 QUICHE_FLAG(bool, quiche_reloadable_flag_quic_enable_disable_resumption, true, true, "If true, disable resumption when receiving NRES connection option.")
 QUICHE_FLAG(bool, quiche_reloadable_flag_quic_enable_mtu_discovery_at_server, false, false, "If true, QUIC will default enable MTU discovery at server, with a target of 1450 bytes.")
 QUICHE_FLAG(bool, quiche_reloadable_flag_quic_enable_server_on_wire_ping, true, true, "If true, enable server retransmittable on wire PING.")
diff --git a/quiche/quic/core/quic_buffered_packet_store.cc b/quiche/quic/core/quic_buffered_packet_store.cc
index 0392ecf..4421b66 100644
--- a/quiche/quic/core/quic_buffered_packet_store.cc
+++ b/quiche/quic/core/quic_buffered_packet_store.cc
@@ -69,6 +69,19 @@
   QuicBufferedPacketStore* connection_store_;
 };
 
+std::optional<QuicEcnCounts> SinglePacketEcnCount(
+    QuicEcnCodepoint ecn_codepoint) {
+  switch (ecn_codepoint) {
+    case ECN_CE:
+      return QuicEcnCounts(0, 0, 1);
+    case ECN_ECT0:
+      return QuicEcnCounts(1, 0, 0);
+    case ECN_ECT1:
+      return QuicEcnCounts(0, 1, 0);
+    default:
+      return std::nullopt;
+  }
+}
 }  // namespace
 
 BufferedPacket::BufferedPacket(std::unique_ptr<QuicReceivedPacket> packet,
@@ -313,7 +326,11 @@
     initial_ack_frame.packets.Add(sent_packet.received_packet_number);
   }
   initial_ack_frame.largest_acked = initial_ack_frame.packets.Max();
-
+  if (GetQuicReloadableFlag(quic_ecn_in_first_ack)) {
+    QUIC_RELOADABLE_FLAG_COUNT(quic_ecn_in_first_ack);
+    initial_ack_frame.ecn_counters =
+        SinglePacketEcnCount(packet_info.packet.ecn_codepoint());
+  }
   if (!creator.AddFrame(QuicFrame(&initial_ack_frame), NOT_RETRANSMISSION)) {
     QUIC_BUG(quic_dispatcher_add_ack_frame_failed)
         << "Unable to add ack frame to an empty packet while acking packet "
diff --git a/quiche/quic/core/quic_buffered_packet_store_test.cc b/quiche/quic/core/quic_buffered_packet_store_test.cc
index 107acaa..60495dc 100644
--- a/quiche/quic/core/quic_buffered_packet_store_test.cc
+++ b/quiche/quic/core/quic_buffered_packet_store_test.cc
@@ -6,6 +6,7 @@
 
 #include <cstddef>
 #include <cstdint>
+#include <cstring>
 #include <list>
 #include <memory>
 #include <optional>
@@ -16,12 +17,16 @@
 #include "absl/strings/string_view.h"
 #include "quiche/quic/core/connection_id_generator.h"
 #include "quiche/quic/core/crypto/transport_parameters.h"
+#include "quiche/quic/core/frames/quic_frame.h"
+#include "quiche/quic/core/frames/quic_padding_frame.h"
 #include "quiche/quic/core/quic_connection_id.h"
 #include "quiche/quic/core/quic_constants.h"
 #include "quiche/quic/core/quic_dispatcher.h"
 #include "quiche/quic/core/quic_dispatcher_stats.h"
 #include "quiche/quic/core/quic_error_codes.h"
 #include "quiche/quic/core/quic_framer.h"
+#include "quiche/quic/core/quic_packet_number.h"
+#include "quiche/quic/core/quic_packet_writer.h"
 #include "quiche/quic/core/quic_packets.h"
 #include "quiche/quic/core/quic_time.h"
 #include "quiche/quic/core/quic_types.h"
@@ -34,6 +39,7 @@
 #include "quiche/quic/test_tools/mock_connection_id_generator.h"
 #include "quiche/quic/test_tools/quic_buffered_packet_store_peer.h"
 #include "quiche/quic/test_tools/quic_test_utils.h"
+#include "quiche/common/quiche_endian.h"
 
 namespace quic {
 static const size_t kDefaultMaxConnectionsInStore = 100;
@@ -50,11 +56,14 @@
 using BufferedPacket = QuicBufferedPacketStore::BufferedPacket;
 using BufferedPacketList = QuicBufferedPacketStore::BufferedPacketList;
 using EnqueuePacketResult = QuicBufferedPacketStore::EnqueuePacketResult;
+using ::testing::_;
 using ::testing::A;
 using ::testing::Conditional;
 using ::testing::Each;
 using ::testing::ElementsAre;
+using ::testing::Invoke;
 using ::testing::Ne;
+using ::testing::Return;
 using ::testing::SizeIs;
 using ::testing::Truly;
 
@@ -149,6 +158,83 @@
   EXPECT_FALSE(store_.HasBufferedPackets(connection_id));
 }
 
+TEST_F(QuicBufferedPacketStoreTest, SimpleEnqueueAckSent) {
+  SetQuicReloadableFlag(quic_ecn_in_first_ack, true);
+  QuicConnectionId connection_id = TestConnectionId(1);
+  MockPacketWriter writer;
+  store_.set_writer(&writer);
+  // Build a decryptable Initial packet with PADDING.
+  QuicFramer client_framer(ParsedQuicVersionVector{ParsedQuicVersion::RFCv1()},
+                           QuicTime::Zero(), Perspective::IS_CLIENT, 8);
+  client_framer.SetInitialObfuscators(connection_id);
+  QuicPacketHeader header;
+  header.destination_connection_id = connection_id;
+  header.version_flag = true;
+  header.packet_number = QuicPacketNumber(1);
+  header.packet_number_length = PACKET_1BYTE_PACKET_NUMBER;
+  header.long_packet_type = INITIAL;
+  header.length_length = quiche::VARIABLE_LENGTH_INTEGER_LENGTH_2;
+  header.retry_token_length_length = quiche::VARIABLE_LENGTH_INTEGER_LENGTH_1;
+  QuicFrames frames = {QuicFrame(QuicPaddingFrame(1200))};
+
+  char* buffer = new char[1500];
+  EncryptionLevel level = HeaderToEncryptionLevel(header);
+  size_t length =
+      client_framer.BuildDataPacket(header, frames, buffer, 1500, level);
+
+  ASSERT_GT(length, 0);
+
+  // Re-construct the data packet with data ownership.
+  auto data = std::make_unique<QuicPacket>(
+      buffer, length, /* owns_buffer */ true,
+      GetIncludedDestinationConnectionIdLength(header),
+      GetIncludedSourceConnectionIdLength(header), header.version_flag,
+      header.nonce != nullptr, header.packet_number_length,
+      header.retry_token_length_length, header.retry_token.length(),
+      header.length_length);
+  unsigned char raw[1500] = {};
+  size_t final_size = client_framer.EncryptPayload(
+      ENCRYPTION_INITIAL, header.packet_number, *data, (char*)raw, 1500);
+  QuicReceivedPacket packet((char*)raw, final_size, QuicTime::Zero(), false, 0,
+                            true, nullptr, 0, false, ECN_ECT1);
+
+  EXPECT_CALL(writer, IsWriteBlocked()).WillOnce(Return(false));
+  std::unique_ptr<QuicEncryptedPacket> ack_packet;
+  EXPECT_CALL(writer, WritePacket(_, _, _, _, _, _))
+      .WillOnce(Invoke([&](const char* buffer, size_t buf_len,
+                           const QuicIpAddress& /*self_address*/,
+                           const QuicSocketAddress& /*peer_address*/,
+                           PerPacketOptions* /*options*/,
+                           const QuicPacketWriterParams& /*params*/) {
+        auto tmp_packet =
+            std::make_unique<QuicEncryptedPacket>(buffer, buf_len);
+        ack_packet = tmp_packet->Clone();
+        return WriteResult(WRITE_STATUS_OK, 1);
+      }));
+  EXPECT_CALL(writer, Flush());
+  EnqueuePacketToStore(store_, connection_id, IETF_QUIC_LONG_HEADER_PACKET,
+                       INITIAL, packet, self_address_, peer_address_,
+                       ParsedQuicVersion::RFCv1(), kNoParsedChlo,
+                       connection_id_generator_);
+  const BufferedPacketList* buffered_list = store_.GetPacketList(connection_id);
+  ASSERT_NE(buffered_list, nullptr);
+  ASSERT_EQ(buffered_list->dispatcher_sent_packets.size(), 1);
+  EXPECT_EQ(buffered_list->dispatcher_sent_packets[0].largest_acked,
+            QuicPacketNumber(1));
+
+  // Decrypt the packet, and verify it reports ECN.
+  MockFramerVisitor mock_framer_visitor;
+  client_framer.set_visitor(&mock_framer_visitor);
+  EXPECT_CALL(mock_framer_visitor, OnPacket()).Times(1);
+  EXPECT_CALL(mock_framer_visitor, OnAckFrameStart(_, _))
+      .WillOnce(Return(true));
+  EXPECT_CALL(mock_framer_visitor, OnAckRange(_, _)).WillOnce(Return(true));
+  std::optional<QuicEcnCounts> counts = QuicEcnCounts(0, 1, 0);
+  EXPECT_CALL(mock_framer_visitor, OnAckFrameEnd(_, counts))
+      .WillOnce(Return(true));
+  client_framer.ProcessPacket(*ack_packet);
+}
+
 TEST_F(QuicBufferedPacketStoreTest, DifferentPacketAddressOnOneConnection) {
   QuicSocketAddress addr_with_new_port(QuicIpAddress::Any4(), 256);
   QuicConnectionId connection_id = TestConnectionId(1);