@@ -0,0 +1,67 @@
+# FEATURE-ci-darwin-header-deadline-followup: Unresolved Darwin external deadline failure
+
+Status: Pending — cause unknown; further diagnostic decision deferred until safe,
+confirmed independent CI fixes are finished. No new investigation is authorized
+by this record alone.
+
+Predecessor: [bounded native diagnostic stage](FEATURE-ci-darwin-header-deadline.md).
+Evidence source: `v3` c0 `c0cfdabc8040273d60c610269a93d1c687ed8517` and prior
+f91 native archive failure. Choose the eventual implementation base when scheduled.
+
+## Preserved defect and requirements
+
+Installed shared TLS-off Darwin `external_http1_e2e`, case
+`published_header_deadline_drives_empty_dispatch`, failed in f91 archive run
+`39962644789` / job `120444991323` / artifact `12506406058`, and c0 archive run
+`39969790346` / job `120469466623` / artifact `12509855171`. On c0 the case took
+10,006.1 ms: original assertion 217 (`receive_close`) and 221 (`!failed`) failed;
+219 (`empty_dispatches > 0`) passed. Other three cases and native HTTP1 passed.
+Preserve the original 300 ms header deadline, 10 s host failure deadline and
+assertions. Original failed gates remain open/incomplete; the defect is not fixed.
+
+## Completed bounded checks and limits
+
+The predecessor's approved controls are finished. Live and deferred trace overlays
+on the exact selected archive passed the four external cases, first in runner
+context, then with corrected EUID 0 and original signal defaults. Their healthy
+~303 ms timer/continuation/enforcement/native-close sequences prove no cause;
+instrumentation can change scheduling. No decisive forced-interleaving regression
+or broken wake/lease-retirement invariant was established.
+
+Final run `39990090304` / macOS job `120539322802` used unchanged selected c0
+archive/core/test/helpers, original package_lane setup/prelude and first two
+TLS-off shared suites, direct original Popen and actual EUID 0. Native HTTP1
+60 tests / 708 checks and external four / 52 passed; header 303.348 ms.
+Original receipt checks preceded the partial stop. This establishes intermittency,
+not cause, fix, independence or whole-matrix passage. Sampling was not triggered;
+actual native sampler execution remains untested. Local real-process controller
+checks do not substitute for native failure evidence.
+
+Same-c0 checkout package job `120468733495` also passed TLS-off before a separate
+TLS-on CA failure. Archive versus checkout/setup was an observed contrast, not
+an explanation. Root execution correction did not establish a deadline cause.
+All temporary source/test/workflow diagnostics were removed in the predecessor;
+its original source/test/workflow tree equals c0 exactly.
+
+## Pending work when scheduled
+
+- [ ] After independent confirmed Windows staging, TLS CA fixture and FreeBSD
+  selected-make fixes are finished, make the next explicit diagnostic decision
+  from retained evidence. No unchanged retry or additional probe is implied.
+- [ ] If further investigation is authorized, define one bounded question and
+  stopping condition; preserve source/runtime context and original failures.
+- [ ] Establish a concrete cause and observe a meaningful failing actual-code
+  regression before any narrow behavior repair; preserve budgets/assertions.
+- [ ] Validate a proven repair with relevant local checks and assigned native CI;
+  remove any newly authorized diagnostics before finalization.
+
+The closed prior Linux parity/publication-wait uncertainty is not reopened.
+No dependency/policy change, broad baseline, assertion relaxation, timeout
+increase or unrelated repair is authorized here.
+
+Primary evidence: `.debug/ci-darwin-native-69af4dxe/journal.md`, original c0/f91
+logs/receipts, `original-prefix-summary.json`, `original-prefix-external.log`,
+and retained original-prefix diagnostic/sampling/suites/commands receipts.
+Final control source artifact `12508482722` (run `39969790346`, attempt 1), tar
+SHA-256 `43124552f20bd00fceddc714856d605ca9caf017a849a991c34f16f437fcab83`.
+The predecessor card records complete archive and evidence ZIP bindings.
@@ -41,8 +41,6 @@
 #include <httpserver/detail/diagnostics_access.hpp>
 #include <httpserver/http/outcome.hpp>
 
-#include <httpserver/detail/deadline_trace.hpp>
-
 namespace httpserver {
 
 namespace detail {
@@ -717,9 +715,6 @@ bool connection_engine::watchdog_due(
     std::chrono::steady_clock::time_point deadline) {
     std::lock_guard<std::mutex> lock(mu_);
     const watchdog_plan plan = plan_watchdog_locked();
-    V3_DEADLINE_TRACE("due conn=%llu planned_ns=%lld current_ns=%lld now_ns=%lld exit=%d defer=%d equal=%d\n",
-        static_cast<deadline_trace_id>(id_), deadline_trace_ns(deadline), deadline_trace_ns(plan.deadline),
-        deadline_trace_ns(std::chrono::steady_clock::now()), plan.exit, plan.defer, plan.deadline == deadline);
     return !plan.exit && !plan.defer && plan.deadline == deadline
         && std::chrono::steady_clock::now() >= deadline;
 }
@@ -745,8 +740,6 @@ void connection_engine::note_transport_activity(bool written) {
 }
 
 void connection_engine::enforce_timeout(std::chrono::steady_clock::time_point deadline) noexcept {
-    V3_DEADLINE_TRACE("enforce conn=%llu deadline_ns=%lld now_ns=%lld\n",
-        static_cast<deadline_trace_id>(id_), deadline_trace_ns(deadline), deadline_trace_ns(std::chrono::steady_clock::now()));
     bool global_expiry = false, close_expiry = false;
     {
         std::lock_guard<std::mutex> lock(mu_);
@@ -783,19 +776,13 @@ task<void> connection_engine::watchdog_loop(
             std::lock_guard<std::mutex> lock(self->mu_);
             plan = self->plan_watchdog_locked();
         }
-        V3_DEADLINE_TRACE("plan conn=%llu deadline_ns=%lld now_ns=%lld exit=%d defer=%d\n",
-            static_cast<deadline_trace_id>(self->id_), deadline_trace_ns(plan.deadline),
-            deadline_trace_ns(std::chrono::steady_clock::now()), plan.exit, plan.defer);
         if (plan.exit) co_return;
         const auto deadline = plan.defer
             ? std::chrono::steady_clock::now() + k_watchdog_tick
             : plan.deadline;
         timer_operation op(self->owner_, self->id_, deadline);
         if (!self->arm_watchdog(op, plan)) continue;
         const io_result r = co_await std::move(op);
-        V3_DEADLINE_TRACE("watchdog_resume conn=%llu seq=%llu result=%d now_ns=%lld\n",
-            static_cast<deadline_trace_id>(self->id_), static_cast<deadline_trace_id>(op.sequence()),
-            static_cast<int>(r.code), deadline_trace_ns(std::chrono::steady_clock::now()));
         {
             std::lock_guard<std::mutex> lock(self->mu_);
             self->pending_timer_.reset();
 
@@ -25,8 +25,6 @@
 #include <utility>
 #include <httpserver/detail/connection_engine.hpp>
 #include <httpserver/detail/http1_websocket_handshake.hpp>
-
-#include <httpserver/detail/deadline_trace.hpp>
 namespace httpserver::detail {
 namespace {
 bool retire_completed_front(http1_response_outbox& outbox) {
@@ -238,15 +236,9 @@ bool connection_engine::transport_output_pending_locked() const {
 bool connection_engine::arm_watchdog(timer_operation& timer, const watchdog_plan& plan) {
     std::lock_guard lock(mu_);
     const auto current = plan_watchdog_locked();
-    V3_DEADLINE_TRACE("arm_check conn=%llu planned_ns=%lld current_ns=%lld exit=%d defer=%d current_defer=%d\n",
-        static_cast<deadline_trace_id>(id_), deadline_trace_ns(plan.deadline), deadline_trace_ns(current.deadline),
-        current.exit, plan.defer, current.defer);
     if (current.exit) return false;
     if (current.defer != plan.defer || current.deadline != plan.deadline) return false;
     pending_timer_ = timer.state();
-    V3_DEADLINE_TRACE("arm conn=%llu token=%p deadline_ns=%lld now_ns=%lld header_ms=%lld\n",
-        static_cast<deadline_trace_id>(id_), static_cast<void*>(timer.state().get()), deadline_trace_ns(timer.deadline()),
-        deadline_trace_ns(std::chrono::steady_clock::now()), deadline_trace_ms(config_.timeouts.header));
     timer.submit(backend_);
     return true;
 }
 
@@ -31,8 +31,6 @@
 #include <utility>
 #include <vector>
 
-#include <httpserver/detail/deadline_trace.hpp>
-
 namespace httpserver {
 namespace detail {
 namespace {
@@ -94,13 +92,10 @@ void io_poll_backend::notify() {
     bool failed = false;
     {
         std::lock_guard<std::mutex> lock(mu_);
-        V3_DEADLINE_TRACE("notify backend=%p pending=%d failed=%d\n", static_cast<void*>(this), wake_pending_, wake_failed_);
         if (wake_failed_ || wake_pending_) return;
         if (wake_.signal()) {
-            V3_DEADLINE_TRACE("signal backend=%p result=1\n", static_cast<void*>(this));
             wake_pending_ = true;
         } else {
-            V3_DEADLINE_TRACE("signal backend=%p result=0\n", static_cast<void*>(this));
             wake_failed_ = true;
             active_ = false;
             failed = true;
@@ -112,10 +107,8 @@ void io_poll_backend::notify() {
 }
 
 void io_poll_backend::acknowledge_wake() {
-    V3_DEADLINE_TRACE("acknowledge backend=%p pending=%d failed=%d\n", static_cast<void*>(this), wake_pending_, wake_failed_);
     if (!wake_.acknowledge()) wake_failed_ = true;
     wake_pending_ = false;
-    V3_DEADLINE_TRACE("acknowledged backend=%p failed=%d\n", static_cast<void*>(this), wake_failed_);
 }
 
 server::interest_snapshot io_poll_backend::interests() const {
@@ -168,7 +161,6 @@ http::outcome io_poll_backend::dispatch(
         close();
         return status;
     }
-    V3_DEADLINE_TRACE("dispatch backend=%p events=%zu now_ns=%lld\n", static_cast<void*>(this), events.size(), deadline_trace_ns(now));
     for (const auto& event : events) dispatch_event(event);
     expire_due_timers(now);
     return ready();
 
@@ -27,45 +27,10 @@
 
 #include "httpserver/detail/io_operation.hpp"
 
-#if defined(HTTPSERVER_DIAG_HEADER_DEADLINE)
-#include <algorithm>
-#include <array>
-#endif
 #include <exception>
 #include <memory>
 #include <utility>
 
-#include <httpserver/detail/deadline_trace.hpp>
-
-#if defined(HTTPSERVER_DIAG_HEADER_DEADLINE)
-namespace httpserver::detail {
-namespace {
-constinit std::array<deadline_trace_record, 2048> deadline_records{};
-constinit std::atomic<std::size_t> deadline_record_count{0};
-}  // namespace
-
-deadline_trace_record* deadline_trace_reserve(long long monotonic_ns) noexcept {  // NOLINT(runtime/int)
-    const auto index = deadline_record_count.fetch_add(1, std::memory_order_relaxed);
-    if (index >= deadline_records.size()) return nullptr;
-    auto& record = deadline_records[index];
-    record.monotonic_ns = monotonic_ns;
-    return &record;
-}
-
-void deadline_trace_flush() noexcept {
-    const int saved_errno = errno;
-    const auto count = std::min(deadline_record_count.load(std::memory_order_relaxed), deadline_records.size());
-    for (std::size_t index = 0; index < count; ++index) {
-        const auto& record = deadline_records[index];
-        if (!record.ready.load(std::memory_order_acquire)) continue;
-        std::fprintf(stderr, "V3_DEADLINE event_ns=%lld ", record.monotonic_ns);  // NOLINT(build/include_what_you_use)
-        record.write(record);
-    }
-    errno = saved_errno;
-}
-}  // namespace httpserver::detail
-#endif
-
 namespace httpserver {
 namespace detail {
 
@@ -144,13 +109,6 @@ void op_state::apply(io_result result) {
         witness = std::move(witness_);
         resume_ex = std::exchange(resume_ex_, nullptr);
     }
-#if defined(HTTPSERVER_DIAG_HEADER_DEADLINE)
-    if (kind_ == io_op_kind::timer) {
-        V3_DEADLINE_TRACE("apply conn=%llu token=%p seq=%llu result=%d frame=%d executor=%d now_ns=%lld\n",
-            static_cast<deadline_trace_id>(connection_), static_cast<void*>(this), static_cast<deadline_trace_id>(sequence()),
-            static_cast<int>(result.code), static_cast<bool>(frame), resume_ex != nullptr, deadline_trace_ns(std::chrono::steady_clock::now()));
-    }
-#endif
     if (frame) {
         resume_guarded(resume_ex, witness, frame);
     }
 
@@ -43,8 +43,6 @@
 #include "httpserver/detail/io_connection_owner.hpp"
 #include "httpserver/detail/io_timer_sweep.hpp"
 
-#include <httpserver/detail/deadline_trace.hpp>
-
 namespace httpserver {
 namespace detail {
 namespace {
@@ -124,13 +122,6 @@ void io_poll_backend::submit(op_state& op) {
             registered = true;
         }
     }
-#if defined(HTTPSERVER_DIAG_HEADER_DEADLINE)
-    if (op.kind() == io_op_kind::timer) {
-        V3_DEADLINE_TRACE("submit conn=%llu token=%p seq=%llu registered=%d rejected=%d admission=%d deadline_ns=%lld\n",
-            static_cast<deadline_trace_id>(op.connection()), static_cast<void*>(&op), static_cast<deadline_trace_id>(op.sequence()),
-            registered, rejected, static_cast<int>(admission), deadline_trace_ns(std::get<timer_payload>(op.payload()).deadline));
-    }
-#endif
     if (rejected) {
         finish_now(state, closed_result());
         return;
@@ -286,7 +277,6 @@ pollsys::native_socket_t io_poll_backend::native_handle(
 }
 
 void io_poll_backend::release_connection(std::uint64_t id) {
-    V3_DEADLINE_TRACE("release conn=%llu now_ns=%lld\n", static_cast<deadline_trace_id>(id), deadline_trace_ns(std::chrono::steady_clock::now()));
     hangup_connection(id);
 }
 
@@ -326,10 +316,6 @@ void io_poll_backend::hangup_connection(std::uint64_t id,
         if (expected && (cit == connections_.end()
                          || cit->second.lifetime != expected)) return;
         if (cit != connections_.end() && cit->second.lifetime) {
-            V3_DEADLINE_TRACE("retire conn=%llu socket=%llu lease=%p generation=%llu leases=%ld\n",
-                static_cast<deadline_trace_id>(id), static_cast<deadline_trace_id>(cit->second.socket),
-                static_cast<void*>(cit->second.lifetime.get()),
-                static_cast<deadline_trace_id>(cit->second.lifetime->generation), cit->second.lifetime.use_count());
             cit->second.dead = true;
             cit->second.lifetime->retired.store(true, std::memory_order_release);
             cit->second.lifetime.reset();
@@ -369,9 +355,6 @@ std::uint64_t io_poll_backend::register_accepted_socket(
     connection_record record;
     record.socket = socket;
     record.lifetime = make_lifetime_locked(socket);
-    V3_DEADLINE_TRACE("accepted conn=%llu socket=%llu lease=%p generation=%llu\n",
-        static_cast<deadline_trace_id>(id), static_cast<deadline_trace_id>(socket),
-        static_cast<void*>(record.lifetime.get()), static_cast<deadline_trace_id>(record.lifetime->generation));
     connections_[id] = std::move(record);
     return id;
 }
 
@@ -2,8 +2,6 @@
 #include <httpserver/detail/io_poll_sys.hpp>
 #include <string>
 
-#include <httpserver/detail/deadline_trace.hpp>
-
 namespace httpserver::detail::pollsys {
 
 int poll_call(poll_slot* slots, std::size_t count, int timeout_ms) {
@@ -39,10 +37,7 @@ bool close_socket(native_socket_t& socket) {
 #if defined(_WIN32)
     return ::closesocket(closing) == 0;
 #else
-    const int result = ::close(closing);
-    V3_DEADLINE_TRACE("native_close socket=%llu result=%d errno=%d now_ns=%lld\n",
-        static_cast<deadline_trace_id>(closing), result, result == 0 ? 0 : errno, deadline_trace_ns(std::chrono::steady_clock::now()));
-    return result == 0;
+    return ::close(closing) == 0;
 #endif
 }
 
 
@@ -7,8 +7,6 @@
 #include <httpserver/detail/io_connection_owner.hpp>
 #include <httpserver/detail/io_timer_sweep.hpp>
 
-#include <httpserver/detail/deadline_trace.hpp>
-
 namespace httpserver::detail {
 
 std::size_t sweep_due_timers(std::unordered_map<op_state*, std::shared_ptr<op_state>>& pending, std::mutex& mu, std::chrono::steady_clock::time_point now) {
@@ -33,9 +31,6 @@ std::size_t sweep_due_timers(std::unordered_map<op_state*, std::shared_ptr<op_st
     });
     std::size_t expired = 0;
     for (const auto& entry : due) {
-        V3_DEADLINE_TRACE("expire conn=%llu token=%p seq=%llu deadline_ns=%lld dispatch_ns=%lld terminal=%d\n",
-            static_cast<deadline_trace_id>(entry.second->connection()), static_cast<void*>(entry.second.get()),
-            static_cast<deadline_trace_id>(entry.second->sequence()), deadline_trace_ns(entry.first), deadline_trace_ns(now), entry.second->is_terminal());
         if (entry.second->claim_terminal()) {
             entry.second->owner()->enqueue(entry.second, io_result{});
             ++expired;