@rynfar/meridian 1.62.0 → 1.62.2

package/dist/{cli-k36dddkm.js → cli-7jgse65q.js}

@@ -6,11 +6,12 @@ import {
   getEffectiveProfiles,
   getRoutingMode,
   listProfiles,
+  resolveCooldownUntil,
   resolvePriorityOrder,
   resolveProfile,
   restoreActiveProfile,
   setActiveProfile
-} from "./cli-h6hfkg3s.js";
+} from "./cli-m0p2bc8v.js";
 import {
   isTrackedPlugin,
   recordError,
@@ -47,8 +48,9 @@ import {
   resolveClaudeExecutableAsync,
   resolvePassthrough,
   resolveSdkModelDefaults,
-  stripExtendedContext
-} from "./cli-p3ggjwgn.js";
+  stripExtendedContext,
+  subscriptionIncludesExtendedContext
+} from "./cli-d45dq9gf.js";
 import {
   getSetting,
   setSetting
@@ -501,6 +503,8 @@ function computeSummary(metrics, windowMs, pricingOverrides) {
       envelopeViolationCount: 0,
       requestsPerMinute: 0,
       queueWait: emptyPhase,
+      sessionQueueWait: emptyPhase,
+      sdkQueueWait: emptyPhase,
       proxyOverhead: emptyPhase,
       ttfb: emptyPhase,
       upstreamDuration: emptyPhase,
@@ -525,6 +529,8 @@ function computeSummary(metrics, windowMs, pricingOverrides) {
   const spanMs = Math.max(newest - oldest, 1);
   const requestsPerMinute = metrics.length / spanMs * 60000;
   const queueWaits = metrics.map((m) => m.queueWaitMs);
+  const sessionQueueWaits = metrics.map((m) => m.sessionQueueWaitMs ?? 0);
+  const sdkQueueWaits = metrics.map((m) => m.sdkQueueWaitMs ?? 0);
   const overheads = metrics.map((m) => m.proxyOverheadMs);
   const ttfbs = metrics.filter((m) => m.ttfbMs !== null).map((m) => m.ttfbMs);
   const upstreams = metrics.map((m) => m.upstreamDurationMs);
@@ -569,6 +575,8 @@ function computeSummary(metrics, windowMs, pricingOverrides) {
     envelopeViolationCount,
     requestsPerMinute: Math.round(requestsPerMinute * 100) / 100,
     queueWait: computePercentiles(queueWaits),
+    sessionQueueWait: computePercentiles(sessionQueueWaits),
+    sdkQueueWait: computePercentiles(sdkQueueWaits),
     proxyOverhead: computePercentiles(overheads),
     ttfb: ttfbs.length > 0 ? computePercentiles(ttfbs) : { p50: 0, p95: 0, p99: 0, min: 0, max: 0, avg: 0 },
     upstreamDuration: computePercentiles(upstreams),
@@ -1445,7 +1453,7 @@ class SqliteTelemetryStore {
         is_resume, is_passthrough, lineage_type,
         has_deferred_tools, deferred_tool_count, tool_count, discovered_tools, session_discovered_count,
         message_count, sdk_session_id,
-        status, queue_wait_ms, proxy_overhead_ms, ttfb_ms,
+        status, queue_wait_ms, session_queue_wait_ms, sdk_queue_wait_ms, proxy_overhead_ms, ttfb_ms,
         upstream_duration_ms, total_duration_ms, content_blocks, text_events, error,
         input_tokens, output_tokens, cache_read_input_tokens,
         cache_creation_input_tokens, cache_hit_rate, profile_id, envelope_violations
@@ -1454,7 +1462,7 @@ class SqliteTelemetryStore {
         @isResume, @isPassthrough, @lineageType,
         @hasDeferredTools, @deferredToolCount, @toolCount, @discoveredTools, @sessionDiscoveredCount,
         @messageCount, @sdkSessionId,
-        @status, @queueWaitMs, @proxyOverheadMs, @ttfbMs,
+        @status, @queueWaitMs, @sessionQueueWaitMs, @sdkQueueWaitMs, @proxyOverheadMs, @ttfbMs,
         @upstreamDurationMs, @totalDurationMs, @contentBlocks, @textEvents, @error,
         @inputTokens, @outputTokens, @cacheReadInputTokens,
         @cacheCreationInputTokens, @cacheHitRate, @profileId, @envelopeViolations
@@ -1484,6 +1492,8 @@ class SqliteTelemetryStore {
         sdkSessionId: metric.sdkSessionId ?? null,
         status: metric.status,
         queueWaitMs: metric.queueWaitMs,
+        sessionQueueWaitMs: metric.sessionQueueWaitMs ?? 0,
+        sdkQueueWaitMs: metric.sdkQueueWaitMs ?? 0,
         proxyOverheadMs: metric.proxyOverheadMs,
         ttfbMs: metric.ttfbMs ?? null,
         upstreamDurationMs: metric.upstreamDurationMs,
@@ -1661,6 +1671,8 @@ function rowToMetric(r) {
     sdkSessionId: r.sdk_session_id ?? undefined,
     status: r.status,
     queueWaitMs: r.queue_wait_ms,
+    sessionQueueWaitMs: r.session_queue_wait_ms ?? 0,
+    sdkQueueWaitMs: r.sdk_queue_wait_ms ?? 0,
     proxyOverheadMs: r.proxy_overhead_ms,
     ttfbMs: r.ttfb_ms ?? null,
     upstreamDurationMs: r.upstream_duration_ms,
@@ -1711,6 +1723,8 @@ CREATE TABLE IF NOT EXISTS metrics (
   sdk_session_id       TEXT,
   status               INTEGER NOT NULL,
   queue_wait_ms        REAL    NOT NULL,
+  session_queue_wait_ms REAL   NOT NULL DEFAULT 0,
+  sdk_queue_wait_ms     REAL   NOT NULL DEFAULT 0,
   proxy_overhead_ms    REAL    NOT NULL,
   ttfb_ms              REAL,
   upstream_duration_ms REAL    NOT NULL,
@@ -1748,7 +1762,9 @@ var init_sqlite = __esm(() => {
   METRICS_MIGRATIONS = [
     "ALTER TABLE metrics ADD COLUMN request_source TEXT",
     "ALTER TABLE metrics ADD COLUMN profile_id TEXT",
-    "ALTER TABLE metrics ADD COLUMN envelope_violations TEXT"
+    "ALTER TABLE metrics ADD COLUMN envelope_violations TEXT",
+    "ALTER TABLE metrics ADD COLUMN session_queue_wait_ms REAL NOT NULL DEFAULT 0",
+    "ALTER TABLE metrics ADD COLUMN sdk_queue_wait_ms REAL NOT NULL DEFAULT 0"
   ];
 });
 
@@ -6476,6 +6492,165 @@ function linkRequestAbort(signal) {
   };
 }
 
+// src/proxy/concurrency.ts
+var DEFAULT_MAX_CONCURRENT = 10;
+var didWarnInvalidMaxConcurrent = false;
+var processSdkSemaphore;
+function requestCancelledError(reason) {
+  if (reason instanceof Error)
+    return reason;
+  return new DOMException(typeof reason === "string" && reason ? reason : "The request was cancelled", "AbortError");
+}
+function resolveMaxConcurrent(source = process.env, warn = console.warn) {
+  const raw2 = source.MERIDIAN_MAX_CONCURRENT ?? source.CLAUDE_PROXY_MAX_CONCURRENT;
+  if (raw2 === undefined)
+    return DEFAULT_MAX_CONCURRENT;
+  if (raw2 && /^\d+$/.test(raw2)) {
+    const parsed = Number(raw2);
+    if (Number.isSafeInteger(parsed) && parsed > 0)
+      return parsed;
+  }
+  if (!didWarnInvalidMaxConcurrent) {
+    didWarnInvalidMaxConcurrent = true;
+    warn(`[PROXY] Invalid MERIDIAN_MAX_CONCURRENT value "${raw2}"; using default ${DEFAULT_MAX_CONCURRENT}`);
+  }
+  return DEFAULT_MAX_CONCURRENT;
+}
+
+class AbortableSemaphore {
+  limit;
+  activeCount = 0;
+  waiters = [];
+  constructor(limit) {
+    this.limit = limit;
+    if (!Number.isSafeInteger(limit) || limit <= 0) {
+      throw new RangeError("Semaphore limit must be a positive integer");
+    }
+  }
+  get snapshot() {
+    return { active: this.activeCount, queued: this.waiters.length, limit: this.limit };
+  }
+  acquire(signal) {
+    if (signal?.aborted)
+      return Promise.reject(requestCancelledError(signal.reason));
+    const enqueuedAt = Date.now();
+    if (this.activeCount < this.limit && this.waiters.length === 0) {
+      this.activeCount++;
+      return Promise.resolve(this.createLease(enqueuedAt));
+    }
+    return new Promise((resolve, reject) => {
+      const waiter = { enqueuedAt, resolve, reject, signal };
+      if (signal) {
+        waiter.abortListener = () => {
+          const index = this.waiters.indexOf(waiter);
+          if (index === -1)
+            return;
+          this.waiters.splice(index, 1);
+          reject(requestCancelledError(signal.reason));
+        };
+        signal.addEventListener("abort", waiter.abortListener, { once: true });
+      }
+      this.waiters.push(waiter);
+    });
+  }
+  createLease(enqueuedAt) {
+    let released = false;
+    return {
+      waitedMs: Date.now() - enqueuedAt,
+      release: () => {
+        if (released)
+          return;
+        released = true;
+        this.activeCount--;
+        this.grantNext();
+      }
+    };
+  }
+  grantNext() {
+    while (this.activeCount < this.limit) {
+      const waiter = this.waiters.shift();
+      if (!waiter)
+        return;
+      if (waiter.abortListener && waiter.signal) {
+        waiter.signal.removeEventListener("abort", waiter.abortListener);
+      }
+      if (waiter.signal?.aborted) {
+        waiter.reject(requestCancelledError(waiter.signal.reason));
+        continue;
+      }
+      this.activeCount++;
+      waiter.resolve(this.createLease(waiter.enqueuedAt));
+    }
+  }
+}
+function getProcessSdkSemaphore() {
+  processSdkSemaphore ??= new AbortableSemaphore(resolveMaxConcurrent());
+  return processSdkSemaphore;
+}
+
+// src/proxy/shutdown.ts
+function trackServerConnections(server) {
+  const sockets = new Set;
+  const onConnection = (socket) => {
+    sockets.add(socket);
+    socket.once("close", () => sockets.delete(socket));
+  };
+  server.on("connection", onConnection);
+  return {
+    forceCloseAll() {
+      server.closeAllConnections?.();
+      for (const socket of sockets)
+        socket.destroy();
+    },
+    dispose() {
+      server.off("connection", onConnection);
+      sockets.clear();
+    }
+  };
+}
+async function closeServerWithGracePeriod(server, options) {
+  const graceMs = Math.max(0, options.graceMs);
+  const deadlineAt = Date.now() + graceMs;
+  while (options.getInFlightCount() > 0) {
+    const remainingMs = deadlineAt - Date.now();
+    if (remainingMs <= 0)
+      break;
+    await new Promise((resolve) => {
+      const timer = setTimeout(resolve, Math.min(50, remainingMs));
+      timer.unref?.();
+    });
+  }
+  const closePromise = new Promise((resolve, reject) => {
+    server.close((error) => error ? reject(error) : resolve());
+  });
+  const remainingGraceMs = Math.max(0, deadlineAt - Date.now());
+  if (remainingGraceMs > 0) {
+    let timeout;
+    const deadline = new Promise((resolve) => {
+      timeout = setTimeout(() => resolve("timeout"), remainingGraceMs);
+      timeout.unref?.();
+    });
+    try {
+      const outcome = await Promise.race([
+        closePromise.then(() => "closed"),
+        deadline
+      ]);
+      if (outcome === "closed")
+        return;
+    } finally {
+      if (timeout)
+        clearTimeout(timeout);
+    }
+  }
+  const remaining = options.getInFlightCount();
+  options.warn?.(`[PROXY] Grace period elapsed with ${remaining} request(s) still in flight after ${graceMs}ms; forcing remaining HTTP connections closed.`);
+  if (options.forceCloseConnections)
+    options.forceCloseConnections();
+  else
+    server.closeAllConnections?.();
+  await closePromise;
+}
+
 // src/proxy/oauthUsage.ts
 var OAUTH_USAGE_URL = "https://api.anthropic.com/api/oauth/usage";
 var OAUTH_BETA_HEADER = "oauth-2025-04-20";
@@ -11299,7 +11474,6 @@ var dashboardHtml = `<!DOCTYPE html>
   .waterfall-seg { height: 100%; border-radius: 2px; min-width: 2px; }
   .waterfall-seg.queue { background: var(--queue); }
   .waterfall-seg.overhead { background: var(--yellow); }
-  .waterfall-seg.ttfb { background: var(--ttfb); }
   .waterfall-seg.response { background: var(--upstream); }
   .legend { display: flex; gap: 16px; margin-bottom: 12px; font-size: 12px; color: var(--muted); }
   .legend-dot { width: 10px; height: 10px; border-radius: 2px; display: inline-block; margin-right: 4px; vertical-align: middle; }
@@ -11555,6 +11729,8 @@ function render(s, reqs, logs) {
   html += '<div class="section"><div class="section-title">Percentiles</div>'
     + '<table class="pct-table"><thead><tr><th>Phase</th><th>p50</th><th>p95</th><th>p99</th><th>Min</th><th>Max</th><th>Avg</th></tr></thead><tbody>'
     + pctRow('Queue Wait', 'var(--queue)', s.queueWait)
+    + pctRow('Session Queue', 'var(--queue)', s.sessionQueueWait)
+    + pctRow('SDK Queue', 'var(--queue)', s.sdkQueueWait)
     + pctRow('Proxy Overhead', 'var(--yellow)', s.proxyOverhead)
     + pctRow('TTFB', 'var(--ttfb)', s.ttfb)
     + pctRow('Upstream', 'var(--upstream)', s.upstreamDuration)
@@ -11569,7 +11745,6 @@ function render(s, reqs, logs) {
   html += '<div class="legend">'
     + '<span><span class="legend-dot" style="background:var(--queue)"></span>Queue</span>'
     + '<span><span class="legend-dot" style="background:var(--yellow)"></span>Proxy</span>'
-    + '<span><span class="legend-dot" style="background:var(--ttfb)"></span>TTFB</span>'
     + '<span><span class="legend-dot" style="background:var(--upstream)"></span>Response</span>'
     + '</div>'
     + '<table><thead><tr><th>Time</th><th>Adapter</th><th>Model</th><th>Mode</th><th>Session</th><th>Status</th>'
@@ -11581,10 +11756,11 @@ function render(s, reqs, logs) {
     const statusClass = r.error ? 'status-err' : 'status-ok';
     const statusText = r.error ? r.error : r.status;
     const scale = 280 / maxTotal;
+    const sessionQW = r.sessionQueueWaitMs || 0;
+    const sdkQW = r.sdkQueueWaitMs || 0;
     const qW = Math.max(r.queueWaitMs * scale, 2);
     const ohW = Math.max((r.proxyOverheadMs || 0) * scale, 0);
-    const ttfbW = Math.max((r.ttfbMs || 0) * scale, 0);
-    const respW = Math.max((r.upstreamDurationMs - (r.ttfbMs || 0)) * scale, 2);
+    const respW = Math.max(r.upstreamDurationMs * scale, 2);
 
     const lineageBadge = r.lineageType ? '<span style="font-size:10px;padding:1px 5px;border-radius:3px;background:' + ({continuation:'var(--green)',compaction:'var(--yellow)',undo:'var(--purple)',diverged:'var(--red)',new:'var(--muted)'}[r.lineageType] || 'var(--muted)') + ';color:var(--bg)">' + r.lineageType + '</span>' : '';
     const envBadge = (r.envelopeViolations && r.envelopeViolations.length > 0) ? ' <span style="font-size:10px;padding:1px 5px;border-radius:3px;background:var(--red);color:var(--bg)" title="' + r.envelopeViolations.join(', ') + '">envelope×' + r.envelopeViolations.length + '</span>' : '';
@@ -11600,16 +11776,15 @@ function render(s, reqs, logs) {
       + '<td>' + r.mode + (r.hasDeferredTools ? (function() { var sessDisc = r.sessionDiscoveredCount || 0; var loaded = ((r.toolCount || 0) - (r.deferredToolCount || 0)) + sessDisc; var deferred = Math.max(0, (r.deferredToolCount || 0) - sessDisc); var newDisc = r.discoveredTools || []; return '<br><span style="font-size:10px;color:var(--purple)">loaded=' + loaded + ' deferred=' + deferred + '</span>' + (newDisc.length > 0 ? '<br><span style="font-size:10px;color:var(--green)">+' + newDisc.join(', +') + '</span>' : ''); })() : '') + '</td>'
       + '<td class="mono">' + sessionShort + ' ' + lineageBadge + envBadge + '<br><span style="font-size:10px;color:var(--muted)">' + msgCount + ' msgs</span></td>'
       + '<td class="' + statusClass + '">' + statusText + '</td>'
-      + '<td class="mono">' + ms(r.queueWaitMs) + '</td>'
+      + '<td class="mono">' + ms(r.queueWaitMs) + '<br><span style="font-size:9px;color:var(--muted)">session ' + ms(sessionQW) + ' / sdk ' + ms(sdkQW) + '</span></td>'
       + '<td class="mono">' + ms(r.proxyOverheadMs) + '</td>'
       + '<td class="mono">' + ms(r.ttfbMs) + '</td>'
       + '<td class="mono">' + ms(r.totalDurationMs) + '</td>'
       + '<td class="mono">' + (r.inputTokens != null ? (r.inputTokens > 1000 ? Math.round(r.inputTokens/1000) + 'k' : r.inputTokens) + ' in<br>' + (r.outputTokens > 1000 ? Math.round(r.outputTokens/1000) + 'k' : r.outputTokens || 0) + ' out' : '—') + '</td>'
       + '<td class="mono">' + (r.cacheHitRate != null ? '<span style="color:' + (r.cacheHitRate > 0.5 ? 'var(--green)' : r.cacheHitRate > 0 ? 'var(--yellow)' : 'var(--red)') + '">' + Math.round(r.cacheHitRate * 100) + '%</span>' : '—') + '</td>'
-      + '<td><div class="waterfall">'
+      + '<td><div class="waterfall" title="Queue, then proxy overhead, then upstream response. A request that replayed upstream sums every attempt into the response segment, while TTFB counts only the attempt that produced the first chunk.">'
       + '<div class="waterfall-seg queue" style="width:' + qW + 'px"></div>'
       + '<div class="waterfall-seg overhead" style="width:' + ohW + 'px"></div>'
-      + '<div class="waterfall-seg ttfb" style="width:' + ttfbW + 'px"></div>'
       + '<div class="waterfall-seg response" style="width:' + respW + 'px"></div>'
       + '</div></td>'
       + '</tr>';
@@ -12000,6 +12175,8 @@ init_percentiles();
 var DURATION_BUCKETS = [10, 25, 50, 100, 250, 500, 1000, 2500, 5000, 1e4, 30000];
 var PHASES = [
   { key: "queue_wait", extract: (m) => m.queueWaitMs },
+  { key: "session_queue_wait", extract: (m) => m.sessionQueueWaitMs ?? 0 },
+  { key: "sdk_queue_wait", extract: (m) => m.sdkQueueWaitMs ?? 0 },
   { key: "proxy_overhead", extract: (m) => m.proxyOverheadMs },
   { key: "ttfb", extract: (m) => m.ttfbMs },
   { key: "upstream", extract: (m) => m.upstreamDurationMs },
@@ -12202,11 +12379,18 @@ function isExpiredTokenError(errMsg) {
     return true;
   return false;
 }
-function isStaleSessionError(error) {
+function classifyResumeRefusal(error, stderr) {
+  if (isBusySessionError(error, stderr))
+    return "busy";
   if (!(error instanceof Error))
-    return false;
+    return;
   const msg = error.message;
-  return msg.includes("No message found with message.uuid") || msg.includes("No conversation found with session ID") || msg.includes("No conversation found to continue") || msg.includes("No conversations found to resume");
+  if (msg.includes("No message found with message.uuid"))
+    return "missing-message";
+  if (msg.includes("No conversation found with session ID") || msg.includes("No conversation found to continue") || msg.includes("No conversations found to resume")) {
+    return "unresumable";
+  }
+  return;
 }
 function isBusySessionError(error, stderr) {
   const needle = "is currently running as a background agent";
@@ -12251,11 +12435,34 @@ function makeRawTail(errMsg) {
     return;
   return head.length > RAW_TAIL_MAX ? head.slice(0, RAW_TAIL_MAX) : head;
 }
+function canRecoverCapturedToolUses(input) {
+  if (!input.passthrough)
+    return false;
+  if (input.capturedToolUses <= 0)
+    return false;
+  switch (input.reason) {
+    case "max_turns":
+    case "upstream_idle":
+      return true;
+    case "aborted":
+      return input.abortIsOurs;
+    default:
+      return false;
+  }
+}
 function extractSdkTermination(errMsg) {
   const stderrTail = extractStderrTail(errMsg);
   const haystack = `${errMsg}
 ${stderrTail ?? ""}`;
   const lower = haystack.toLowerCase();
+  if (lower.includes("upstream idle for")) {
+    const m = haystack.match(/upstream idle for (\d+)ms/i);
+    return {
+      reason: "upstream_idle",
+      ...m ? { idleMs: Number(m[1]) } : {},
+      ...stderrTail ? { stderrTail } : {}
+    };
+  }
   if (lower.includes("reached maximum number of turns")) {
     const m = haystack.match(/Reached maximum number of turns \((\d+)\)/i);
     return {
@@ -12927,7 +13134,7 @@ var FULL_CAPABILITIES = Object.freeze({
   structured_outputs: yes,
   thinking: { supported: true, types: { adaptive: yes, enabled: yes } }
 });
-function buildModelList(isMaxSubscription, now = Math.floor(Date.now() / 1000)) {
+function buildModelList(extendedContextIncluded, now = Math.floor(Date.now() / 1000)) {
   return [
     {
       id: "claude-sonnet-5",
@@ -12953,7 +13160,7 @@ function buildModelList(isMaxSubscription, now = Math.floor(Date.now() / 1000))
       created: now,
       owned_by: "anthropic",
       display_name: "Claude Opus 5",
-      context_window: isMaxSubscription ? 1e6 : 200000,
+      context_window: extendedContextIncluded ? 1e6 : 200000,
       capabilities: FULL_CAPABILITIES
     },
     {
@@ -12962,7 +13169,7 @@ function buildModelList(isMaxSubscription, now = Math.floor(Date.now() / 1000))
       created: now,
       owned_by: "anthropic",
       display_name: "Claude Opus 4.6",
-      context_window: isMaxSubscription ? 1e6 : 200000,
+      context_window: extendedContextIncluded ? 1e6 : 200000,
       capabilities: FULL_CAPABILITIES
     },
     {
@@ -12971,7 +13178,7 @@ function buildModelList(isMaxSubscription, now = Math.floor(Date.now() / 1000))
       created: now,
       owned_by: "anthropic",
       display_name: "Claude Opus 4.7",
-      context_window: isMaxSubscription ? 1e6 : 200000,
+      context_window: extendedContextIncluded ? 1e6 : 200000,
       capabilities: FULL_CAPABILITIES
     },
     {
@@ -12980,7 +13187,7 @@ function buildModelList(isMaxSubscription, now = Math.floor(Date.now() / 1000))
       created: now,
       owned_by: "anthropic",
       display_name: "Claude Opus 4.8",
-      context_window: isMaxSubscription ? 1e6 : 200000,
+      context_window: extendedContextIncluded ? 1e6 : 200000,
       capabilities: FULL_CAPABILITIES
     },
     {
@@ -12989,7 +13196,7 @@ function buildModelList(isMaxSubscription, now = Math.floor(Date.now() / 1000))
       created: now,
       owned_by: "anthropic",
       display_name: "Claude Fable 5",
-      context_window: isMaxSubscription ? 1e6 : 200000,
+      context_window: extendedContextIncluded ? 1e6 : 200000,
       capabilities: FULL_CAPABILITIES
     },
     {
@@ -19459,7 +19666,7 @@ import { join as join5, isAbsolute as isAbsolute2, extname } from "path";
 import { pathToFileURL } from "url";
 
 // src/proxy/plugins/validation.ts
-var KNOWN_ADAPTERS = ["opencode", "openai", "jcode", "crush", "droid", "pi", "forgecode", "passthrough"];
+init_detect();
 var KNOWN_HOOKS = ["onRequest", "onResponse", "onTelemetry", "onSession", "onToolUse", "onToolResult", "onError"];
 function validateTransform(exported) {
   if (exported == null || typeof exported !== "object") {
@@ -19480,8 +19687,9 @@ function validateTransform(exported) {
   }
   const warnings = [];
   if (Array.isArray(obj.adapters)) {
+    const known = listAdapterNames();
     for (const adapter of obj.adapters) {
-      if (typeof adapter === "string" && !KNOWN_ADAPTERS.includes(adapter)) {
+      if (typeof adapter === "string" && !known.includes(adapter)) {
         warnings.push(adapter);
       }
     }
@@ -20452,10 +20660,117 @@ function storeSession(sessionId, messages, claudeSessionId, workingDirectory, sd
   }
 }
 
+// src/proxy/session/turnCoordinator.ts
+function cancellationError(reason) {
+  if (reason instanceof Error)
+    return reason;
+  return new DOMException(typeof reason === "string" && reason ? reason : "The request was cancelled", "AbortError");
+}
+
+class SessionTurnCoordinator {
+  turns = new Map;
+  get size() {
+    return this.turns.size;
+  }
+  acquire(key, signal) {
+    if (signal?.aborted)
+      return Promise.reject(cancellationError(signal.reason));
+    let state = this.turns.get(key);
+    if (!state) {
+      state = { held: false, versions: new Map, waiters: [] };
+      this.turns.set(key, state);
+    }
+    const arrivedAt = Date.now();
+    const arrivedVersions = new Map(state.versions);
+    if (!state.held && state.waiters.length === 0) {
+      state.held = true;
+      return Promise.resolve(this.createLease(key, state, arrivedAt, arrivedVersions));
+    }
+    return new Promise((resolve3, reject) => {
+      const waiter = {
+        arrivedAt,
+        versions: arrivedVersions,
+        resolve: resolve3,
+        reject,
+        signal
+      };
+      if (signal) {
+        waiter.abortListener = () => {
+          const index = state.waiters.indexOf(waiter);
+          if (index === -1)
+            return;
+          state.waiters.splice(index, 1);
+          reject(cancellationError(signal.reason));
+          this.cleanup(key, state);
+        };
+        signal.addEventListener("abort", waiter.abortListener, { once: true });
+      }
+      state.waiters.push(waiter);
+    });
+  }
+  createLease(key, state, arrivedAt, arrivedVersions) {
+    let released = false;
+    const committedScopes = new Set;
+    return {
+      waitedMs: Date.now() - arrivedAt,
+      advancedWhileWaiting: (scopeKey) => (state.versions.get(scopeKey) ?? 0) > (arrivedVersions.get(scopeKey) ?? 0),
+      markCommitted: (scopeKey) => {
+        if (released || committedScopes.has(scopeKey))
+          return;
+        committedScopes.add(scopeKey);
+        state.versions.set(scopeKey, (state.versions.get(scopeKey) ?? 0) + 1);
+      },
+      release: () => {
+        if (released)
+          return;
+        released = true;
+        state.held = false;
+        while (state.waiters.length > 0) {
+          const waiter = state.waiters.shift();
+          if (waiter.abortListener && waiter.signal) {
+            waiter.signal.removeEventListener("abort", waiter.abortListener);
+          }
+          if (waiter.signal?.aborted) {
+            waiter.reject(cancellationError(waiter.signal.reason));
+            continue;
+          }
+          state.held = true;
+          waiter.resolve(this.createLease(key, state, waiter.arrivedAt, waiter.versions));
+          return;
+        }
+        this.cleanup(key, state);
+      }
+    };
+  }
+  cleanup(key, state) {
+    if (!state.held && state.waiters.length === 0 && this.turns.get(key) === state) {
+      this.turns.delete(key);
+    }
+  }
+}
+var processSessionTurns = new SessionTurnCoordinator;
+
 // src/proxy/server.ts
 var exec2 = promisify3(execCallback);
 var claudeExecutable = "";
 var UPSTREAM_IDLE_MS = envInt("UPSTREAM_IDLE_MS", 90000);
+var SHUTDOWN_GRACE_MS = envInt("SHUTDOWN_GRACE_MS", 30000);
+function totalQueueWaitMs(meta) {
+  return meta.sessionQueueWaitMs + meta.sdkQueueWaitMs;
+}
+function forkAttemptMeta(meta, attempt) {
+  if (attempt === 0)
+    return meta;
+  return {
+    ...meta,
+    queueEnteredAt: Date.now(),
+    sessionQueueWaitMs: 0,
+    sdkQueueWaitMs: 0,
+    sdkActiveDurationMs: 0,
+    currentSdkStartedAt: undefined,
+    ttfbMs: undefined
+  };
+}
 function credentialStoreForProfile(profile) {
   if (profile.type !== "claude-max")
     return;
@@ -20661,28 +20976,62 @@ function createProxyServer(config = {}) {
   const sessionDiscoveredTools = new Map;
   const sessionToolCache = new Map;
   const sessionMcpCache = new LRUMap(getMaxSessionsLimit());
-  const PENDING_STORE_WAIT_MS = 3000;
-  const PENDING_STORE_AUTO_RESOLVE_MS = 1e4;
-  const BUSY_SESSION_MAX_RETRIES = 3;
-  const BUSY_SESSION_RETRY_DELAY_MS = parseInt(process.env.MERIDIAN_BUSY_RETRY_DELAY_MS ?? "500", 10);
-  const pendingSessionStores = new Map;
-  const registerPendingStore = (key) => {
-    let resolveFn = () => {};
-    const promise = new Promise((resolve3) => {
-      const timer = setTimeout(resolve3, PENDING_STORE_AUTO_RESOLVE_MS);
-      resolveFn = () => {
-        clearTimeout(timer);
-        resolve3();
-      };
-    });
-    const entry = { promise, resolve: resolveFn };
-    pendingSessionStores.set(key, entry);
-    return () => {
-      entry.resolve();
-      if (pendingSessionStores.get(key) === entry)
-        pendingSessionStores.delete(key);
-    };
-  };
+  const RESUME_REFUSAL_MAX_RETRIES = 3;
+  const RESUME_REFUSAL_RETRY_DELAY_MS = parseInt(process.env.MERIDIAN_BUSY_RETRY_DELAY_MS ?? "500", 10);
+  const SESSION_TURN_MAX_HOLD_MS = envInt("SESSION_TURN_MAX_HOLD_MS", 600000);
+  const sdkSemaphore = finalConfig.maxConcurrent !== undefined ? new AbortableSemaphore(finalConfig.maxConcurrent) : getProcessSdkSemaphore();
+  const responseCompletions = new WeakMap;
+  let draining = false;
+  let inFlightRequests = 0;
+  const internalHopToken = randomUUID();
+  const errorEnvelope = (shape, type, message) => shape === "anthropic" ? { type: "error", error: { type, message } } : { error: { type, message, code: null } };
+  const DRAIN_MESSAGE = "Meridian is shutting down and is not accepting new requests. Retry against another instance.";
+  const drainingResponse = (shape = "anthropic") => new Response(JSON.stringify(errorEnvelope(shape, "overloaded_error", DRAIN_MESSAGE)), {
+    status: 503,
+    headers: { "Content-Type": "application/json", "x-meridian-draining": "1" }
+  });
+  async function relayInnerError(internalRes, shape) {
+    const errBody = await internalRes.text();
+    let innerType;
+    let innerMessage;
+    try {
+      const parsed = JSON.parse(errBody);
+      innerType = parsed?.error?.type;
+      innerMessage = parsed?.error?.message;
+    } catch {}
+    const payload = errorEnvelope(shape, innerType ?? "upstream_error", innerMessage ?? errBody);
+    const headers = { "Content-Type": "application/json" };
+    const drainingHeader = internalRes.headers.get("x-meridian-draining");
+    if (drainingHeader)
+      headers["x-meridian-draining"] = drainingHeader;
+    return new Response(JSON.stringify(payload), { status: internalRes.status, headers });
+  }
+  async function* runSdkQueryAttempt(params, signal, requestMeta, mode) {
+    const acquireStartedAt = Date.now();
+    let lease;
+    try {
+      lease = await sdkSemaphore.acquire(signal);
+    } catch (error) {
+      requestMeta.sdkQueueWaitMs += Date.now() - acquireStartedAt;
+      throw error;
+    }
+    requestMeta.sdkQueueWaitMs += lease.waitedMs;
+    const startedAt = Date.now();
+    requestMeta.currentSdkStartedAt = startedAt;
+    let sdkQuery;
+    try {
+      sdkQuery = query(params);
+      yield* guardUpstreamIdle(sdkQuery, UPSTREAM_IDLE_MS, (sinceLastMs) => claudeLog("upstream.stalled", { mode, sinceLastMs }));
+    } finally {
+      try {
+        if (typeof sdkQuery?.close === "function")
+          sdkQuery.close();
+      } finally {
+        requestMeta.sdkActiveDurationMs += Date.now() - startedAt;
+        lease.release();
+      }
+    }
+  }
   const pluginDir = finalConfig.pluginDir ?? join8(homedir7(), ".config", "meridian", "plugins");
   const pluginConfigPath = finalConfig.pluginConfigPath ?? join8(homedir7(), ".config", "meridian", "plugins.json");
   let loadedPlugins = [];
@@ -20705,7 +21054,6 @@ function createProxyServer(config = {}) {
   const PRIORITY_ASSIGNMENTS_MAX = 5000;
   const priorityAssignments = new AssignmentStore(PRIORITY_ASSIGNMENTS_MAX);
   const PRIORITY_DEFAULT_COOLDOWN_MS = 10 * 60000;
-  const PRIORITY_COOLDOWN_CAP_MS = 6 * 60 * 60000;
   function priorityProfileOrderSetting() {
     const env2 = process.env.MERIDIAN_PROFILE_ORDER;
     if (env2 && env2.trim())
@@ -20714,9 +21062,12 @@ function createProxyServer(config = {}) {
     return Array.isArray(setting) && setting.length > 0 ? setting : undefined;
   }
   function priorityCooldownUntil(profileId, now) {
-    const fiveHour = rateLimitStore.getAll(profileId).find((e) => e.rateLimitType === "five_hour" && (e.resetsAt ?? 0) > now && (e.status === "rejected" || (e.utilization ?? 0) >= 1));
-    const until = fiveHour?.resetsAt ?? now + PRIORITY_DEFAULT_COOLDOWN_MS;
-    return Math.min(until, now + PRIORITY_COOLDOWN_CAP_MS);
+    const windows = rateLimitStore.getAll(profileId).map((e) => ({
+      type: e.rateLimitType ?? "",
+      resetsAt: e.resetsAt,
+      exhausted: e.status === "rejected" || (e.utilization ?? 0) >= 1
+    }));
+    return resolveCooldownUntil(windows, now, PRIORITY_DEFAULT_COOLDOWN_MS);
   }
   function refinePriorityCooldown(profileId) {
     const target = getEffectiveProfiles(finalConfig.profiles).find((p) => p.id === profileId);
@@ -20725,14 +21076,15 @@ function createProxyServer(config = {}) {
     fetchOAuthUsage({ profileId, claudeConfigDir: target?.claudeConfigDir, force: true }).then((usage) => {
       if (!usage || usage.stale)
         return;
-      const fiveHour = usage.windows.find((w) => w.type === "five_hour");
-      if (!fiveHour || (fiveHour.utilization ?? 0) < 1)
-        return;
       const now = Date.now();
-      const resetsAt = fiveHour.resetsAt;
-      if (!resetsAt || resetsAt <= now)
+      const windows = usage.windows.map((w) => ({
+        type: w.type,
+        resetsAt: w.resetsAt,
+        exhausted: (w.utilization ?? 0) >= 1
+      }));
+      const until = resolveCooldownUntil(windows, now, 0);
+      if (until <= now)
         return;
-      const until = Math.min(resetsAt, now + PRIORITY_COOLDOWN_CAP_MS);
       priorityExhaustion.mark(profileId, until, "rate_limit_error");
       claudeLog("priority.cooldown_refined", { profile: profileId, until, source: "oauth_usage" });
     }).catch((err) => {
@@ -20806,19 +21158,19 @@ function createProxyServer(config = {}) {
         reader.cancel(reason).catch(() => {});
       }
     });
-    return { failed: false, errorPayload: null, errorType: null, response: new Response(rest, { status: res.status, headers: res.headers }) };
+    const response = new Response(rest, { status: res.status, headers: res.headers });
+    const completion = responseCompletions.get(res);
+    if (completion)
+      responseCompletions.set(response, completion);
+    return { failed: false, errorPayload: null, errorType: null, response };
   }
-  async function dispatchPriority(c, orderedCandidateIds, sessionKey, wantsStream) {
-    const bodyBuf = await c.req.arrayBuffer();
+  async function dispatchPriority(c, body, requestMeta, orderedCandidateIds, sessionKey, wantsStream) {
     let lastError = null;
     let lastStatus = 429;
     let previous = null;
     let previousReason = "rate_limit_error";
-    for (const candidate of orderedCandidateIds) {
-      const headers = new Headers(c.req.raw.headers);
-      headers.set("x-meridian-profile", candidate);
-      headers.set("x-meridian-priority-dispatch", "1");
-      const inner = await app.fetch(new Request(c.req.url, { method: "POST", headers, body: bodyBuf }));
+    for (const [attempt, candidate] of orderedCandidateIds.entries()) {
+      const inner = await handleMessages(c, forkAttemptMeta(requestMeta, attempt), { body, forcedProfileId: candidate });
       const sniffed = await sniffAccountFailure(inner);
       if (!sniffed.failed) {
         if (sessionKey)
@@ -20829,6 +21181,7 @@ function createProxyServer(config = {}) {
         }
         return sniffed.response;
       }
+      await responseCompletions.get(inner)?.catch(() => {});
       const reason = sniffed.errorType;
       const quotaRefusal = isQuotaRefusal(reason);
       const cooldownUntil = quotaRefusal ? priorityCooldownUntil(candidate, Date.now()) : Date.now() + PRIORITY_DEFAULT_COOLDOWN_MS;
@@ -20865,28 +21218,8 @@ data: ${JSON.stringify(lastError)}
     }
     return c.html(landingHtml);
   });
-  const MAX_CONCURRENT_SESSIONS = parseInt((process.env.MERIDIAN_MAX_CONCURRENT ?? process.env.CLAUDE_PROXY_MAX_CONCURRENT) || "10", 10);
-  let activeSessions = 0;
-  const sessionQueue = [];
-  async function acquireSession() {
-    if (activeSessions < MAX_CONCURRENT_SESSIONS) {
-      activeSessions++;
-      return;
-    }
-    return new Promise((resolve3) => {
-      sessionQueue.push({ resolve: resolve3 });
-    });
-  }
-  function releaseSession() {
-    activeSessions--;
-    const next = sessionQueue.shift();
-    if (next) {
-      activeSessions++;
-      next.resolve();
-    }
-  }
-  const handleMessages = async (c, requestMeta) => {
-    const requestStartAt = Date.now();
+  const handleMessages = async (c, requestMeta, options) => {
+    const requestStartAt = requestMeta.queueEnteredAt;
     const requestAbort = linkRequestAbort(c.req.raw.signal);
     let streamOwnsAbortLink = false;
     return withClaudeLogContext({ requestId: requestMeta.requestId, endpoint: requestMeta.endpoint }, async () => {
@@ -20902,7 +21235,7 @@ data: ${JSON.stringify(lastError)}
           }
           return textPrompt;
         };
-        const body = await c.req.json();
+        const body = options.body;
         if (!Array.isArray(body.messages)) {
           return c.json({ type: "error", error: { type: "invalid_request_error", message: "messages: Field required" } }, 400);
         }
@@ -20919,7 +21252,7 @@ data: ${JSON.stringify(lastError)}
         }
         const outputFormat = parsedOutputFormat.value;
         const routingMode = getRoutingMode(process.env.MERIDIAN_ROUTING ?? getSetting("routing"));
-        if (routingMode === "priority" && !c.req.header("x-meridian-profile")) {
+        if (routingMode === "priority" && !options.forcedProfileId && !c.req.header("x-meridian-profile")) {
           const effectivePool = getEffectiveProfiles(finalConfig.profiles);
           if (effectivePool.length > 1) {
             const { order, unknown } = resolvePriorityOrder(effectivePool.map((p) => p.id), priorityProfileOrderSetting());
@@ -20936,10 +21269,10 @@ data: ${JSON.stringify(lastError)}
               first = pick?.id ?? order[0];
             }
             const candidates = [first, ...order.filter((id) => id !== first && !priorityExhaustion.isExhausted(id))];
-            return dispatchPriority(c, candidates, sessionKey, body.stream === true);
+            return dispatchPriority(c, body, requestMeta, candidates, sessionKey, body.stream === true);
           }
         }
-        const profile = resolveProfile(finalConfig.profiles, finalConfig.defaultProfile, c.req.header("x-meridian-profile") || undefined, routingMode === "sticky" ? { routingMode, stickySessionKey: adapter.getSessionId(c, body) } : undefined);
+        const profile = resolveProfile(finalConfig.profiles, finalConfig.defaultProfile, options.forcedProfileId || c.req.header("x-meridian-profile") || undefined, routingMode === "sticky" ? { routingMode, stickySessionKey: adapter.getSessionId(c, body) } : undefined);
         const authStatus = await getClaudeAuthStatusAsync(profile.id !== "default" ? profile.id : undefined, Object.keys(profile.env).length > 0 ? profile.env : undefined);
         const agentMode = c.req.header("x-opencode-agent-mode") ?? null;
         const requestSource = c.req.header("x-meridian-source")?.slice(0, 64) || undefined;
@@ -21028,26 +21361,63 @@ data: ${JSON.stringify(lastError)}
         const betas = betaFilter.forwarded;
         const agentSessionId = adapter.getSessionId(c, body);
         const profileSessionId = profile.id !== "default" && agentSessionId ? `${profile.id}:${agentSessionId}` : agentSessionId;
+        const commitSessionTurn = () => {
+          if (profileSessionId)
+            requestMeta.sessionTurnLease?.markCommitted(profileSessionId);
+        };
         const profileScopedCwd = profile.id !== "default" ? `${clientWorkingDirectory}::profile=${profile.id}` : clientWorkingDirectory;
         const lastMessage = Array.isArray(body.messages) ? body.messages[body.messages.length - 1] : undefined;
         const lastIsToolResult = Array.isArray(lastMessage?.content) && lastMessage.content.some((b) => b?.type === "tool_result");
         const isClientDrivenLoop = adapterBase !== "claude-code" && !agentSessionId && lastIsToolResult;
         const isIndependentSession = !agentSessionId && (requestSource?.startsWith("fork-") || requestSource?.startsWith("subagent-")) || isClientDrivenLoop || false;
-        if (!isIndependentSession && profileSessionId) {
-          const pendingStore = pendingSessionStores.get(profileSessionId);
-          if (pendingStore) {
-            const waitStart = Date.now();
-            await Promise.race([
-              pendingStore.promise,
-              new Promise((resolve3) => setTimeout(resolve3, PENDING_STORE_WAIT_MS))
-            ]);
-            claudeLog("session.pending_store_awaited", { waitedMs: Date.now() - waitStart });
-          }
-        }
         let lineageResult = isIndependentSession ? { type: "diverged", reason: "independent-request" } : lookupSession(profileSessionId, body.messages || [], profileScopedCwd);
         if (lineageResult.type === "undo" && adapterBase === "opencode" && !agentSessionId) {
           lineageResult = { type: "diverged", reason: "missing-session-header" };
         }
+        const declaresConcurrentFlow = requestSource?.startsWith("fork-") === true || requestSource?.startsWith("subagent-") === true;
+        if (profileSessionId && !declaresConcurrentFlow && requestMeta.sessionTurnLease?.advancedWhileWaiting(profileSessionId) && lineageResult.type !== "continuation" && lineageResult.type !== "compaction") {
+          const reason = lineageResult.type === "diverged" ? lineageResult.reason : lineageResult.type;
+          const message = "This session advanced while the request was waiting. Retry with the latest conversation history or use a distinct session ID.";
+          claudeLog("session.concurrent_conflict", {
+            reason,
+            sessionQueueWaitMs: requestMeta.sessionQueueWaitMs
+          });
+          diagnosticLog2.session(`${requestMeta.requestId} session.concurrent_conflict reason=${reason} wait=${requestMeta.sessionQueueWaitMs}ms`, requestMeta.requestId);
+          const conflictTotalMs = Date.now() - requestStartAt;
+          const conflictQueueWaitMs = totalQueueWaitMs(requestMeta);
+          telemetryStore2.record({
+            requestId: requestMeta.requestId,
+            timestamp: Date.now(),
+            adapter: adapter.name,
+            model,
+            requestModel: requestedModel,
+            mode: stream3 ? "stream" : "non-stream",
+            isResume: false,
+            isPassthrough: envBool("PASSTHROUGH"),
+            hasDeferredTools: undefined,
+            deferredToolCount: undefined,
+            toolCount: body.tools?.length ?? 0,
+            lineageType: lineageResult.type,
+            messageCount: Array.isArray(body.messages) ? body.messages.length : 0,
+            sdkSessionId: undefined,
+            status: 400,
+            queueWaitMs: conflictQueueWaitMs,
+            sessionQueueWaitMs: requestMeta.sessionQueueWaitMs,
+            sdkQueueWaitMs: requestMeta.sdkQueueWaitMs,
+            proxyOverheadMs: Math.max(0, conflictTotalMs - conflictQueueWaitMs),
+            ttfbMs: null,
+            upstreamDurationMs: 0,
+            totalDurationMs: conflictTotalMs,
+            contentBlocks: 0,
+            textEvents: 0,
+            error: "session_turn_conflict",
+            profileId: profile.id
+          });
+          return new Response(JSON.stringify({ type: "error", error: { type: "invalid_request_error", message } }), {
+            status: 400,
+            headers: { "Content-Type": "application/json" }
+          });
+        }
         if (pipeline.some((t) => t.onSession)) {
           const mismatch = lineageResult.type === "diverged" ? lineageResult.mismatch : undefined;
           runTransformHook(pipeline, "onSession", {
@@ -21083,7 +21453,8 @@ data: ${JSON.stringify(lastError)}
         const lineageType = lineageResult.type === "diverged" && !cachedSession ? "new" : lineageResult.type;
         const msgCount = Array.isArray(body.messages) ? body.messages.length : 0;
         const toolCount = body.tools?.length ?? 0;
-        const requestLogLine = `${requestMeta.requestId} adapter=${adapter.name}${requestSource ? ` source=${requestSource}` : ""}${profile.id !== "default" ? ` profile=${profile.id}${routingMode === "sticky" ? "(sticky)" : c.req.header("x-meridian-priority-dispatch") ? "(priority)" : ""}` : ""} model=${model} stream=${stream3} tools=${toolCount} lineage=${lineageType} session=${resumeSessionId?.slice(0, 8) || "new"}${isUndo && undoRollbackUuid ? ` rollback=${undoRollbackUuid.slice(0, 8)}` : ""}${agentMode ? ` agent=${agentMode}` : ""} active=${activeSessions}/${MAX_CONCURRENT_SESSIONS} msgCount=${msgCount}`;
+        const sdkSnapshot = sdkSemaphore.snapshot;
+        const requestLogLine = `${requestMeta.requestId} adapter=${adapter.name}${requestSource ? ` source=${requestSource}` : ""}${profile.id !== "default" ? ` profile=${profile.id}${routingMode === "sticky" ? "(sticky)" : options.forcedProfileId ? "(priority)" : ""}` : ""} model=${model} stream=${stream3} tools=${toolCount} lineage=${lineageType} session=${resumeSessionId?.slice(0, 8) || "new"}${isUndo && undoRollbackUuid ? ` rollback=${undoRollbackUuid.slice(0, 8)}` : ""}${agentMode ? ` agent=${agentMode}` : ""} sdkActive=${sdkSnapshot.active}/${sdkSnapshot.limit} sdkQueued=${sdkSnapshot.queued} sessionWait=${requestMeta.sessionQueueWaitMs}ms msgCount=${msgCount}`;
         plog(`[PROXY] ${requestLogLine} msgs=${msgSummary}`);
         diagnosticLog2.session(`${requestLogLine}`, requestMeta.requestId);
         if (lineageResult.type === "diverged" && profileSessionId && !isIndependentSession) {
@@ -21098,7 +21469,9 @@ data: ${JSON.stringify(lastError)}
         claudeLog("request.received", {
           model,
           stream: stream3,
-          queueWaitMs: requestMeta.queueStartedAt - requestMeta.queueEnteredAt,
+          queueWaitMs: totalQueueWaitMs(requestMeta),
+          sessionQueueWaitMs: requestMeta.sessionQueueWaitMs,
+          sdkQueueWaitMs: requestMeta.sdkQueueWaitMs,
           messageCount: Array.isArray(body.messages) ? body.messages.length : 0,
           hasSystemPrompt: Boolean(body.system)
         });
@@ -21380,14 +21753,15 @@ data: ${JSON.stringify(lastError)}
               }
               let tokenRefreshed = false;
               let didFreshBaseRetry = false;
-              let busySessionRetries = 0;
+              let resumeRefusalRetries = 0;
               let busySessionFork = false;
+              let sawUnresumableRefusal = false;
               while (true) {
                 let didYieldContent = false;
                 const attemptStderrStart = stderrLines.length;
                 turnGenerating = true;
                 try {
-                  for await (const event of query(buildQueryOptions({
+                  for await (const event of runSdkQueryAttempt(buildQueryOptions({
                     prompt: makePrompt(),
                     model,
                     workingDirectory,
@@ -21429,7 +21803,7 @@ data: ${JSON.stringify(lastError)}
                     sdkDebug: sdkFeatures.sdkDebug,
                     additionalDirectories: sdkFeatures.additionalDirectories ? sdkFeatures.additionalDirectories.split(",").map((d) => d.trim()).filter(Boolean) : undefined,
                     advisorModel
-                  }, requestAbort.controller))) {
+                  }, requestAbort.controller), requestAbort.controller.signal, requestMeta, "non_stream")) {
                     if (event.type === "rate_limit_event") {
                       rateLimitStore.record(profile.id, event.rate_limit_info);
                     }
@@ -21444,34 +21818,38 @@ data: ${JSON.stringify(lastError)}
                   releaseHeldDenies("non_stream_attempt_error");
                   if (didYieldContent)
                     throw error;
-                  if (resumeSessionId && isBusySessionError(error, stderrLines.slice(attemptStderrStart).join(`
-`))) {
-                    if (busySessionRetries < BUSY_SESSION_MAX_RETRIES) {
-                      busySessionRetries++;
-                      claudeLog("session.busy_retry", { mode: "non_stream", attempt: busySessionRetries, resumeSessionId });
-                      plog(`[PROXY] ${requestMeta.requestId} session busy (bg agent), retrying resume ${busySessionRetries}/${BUSY_SESSION_MAX_RETRIES}`);
-                      await new Promise((resolve3) => setTimeout(resolve3, BUSY_SESSION_RETRY_DELAY_MS * busySessionRetries));
+                  const refusal = classifyResumeRefusal(error, resumeSessionId ? stderrLines.slice(attemptStderrStart).join(`
+`) : undefined);
+                  if (refusal === "unresumable")
+                    sawUnresumableRefusal = true;
+                  if (resumeSessionId && (refusal === "busy" || refusal === "unresumable")) {
+                    if (resumeRefusalRetries < RESUME_REFUSAL_MAX_RETRIES) {
+                      resumeRefusalRetries++;
+                      claudeLog("session.resume_retry", { mode: "non_stream", refusal, attempt: resumeRefusalRetries, resumeSessionId });
+                      plog(`[PROXY] ${requestMeta.requestId} resume refused (${refusal}), retrying ${resumeRefusalRetries}/${RESUME_REFUSAL_MAX_RETRIES}`);
+                      await new Promise((resolve3) => setTimeout(resolve3, RESUME_REFUSAL_RETRY_DELAY_MS * resumeRefusalRetries));
                       continue;
                     }
-                    if (!busySessionFork) {
+                    if (refusal === "busy" && !busySessionFork) {
                       busySessionFork = true;
                       claudeLog("session.busy_fork", { mode: "non_stream", resumeSessionId });
-                      plog(`[PROXY] ${requestMeta.requestId} session still busy after ${BUSY_SESSION_MAX_RETRIES} retries — forking session`);
+                      plog(`[PROXY] ${requestMeta.requestId} session still busy after ${RESUME_REFUSAL_MAX_RETRIES} retries — forking session`);
                       continue;
                     }
                   }
-                  if (isStaleSessionError(error)) {
-                    claudeLog("session.stale_uuid_retry", {
+                  if (refusal === "missing-message" || sawUnresumableRefusal) {
+                    claudeLog("session.resume_replay", {
                       mode: "non_stream",
+                      refusal,
                       rollbackUuid: undoRollbackUuid,
                       resumeSessionId
                     });
-                    plog(`[PROXY] Stale session UUID, evicting and retrying as fresh session`);
+                    plog(`[PROXY] ${requestMeta.requestId} session unusable (${refusal}), evicting and replaying as fresh session`);
                     evictSession(profileSessionId, profileScopedCwd, allMessages);
                     sdkUuidMap.length = 0;
                     for (let i = 0;i < allMessages.length; i++)
                       sdkUuidMap.push(null);
-                    yield* query(buildQueryOptions({
+                    yield* runSdkQueryAttempt(buildQueryOptions({
                       prompt: buildFreshPrompt(allMessages, sanitizeOpts),
                       model,
                       workingDirectory,
@@ -21512,7 +21890,7 @@ data: ${JSON.stringify(lastError)}
                       sdkDebug: sdkFeatures.sdkDebug,
                       additionalDirectories: sdkFeatures.additionalDirectories ? sdkFeatures.additionalDirectories.split(",").map((d) => d.trim()).filter(Boolean) : undefined,
                       advisorModel
-                    }, requestAbort.controller));
+                    }, requestAbort.controller), requestAbort.controller.signal, requestMeta, "non_stream_fresh");
                     return;
                   }
                   if (isExtraUsageRequiredError(errMsg) && hasExtendedContext(model)) {
@@ -21540,7 +21918,7 @@ data: ${JSON.stringify(lastError)}
                     sdkUuidMap.length = 0;
                     for (let i = 0;i < allMessages.length; i++)
                       sdkUuidMap.push(null);
-                    yield* query(buildQueryOptions({
+                    yield* runSdkQueryAttempt(buildQueryOptions({
                       prompt: buildFreshPrompt(allMessages, sanitizeOpts),
                       model,
                       workingDirectory,
@@ -21581,7 +21959,7 @@ data: ${JSON.stringify(lastError)}
                       sdkDebug: sdkFeatures.sdkDebug,
                       additionalDirectories: sdkFeatures.additionalDirectories ? sdkFeatures.additionalDirectories.split(",").map((d) => d.trim()).filter(Boolean) : undefined,
                       advisorModel
-                    }, requestAbort.controller));
+                    }, requestAbort.controller), requestAbort.controller.signal, requestMeta, "non_stream_fresh");
                     return;
                   }
                   if (isExpiredTokenError(errMsg) && !tokenRefreshed) {
@@ -21655,10 +22033,11 @@ data: ${JSON.stringify(lastError)}
                 }
                 if (!firstChunkAt) {
                   firstChunkAt = Date.now();
+                  requestMeta.ttfbMs ??= firstChunkAt - (requestMeta.currentSdkStartedAt ?? firstChunkAt);
                   claudeLog("upstream.first_chunk", {
                     mode: "non_stream",
                     model,
-                    ttfbMs: firstChunkAt - upstreamStartAt
+                    ttfbMs: requestMeta.ttfbMs
                   });
                 }
                 const isPassthroughTurn2 = passthrough && assistantMessages > 1 && contentBlocks.some((b) => b.type === "tool_use");
@@ -21737,7 +22116,12 @@ data: ${JSON.stringify(lastError)}
 Subprocess stderr: ${stderrOutput}`;
             }
             const sdkTerm = extractSdkTermination(error instanceof Error ? error.message : String(error));
-            const canRecoverAsToolUse = passthrough && capturedToolUses.length > 0 && (sdkTerm.reason === "max_turns" || sdkTerm.reason === "aborted");
+            const canRecoverAsToolUse = canRecoverCapturedToolUses({
+              reason: sdkTerm.reason,
+              passthrough,
+              capturedToolUses: capturedToolUses.length,
+              abortIsOurs: true
+            });
             if (canRecoverAsToolUse) {
               diagnosticLog2.session(`${requestMeta.requestId} sdk_termination_recovered ${formatSdkTermination(sdkTerm, {
                 model,
@@ -21832,7 +22216,7 @@ Subprocess stderr: ${stderrOutput}`;
             contentBlocks: contentBlocks.length,
             hasToolUse
           });
-          const nonStreamQueueWaitMs = requestMeta.queueStartedAt - requestMeta.queueEnteredAt;
+          const nonStreamQueueWaitMs = totalQueueWaitMs(requestMeta);
           checkTokenHealth(requestMeta.requestId, currentSessionId || resumeSessionId, lastUsage, allMessages.length, isResume, passthrough);
           telemetryStore2.record({
             requestId: requestMeta.requestId,
@@ -21855,9 +22239,11 @@ Subprocess stderr: ${stderrOutput}`;
             sdkSessionId: currentSessionId || resumeSessionId,
             status: 200,
             queueWaitMs: nonStreamQueueWaitMs,
-            proxyOverheadMs: upstreamStartAt - requestStartAt - nonStreamQueueWaitMs,
-            ttfbMs: firstChunkAt ? firstChunkAt - upstreamStartAt : null,
-            upstreamDurationMs: Date.now() - upstreamStartAt,
+            sessionQueueWaitMs: requestMeta.sessionQueueWaitMs,
+            sdkQueueWaitMs: requestMeta.sdkQueueWaitMs,
+            proxyOverheadMs: Math.max(0, totalDurationMs - nonStreamQueueWaitMs - requestMeta.sdkActiveDurationMs),
+            ttfbMs: requestMeta.ttfbMs ?? null,
+            upstreamDurationMs: requestMeta.sdkActiveDurationMs,
             totalDurationMs,
             contentBlocks: contentBlocks.length,
             textEvents: 0,
@@ -21878,6 +22264,7 @@ Subprocess stderr: ${stderrOutput}`;
           }
           if (currentSessionId && !isIndependentSession && !sawDuplicateToolUse) {
             storeSession(profileSessionId, body.messages || [], currentSessionId, profileScopedCwd, sdkUuidMap, lastUsage, earlyStopFired ? nextPassthroughResumeUuid : null);
+            commitSessionTurn();
           }
           const responseSessionId = currentSessionId || resumeSessionId || `session_${Date.now()}`;
           return new Response(JSON.stringify({
@@ -21901,217 +22288,139 @@ Subprocess stderr: ${stderrOutput}`;
           });
         }
         const encoder = new TextEncoder;
+        let resolveStreamCompletion = () => {};
+        const streamCompletion = new Promise((resolve3) => {
+          resolveStreamCompletion = resolve3;
+        });
         const readable = new ReadableStream({
-          async start(controller) {
-            const upstreamStartAt = Date.now();
-            let firstChunkAt;
-            let heartbeatCount = 0;
-            let streamEventsSeen = 0;
-            let eventsForwarded = 0;
-            let textEventsForwarded = 0;
-            let textCharsForwarded = 0;
-            let bytesSent = 0;
-            let streamClosed = false;
-            let awaitingEarlyStopDrain = false;
-            claudeLog("upstream.start", { mode: "stream", model });
-            const safeEnqueue = (payload, source) => {
-              if (streamClosed)
-                return false;
-              try {
-                controller.enqueue(payload);
-                bytesSent += payload.byteLength;
-                return true;
-              } catch (error) {
-                if (isClosedControllerError(error)) {
-                  streamClosed = true;
-                  claudeLog("stream.client_closed", { source, streamEventsSeen, eventsForwarded });
+          start(controller) {
+            return (async () => {
+              const upstreamStartAt = Date.now();
+              let firstChunkAt;
+              let heartbeatCount = 0;
+              let streamEventsSeen = 0;
+              let eventsForwarded = 0;
+              let textEventsForwarded = 0;
+              let textCharsForwarded = 0;
+              let bytesSent = 0;
+              let streamClosed = false;
+              let awaitingEarlyStopDrain = false;
+              claudeLog("upstream.start", { mode: "stream", model });
+              const safeEnqueue = (payload, source) => {
+                if (streamClosed)
                   return false;
+                try {
+                  controller.enqueue(payload);
+                  bytesSent += payload.byteLength;
+                  return true;
+                } catch (error) {
+                  if (isClosedControllerError(error)) {
+                    streamClosed = true;
+                    claudeLog("stream.client_closed", { source, streamEventsSeen, eventsForwarded });
+                    return false;
+                  }
+                  claudeLog("stream.enqueue_failed", {
+                    source,
+                    error: error instanceof Error ? error.message : String(error)
+                  });
+                  throw error;
                 }
-                claudeLog("stream.enqueue_failed", {
-                  source,
-                  error: error instanceof Error ? error.message : String(error)
-                });
-                throw error;
-              }
-            };
-            const sdkUuidMap = cachedSession?.sdkMessageUuids ? [...cachedSession.sdkMessageUuids] : [];
-            while (sdkUuidMap.length < allMessages.length)
-              sdkUuidMap.push(null);
-            let messageStartEmitted = false;
-            let lastUsage;
-            let hasStructuredOutput = false;
-            let structuredOutput;
-            let nextPassthroughResumeUuid;
-            const silentTurnRecoveryEnabled = env("SILENT_TURN_RECOVERY") !== "0";
-            let silentTurnRecoveryAttempted = false;
-            let silentTurnRecovered = false;
-            const streamedToolUseIds = new Set;
-            let pendingTerminalDelta = null;
-            let terminalDeltaSent = false;
-            const sendTerminalDelta = (stopReasonOverride) => {
-              if (terminalDeltaSent)
-                return;
-              const payload = stopReasonOverride ? encoder.encode(`event: message_delta
+              };
+              const sdkUuidMap = cachedSession?.sdkMessageUuids ? [...cachedSession.sdkMessageUuids] : [];
+              while (sdkUuidMap.length < allMessages.length)
+                sdkUuidMap.push(null);
+              let messageStartEmitted = false;
+              let lastUsage;
+              let hasStructuredOutput = false;
+              let structuredOutput;
+              let nextPassthroughResumeUuid;
+              const silentTurnRecoveryEnabled = env("SILENT_TURN_RECOVERY") !== "0";
+              let silentTurnRecoveryAttempted = false;
+              let silentTurnRecovered = false;
+              const streamedToolUseIds = new Set;
+              let pendingTerminalDelta = null;
+              let terminalDeltaSent = false;
+              const sendTerminalDelta = (stopReasonOverride) => {
+                if (terminalDeltaSent)
+                  return;
+                const payload = stopReasonOverride ? encoder.encode(`event: message_delta
 data: ${JSON.stringify({
-                type: "message_delta",
-                delta: { stop_reason: stopReasonOverride, stop_sequence: null },
-                usage: { output_tokens: lastUsage?.output_tokens ?? 0 }
-              })}
+                  type: "message_delta",
+                  delta: { stop_reason: stopReasonOverride, stop_sequence: null },
+                  usage: { output_tokens: lastUsage?.output_tokens ?? 0 }
+                })}
 
 `) : pendingTerminalDelta;
-              if (!payload)
-                return;
-              terminalDeltaSent = true;
-              if (safeEnqueue(payload, "terminal_message_delta"))
-                eventsForwarded += 1;
-            };
-            const openClientBlocks = new Set;
-            const resolvePendingStore = passthrough && earlyStopEnabled && !isIndependentSession && profileSessionId ? registerPendingStore(profileSessionId) : () => {};
-            let pendingEarlyStop = false;
-            let pendingEarlyStopAt = 0;
-            const fireEarlyStop = (reason) => {
-              earlyStopFired = true;
-              claudeLog("passthrough.early_stop", {
-                mode: "stream",
-                captured: capturedToolUses.length,
-                drained: awaitingEarlyStopDrain,
-                reason,
-                deferredMs: pendingEarlyStopAt ? Date.now() - pendingEarlyStopAt : 0
-              });
-              pendingEarlyStop = false;
-              flushOpenClientBlocks("early_stop");
-              sendTerminalDelta("tool_use");
-              safeEnqueue(encoder.encode(`event: message_stop
+                if (!payload)
+                  return;
+                terminalDeltaSent = true;
+                if (safeEnqueue(payload, "terminal_message_delta"))
+                  eventsForwarded += 1;
+              };
+              const openClientBlocks = new Set;
+              let pendingEarlyStop = false;
+              let pendingEarlyStopAt = 0;
+              const fireEarlyStop = (reason) => {
+                earlyStopFired = true;
+                claudeLog("passthrough.early_stop", {
+                  mode: "stream",
+                  captured: capturedToolUses.length,
+                  drained: awaitingEarlyStopDrain,
+                  reason,
+                  deferredMs: pendingEarlyStopAt ? Date.now() - pendingEarlyStopAt : 0
+                });
+                pendingEarlyStop = false;
+                flushOpenClientBlocks("early_stop");
+                sendTerminalDelta("tool_use");
+                safeEnqueue(encoder.encode(`event: message_stop
 data: ${JSON.stringify({ type: "message_stop" })}
 
 `), "early_stop");
-              requestAbort.abort("passthrough turn complete");
-              awaitingEarlyStopDrain = false;
-              if (!streamClosed) {
-                streamClosed = true;
-                try {
-                  controller.close();
-                } catch {}
-              }
-            };
-            const flushOpenClientBlocks = (source) => {
-              if (openClientBlocks.size === 0)
-                return;
-              recordEnvelopeViolations([...openClientBlocks].map((idx) => ({
-                type: "dangling_block",
-                detail: `content block ${idx} still open at ${source} close`
-              })));
-              claudeLog("stream.dangling_blocks_closed", { source, count: openClientBlocks.size });
-              for (const idx of openClientBlocks) {
-                safeEnqueue(encoder.encode(`event: content_block_stop
+                requestAbort.abort("passthrough turn complete");
+                awaitingEarlyStopDrain = false;
+                if (!streamClosed) {
+                  streamClosed = true;
+                  try {
+                    controller.close();
+                  } catch {}
+                }
+              };
+              const flushOpenClientBlocks = (source) => {
+                if (openClientBlocks.size === 0)
+                  return;
+                recordEnvelopeViolations([...openClientBlocks].map((idx) => ({
+                  type: "dangling_block",
+                  detail: `content block ${idx} still open at ${source} close`
+                })));
+                claudeLog("stream.dangling_blocks_closed", { source, count: openClientBlocks.size });
+                for (const idx of openClientBlocks) {
+                  safeEnqueue(encoder.encode(`event: content_block_stop
 data: ${JSON.stringify({ type: "content_block_stop", index: idx })}
 
 `), `${source}_close_dangling`);
-              }
-              openClientBlocks.clear();
-            };
-            let currentSessionId;
-            try {
-              const MAX_RATE_LIMIT_RETRIES = 2;
-              const RATE_LIMIT_BASE_DELAY_MS = 1000;
-              const response = async function* () {
-                let rateLimitRetries = 0;
-                if (profileCredentialStore) {
-                  await ensureFreshToken(profileCredentialStore).catch(() => {});
                 }
-                let tokenRefreshed = false;
-                let didFreshBaseRetry = false;
-                let busySessionRetries = 0;
-                let busySessionFork = false;
-                while (true) {
-                  let didYieldClientEvent = false;
-                  const attemptStderrStart = stderrLines.length;
-                  try {
-                    for await (const event of query(buildQueryOptions({
-                      prompt: makePrompt(),
-                      model,
-                      workingDirectory,
-                      clientWorkingDirectory,
-                      systemContext,
-                      claudeExecutable,
-                      passthrough,
-                      stream: true,
-                      sdkAgents,
-                      passthroughMcp,
-                      cleanEnv: profileEnv,
-                      envOverrides,
-                      hasDeferredTools,
-                      resumeSessionId,
-                      isUndo,
-                      resumeSessionAtUuid: undoRollbackUuid ?? passthroughResumeUuid,
-                      forkSession: busySessionFork || Boolean(passthroughResumeUuid) || undefined,
-                      sdkHooks,
-                      blockedTools: pipelineCtx.blockedTools,
-                      incompatibleTools: pipelineCtx.incompatibleTools,
-                      mcpServerName: adapter.getMcpServerName(),
-                      allowedMcpTools: pipelineCtx.allowedMcpTools,
-                      onStderr,
-                      effort,
-                      thinking,
-                      taskBudget,
-                      outputFormat,
-                      betas,
-                      settingSources,
-                      codeSystemPrompt: sdkFeatures.codeSystemPrompt,
-                      clientSystemPrompt: sdkFeatures.clientSystemPrompt === false ? false : undefined,
-                      memory: sdkFeatures.memory,
-                      dreaming: sdkFeatures.dreaming,
-                      sharedMemory: sdkFeatures.sharedMemory,
-                      webFetchPreflight: sdkFeatures.webFetchPreflight,
-                      claudeAiConnectors: sdkFeatures.claudeAiConnectors,
-                      maxBudgetUsd: sdkFeatures.maxBudgetUsd,
-                      fallbackModel: sdkFeatures.fallbackModel,
-                      sdkDebug: sdkFeatures.sdkDebug,
-                      additionalDirectories: sdkFeatures.additionalDirectories ? sdkFeatures.additionalDirectories.split(",").map((d) => d.trim()).filter(Boolean) : undefined,
-                      advisorModel
-                    }, requestAbort.controller))) {
-                      if (event.type === "rate_limit_event") {
-                        rateLimitStore.record(profile.id, event.rate_limit_info);
-                      }
-                      if (event.type === "stream_event") {
-                        didYieldClientEvent = true;
-                      }
-                      yield event;
-                    }
-                    return;
-                  } catch (error) {
-                    const errMsg = error instanceof Error ? error.message : String(error);
-                    if (didYieldClientEvent)
-                      throw error;
-                    if (resumeSessionId && isBusySessionError(error, stderrLines.slice(attemptStderrStart).join(`
-`))) {
-                      if (busySessionRetries < BUSY_SESSION_MAX_RETRIES) {
-                        busySessionRetries++;
-                        claudeLog("session.busy_retry", { mode: "stream", attempt: busySessionRetries, resumeSessionId });
-                        plog(`[PROXY] ${requestMeta.requestId} session busy (bg agent), retrying resume ${busySessionRetries}/${BUSY_SESSION_MAX_RETRIES}`);
-                        await new Promise((resolve3) => setTimeout(resolve3, BUSY_SESSION_RETRY_DELAY_MS * busySessionRetries));
-                        continue;
-                      }
-                      if (!busySessionFork) {
-                        busySessionFork = true;
-                        claudeLog("session.busy_fork", { mode: "stream", resumeSessionId });
-                        plog(`[PROXY] ${requestMeta.requestId} session still busy after ${BUSY_SESSION_MAX_RETRIES} retries — forking session`);
-                        continue;
-                      }
-                    }
-                    if (isStaleSessionError(error)) {
-                      claudeLog("session.stale_uuid_retry", {
-                        mode: "stream",
-                        rollbackUuid: undoRollbackUuid,
-                        resumeSessionId
-                      });
-                      plog(`[PROXY] Stale session UUID, evicting and retrying as fresh session`);
-                      evictSession(profileSessionId, profileScopedCwd, allMessages);
-                      sdkUuidMap.length = 0;
-                      for (let i = 0;i < allMessages.length; i++)
-                        sdkUuidMap.push(null);
-                      yield* query(buildQueryOptions({
-                        prompt: buildFreshPrompt(allMessages, sanitizeOpts),
+                openClientBlocks.clear();
+              };
+              let currentSessionId;
+              try {
+                const MAX_RATE_LIMIT_RETRIES = 2;
+                const RATE_LIMIT_BASE_DELAY_MS = 1000;
+                const response = async function* () {
+                  let rateLimitRetries = 0;
+                  if (profileCredentialStore) {
+                    await ensureFreshToken(profileCredentialStore).catch(() => {});
+                  }
+                  let tokenRefreshed = false;
+                  let didFreshBaseRetry = false;
+                  let resumeRefusalRetries = 0;
+                  let busySessionFork = false;
+                  let sawUnresumableRefusal = false;
+                  while (true) {
+                    let didYieldClientEvent = false;
+                    const attemptStderrStart = stderrLines.length;
+                    try {
+                      for await (const event of runSdkQueryAttempt(buildQueryOptions({
+                        prompt: makePrompt(),
                         model,
                         workingDirectory,
                         clientWorkingDirectory,
@@ -22124,9 +22433,10 @@ data: ${JSON.stringify({ type: "content_block_stop", index: idx })}
                         cleanEnv: profileEnv,
                         envOverrides,
                         hasDeferredTools,
-                        resumeSessionId: undefined,
-                        isUndo: false,
-                        resumeSessionAtUuid: undefined,
+                        resumeSessionId,
+                        isUndo,
+                        resumeSessionAtUuid: undoRollbackUuid ?? passthroughResumeUuid,
+                        forkSession: busySessionFork || Boolean(passthroughResumeUuid) || undefined,
                         sdkHooks,
                         blockedTools: pipelineCtx.blockedTools,
                         incompatibleTools: pipelineCtx.incompatibleTools,
@@ -22151,852 +22461,993 @@ data: ${JSON.stringify({ type: "content_block_stop", index: idx })}
                         sdkDebug: sdkFeatures.sdkDebug,
                         additionalDirectories: sdkFeatures.additionalDirectories ? sdkFeatures.additionalDirectories.split(",").map((d) => d.trim()).filter(Boolean) : undefined,
                         advisorModel
-                      }, requestAbort.controller));
+                      }, requestAbort.controller), requestAbort.controller.signal, requestMeta, "stream")) {
+                        if (event.type === "rate_limit_event") {
+                          rateLimitStore.record(profile.id, event.rate_limit_info);
+                        }
+                        if (event.type === "stream_event") {
+                          didYieldClientEvent = true;
+                        }
+                        yield event;
+                      }
                       return;
+                    } catch (error) {
+                      const errMsg = error instanceof Error ? error.message : String(error);
+                      if (didYieldClientEvent)
+                        throw error;
+                      const refusal = classifyResumeRefusal(error, resumeSessionId ? stderrLines.slice(attemptStderrStart).join(`
+`) : undefined);
+                      if (refusal === "unresumable")
+                        sawUnresumableRefusal = true;
+                      if (resumeSessionId && (refusal === "busy" || refusal === "unresumable")) {
+                        if (resumeRefusalRetries < RESUME_REFUSAL_MAX_RETRIES) {
+                          resumeRefusalRetries++;
+                          claudeLog("session.resume_retry", { mode: "stream", refusal, attempt: resumeRefusalRetries, resumeSessionId });
+                          plog(`[PROXY] ${requestMeta.requestId} resume refused (${refusal}), retrying ${resumeRefusalRetries}/${RESUME_REFUSAL_MAX_RETRIES}`);
+                          await new Promise((resolve3) => setTimeout(resolve3, RESUME_REFUSAL_RETRY_DELAY_MS * resumeRefusalRetries));
+                          continue;
+                        }
+                        if (refusal === "busy" && !busySessionFork) {
+                          busySessionFork = true;
+                          claudeLog("session.busy_fork", { mode: "stream", resumeSessionId });
+                          plog(`[PROXY] ${requestMeta.requestId} session still busy after ${RESUME_REFUSAL_MAX_RETRIES} retries — forking session`);
+                          continue;
+                        }
+                      }
+                      if (refusal === "missing-message" || sawUnresumableRefusal) {
+                        claudeLog("session.resume_replay", {
+                          mode: "stream",
+                          refusal,
+                          rollbackUuid: undoRollbackUuid,
+                          resumeSessionId
+                        });
+                        plog(`[PROXY] ${requestMeta.requestId} session unusable (${refusal}), evicting and replaying as fresh session`);
+                        evictSession(profileSessionId, profileScopedCwd, allMessages);
+                        sdkUuidMap.length = 0;
+                        for (let i = 0;i < allMessages.length; i++)
+                          sdkUuidMap.push(null);
+                        yield* runSdkQueryAttempt(buildQueryOptions({
+                          prompt: buildFreshPrompt(allMessages, sanitizeOpts),
+                          model,
+                          workingDirectory,
+                          clientWorkingDirectory,
+                          systemContext,
+                          claudeExecutable,
+                          passthrough,
+                          stream: true,
+                          sdkAgents,
+                          passthroughMcp,
+                          cleanEnv: profileEnv,
+                          envOverrides,
+                          hasDeferredTools,
+                          resumeSessionId: undefined,
+                          isUndo: false,
+                          resumeSessionAtUuid: undefined,
+                          sdkHooks,
+                          blockedTools: pipelineCtx.blockedTools,
+                          incompatibleTools: pipelineCtx.incompatibleTools,
+                          mcpServerName: adapter.getMcpServerName(),
+                          allowedMcpTools: pipelineCtx.allowedMcpTools,
+                          onStderr,
+                          effort,
+                          thinking,
+                          taskBudget,
+                          outputFormat,
+                          betas,
+                          settingSources,
+                          codeSystemPrompt: sdkFeatures.codeSystemPrompt,
+                          clientSystemPrompt: sdkFeatures.clientSystemPrompt === false ? false : undefined,
+                          memory: sdkFeatures.memory,
+                          dreaming: sdkFeatures.dreaming,
+                          sharedMemory: sdkFeatures.sharedMemory,
+                          webFetchPreflight: sdkFeatures.webFetchPreflight,
+                          claudeAiConnectors: sdkFeatures.claudeAiConnectors,
+                          maxBudgetUsd: sdkFeatures.maxBudgetUsd,
+                          fallbackModel: sdkFeatures.fallbackModel,
+                          sdkDebug: sdkFeatures.sdkDebug,
+                          additionalDirectories: sdkFeatures.additionalDirectories ? sdkFeatures.additionalDirectories.split(",").map((d) => d.trim()).filter(Boolean) : undefined,
+                          advisorModel
+                        }, requestAbort.controller), requestAbort.controller.signal, requestMeta, "stream_fresh");
+                        return;
+                      }
+                      if (isExtraUsageRequiredError(errMsg) && hasExtendedContext(model)) {
+                        const from = model;
+                        model = stripExtendedContext(model);
+                        recordExtendedContextUnavailable();
+                        claudeLog("upstream.context_fallback", {
+                          mode: "stream",
+                          from,
+                          to: model,
+                          reason: "extra_usage_required"
+                        });
+                        plog(`[PROXY] ${requestMeta.requestId} extra usage required for [1m], falling back to ${model} (skipping [1m] for 1h)`);
+                        continue;
+                      }
+                      if (isExtraUsageRequiredError(errMsg) && resumeSessionId && !didFreshBaseRetry) {
+                        didFreshBaseRetry = true;
+                        claudeLog("upstream.session_fallback", {
+                          mode: "stream",
+                          model,
+                          reason: "extra_usage_required_resume"
+                        });
+                        plog(`[PROXY] ${requestMeta.requestId} extra usage persisted on resumed ${model}, retrying as fresh session`);
+                        evictSession(profileSessionId, profileScopedCwd, allMessages);
+                        sdkUuidMap.length = 0;
+                        for (let i = 0;i < allMessages.length; i++)
+                          sdkUuidMap.push(null);
+                        yield* runSdkQueryAttempt(buildQueryOptions({
+                          prompt: buildFreshPrompt(allMessages, sanitizeOpts),
+                          model,
+                          workingDirectory,
+                          clientWorkingDirectory,
+                          systemContext,
+                          claudeExecutable,
+                          passthrough,
+                          stream: true,
+                          sdkAgents,
+                          passthroughMcp,
+                          cleanEnv: profileEnv,
+                          envOverrides,
+                          hasDeferredTools,
+                          resumeSessionId: undefined,
+                          isUndo: false,
+                          resumeSessionAtUuid: undefined,
+                          sdkHooks,
+                          blockedTools: pipelineCtx.blockedTools,
+                          incompatibleTools: pipelineCtx.incompatibleTools,
+                          mcpServerName: adapter.getMcpServerName(),
+                          allowedMcpTools: pipelineCtx.allowedMcpTools,
+                          onStderr,
+                          effort,
+                          thinking,
+                          taskBudget,
+                          outputFormat,
+                          betas,
+                          settingSources,
+                          codeSystemPrompt: sdkFeatures.codeSystemPrompt,
+                          clientSystemPrompt: sdkFeatures.clientSystemPrompt === false ? false : undefined,
+                          memory: sdkFeatures.memory,
+                          dreaming: sdkFeatures.dreaming,
+                          sharedMemory: sdkFeatures.sharedMemory,
+                          webFetchPreflight: sdkFeatures.webFetchPreflight,
+                          claudeAiConnectors: sdkFeatures.claudeAiConnectors,
+                          maxBudgetUsd: sdkFeatures.maxBudgetUsd,
+                          fallbackModel: sdkFeatures.fallbackModel,
+                          sdkDebug: sdkFeatures.sdkDebug,
+                          additionalDirectories: sdkFeatures.additionalDirectories ? sdkFeatures.additionalDirectories.split(",").map((d) => d.trim()).filter(Boolean) : undefined,
+                          advisorModel
+                        }, requestAbort.controller), requestAbort.controller.signal, requestMeta, "stream_fresh");
+                        return;
+                      }
+                      if (isExpiredTokenError(errMsg) && !tokenRefreshed) {
+                        tokenRefreshed = true;
+                        const refreshed = profileCredentialStore ? await refreshOAuthToken(profileCredentialStore) : false;
+                        if (refreshed) {
+                          claudeLog("token_refresh.retrying", { mode: "stream" });
+                          plog(`[PROXY] ${requestMeta.requestId} OAuth token expired — refreshed, retrying`);
+                          continue;
+                        }
+                      }
+                      if (isRateLimitError(errMsg)) {
+                        if (hasExtendedContext(model)) {
+                          const from = model;
+                          model = stripExtendedContext(model);
+                          claudeLog("upstream.context_fallback", {
+                            mode: "stream",
+                            from,
+                            to: model,
+                            reason: "rate_limit"
+                          });
+                          plog(`[PROXY] ${requestMeta.requestId} rate-limited on [1m], retrying with ${model}`);
+                          continue;
+                        }
+                        if (rateLimitRetries < MAX_RATE_LIMIT_RETRIES) {
+                          rateLimitRetries++;
+                          const delay = RATE_LIMIT_BASE_DELAY_MS * Math.pow(2, rateLimitRetries - 1);
+                          claudeLog("upstream.rate_limit_backoff", {
+                            mode: "stream",
+                            model,
+                            attempt: rateLimitRetries,
+                            maxAttempts: MAX_RATE_LIMIT_RETRIES,
+                            delayMs: delay
+                          });
+                          plog(`[PROXY] ${requestMeta.requestId} rate-limited on ${model}, retry ${rateLimitRetries}/${MAX_RATE_LIMIT_RETRIES} in ${delay}ms`);
+                          await new Promise((r) => setTimeout(r, delay));
+                          continue;
+                        }
+                      }
+                      throw error;
                     }
-                    if (isExtraUsageRequiredError(errMsg) && hasExtendedContext(model)) {
-                      const from = model;
-                      model = stripExtendedContext(model);
-                      recordExtendedContextUnavailable();
-                      claudeLog("upstream.context_fallback", {
-                        mode: "stream",
-                        from,
-                        to: model,
-                        reason: "extra_usage_required"
-                      });
-                      plog(`[PROXY] ${requestMeta.requestId} extra usage required for [1m], falling back to ${model} (skipping [1m] for 1h)`);
-                      continue;
-                    }
-                    if (isExtraUsageRequiredError(errMsg) && resumeSessionId && !didFreshBaseRetry) {
-                      didFreshBaseRetry = true;
-                      claudeLog("upstream.session_fallback", {
-                        mode: "stream",
-                        model,
-                        reason: "extra_usage_required_resume"
-                      });
-                      plog(`[PROXY] ${requestMeta.requestId} extra usage persisted on resumed ${model}, retrying as fresh session`);
-                      evictSession(profileSessionId, profileScopedCwd, allMessages);
-                      sdkUuidMap.length = 0;
-                      for (let i = 0;i < allMessages.length; i++)
-                        sdkUuidMap.push(null);
-                      yield* query(buildQueryOptions({
-                        prompt: buildFreshPrompt(allMessages, sanitizeOpts),
-                        model,
-                        workingDirectory,
-                        clientWorkingDirectory,
-                        systemContext,
-                        claudeExecutable,
-                        passthrough,
-                        stream: true,
-                        sdkAgents,
-                        passthroughMcp,
-                        cleanEnv: profileEnv,
-                        envOverrides,
-                        hasDeferredTools,
-                        resumeSessionId: undefined,
-                        isUndo: false,
-                        resumeSessionAtUuid: undefined,
-                        sdkHooks,
-                        blockedTools: pipelineCtx.blockedTools,
-                        incompatibleTools: pipelineCtx.incompatibleTools,
-                        mcpServerName: adapter.getMcpServerName(),
-                        allowedMcpTools: pipelineCtx.allowedMcpTools,
-                        onStderr,
-                        effort,
-                        thinking,
-                        taskBudget,
-                        outputFormat,
-                        betas,
-                        settingSources,
-                        codeSystemPrompt: sdkFeatures.codeSystemPrompt,
-                        clientSystemPrompt: sdkFeatures.clientSystemPrompt === false ? false : undefined,
-                        memory: sdkFeatures.memory,
-                        dreaming: sdkFeatures.dreaming,
-                        sharedMemory: sdkFeatures.sharedMemory,
-                        webFetchPreflight: sdkFeatures.webFetchPreflight,
-                        claudeAiConnectors: sdkFeatures.claudeAiConnectors,
-                        maxBudgetUsd: sdkFeatures.maxBudgetUsd,
-                        fallbackModel: sdkFeatures.fallbackModel,
-                        sdkDebug: sdkFeatures.sdkDebug,
-                        additionalDirectories: sdkFeatures.additionalDirectories ? sdkFeatures.additionalDirectories.split(",").map((d) => d.trim()).filter(Boolean) : undefined,
-                        advisorModel
-                      }, requestAbort.controller));
+                  }
+                }();
+                const heartbeat = setInterval(() => {
+                  heartbeatCount += 1;
+                  try {
+                    const payload = encoder.encode(`: ping
+
+`);
+                    if (!safeEnqueue(payload, "heartbeat")) {
+                      clearInterval(heartbeat);
                       return;
                     }
-                    if (isExpiredTokenError(errMsg) && !tokenRefreshed) {
-                      tokenRefreshed = true;
-                      const refreshed = profileCredentialStore ? await refreshOAuthToken(profileCredentialStore) : false;
-                      if (refreshed) {
-                        claudeLog("token_refresh.retrying", { mode: "stream" });
-                        plog(`[PROXY] ${requestMeta.requestId} OAuth token expired — refreshed, retrying`);
-                        continue;
+                    if (heartbeatCount % 5 === 0) {
+                      claudeLog("stream.heartbeat", { count: heartbeatCount });
+                    }
+                  } catch (error) {
+                    claudeLog("stream.heartbeat_failed", {
+                      count: heartbeatCount,
+                      error: error instanceof Error ? error.message : String(error)
+                    });
+                    clearInterval(heartbeat);
+                  }
+                }, 15000);
+                const skipBlockIndices = new Set;
+                const taskToolBlockIndices = new Set;
+                const taskToolJsonBuffer = new Map;
+                let nextClientBlockIndex = 0;
+                const sdkToClientIndex = new Map;
+                const guardedResponse = guardUpstreamIdle(response, UPSTREAM_IDLE_MS, (sinceLastMs) => claudeLog("upstream.stalled", {
+                  mode: "stream",
+                  model,
+                  sinceLastMs,
+                  streamEventsSeen,
+                  firstChunkAt: firstChunkAt ?? null
+                }));
+                try {
+                  for await (const message of guardedResponse) {
+                    if (streamClosed && !awaitingEarlyStopDrain) {
+                      break;
+                    }
+                    if (message.session_id) {
+                      currentSessionId = message.session_id;
+                    }
+                    if (message.type === "assistant" && message.uuid) {
+                      sdkUuidMap.push(message.uuid);
+                    }
+                    nextPassthroughResumeUuid = resumeBoundaryUuid(message) ?? nextPassthroughResumeUuid;
+                    if (earlyStopEnabled) {
+                      if (message.type === "assistant") {
+                        noteAssistantContent(earlyStop, message.message?.content);
+                      } else if (message.type === "user") {
+                        noteUserContent(earlyStop, message.message?.content);
+                        if (shouldEarlyStop(earlyStop) && streamedToolUseIds.size > 0) {
+                          if (openClientBlocks.size > 0) {
+                            if (!pendingEarlyStop) {
+                              pendingEarlyStop = true;
+                              pendingEarlyStopAt = Date.now();
+                              claudeLog("passthrough.early_stop_deferred", {
+                                openBlocks: openClientBlocks.size,
+                                captured: capturedToolUses.length
+                              });
+                            }
+                          } else {
+                            fireEarlyStop("immediate");
+                            break;
+                          }
+                        }
                       }
                     }
-                    if (isRateLimitError(errMsg)) {
-                      if (hasExtendedContext(model)) {
-                        const from = model;
-                        model = stripExtendedContext(model);
-                        claudeLog("upstream.context_fallback", {
-                          mode: "stream",
-                          from,
-                          to: model,
-                          reason: "rate_limit"
-                        });
-                        plog(`[PROXY] ${requestMeta.requestId} rate-limited on [1m], retrying with ${model}`);
-                        continue;
+                    if (message.type === "result") {
+                      const resultUsage = message.usage;
+                      if (resultUsage)
+                        lastUsage = { ...lastUsage, ...resultUsage };
+                      if (outputFormat && "structured_output" in message) {
+                        hasStructuredOutput = true;
+                        structuredOutput = message.structured_output;
                       }
-                      if (rateLimitRetries < MAX_RATE_LIMIT_RETRIES) {
-                        rateLimitRetries++;
-                        const delay = RATE_LIMIT_BASE_DELAY_MS * Math.pow(2, rateLimitRetries - 1);
-                        claudeLog("upstream.rate_limit_backoff", {
+                    }
+                    if (message.type === "stream_event") {
+                      streamEventsSeen += 1;
+                      if (!firstChunkAt) {
+                        firstChunkAt = Date.now();
+                        requestMeta.ttfbMs ??= firstChunkAt - (requestMeta.currentSdkStartedAt ?? firstChunkAt);
+                        claudeLog("upstream.first_chunk", {
                           mode: "stream",
                           model,
-                          attempt: rateLimitRetries,
-                          maxAttempts: MAX_RATE_LIMIT_RETRIES,
-                          delayMs: delay
+                          ttfbMs: requestMeta.ttfbMs
                         });
-                        plog(`[PROXY] ${requestMeta.requestId} rate-limited on ${model}, retry ${rateLimitRetries}/${MAX_RATE_LIMIT_RETRIES} in ${delay}ms`);
-                        await new Promise((r) => setTimeout(r, delay));
-                        continue;
                       }
-                    }
-                    throw error;
-                  }
-                }
-              }();
-              const heartbeat = setInterval(() => {
-                heartbeatCount += 1;
-                try {
-                  const payload = encoder.encode(`: ping
-
-`);
-                  if (!safeEnqueue(payload, "heartbeat")) {
-                    clearInterval(heartbeat);
-                    return;
-                  }
-                  if (heartbeatCount % 5 === 0) {
-                    claudeLog("stream.heartbeat", { count: heartbeatCount });
-                  }
-                } catch (error) {
-                  claudeLog("stream.heartbeat_failed", {
-                    count: heartbeatCount,
-                    error: error instanceof Error ? error.message : String(error)
-                  });
-                  clearInterval(heartbeat);
-                }
-              }, 15000);
-              const skipBlockIndices = new Set;
-              const taskToolBlockIndices = new Set;
-              const taskToolJsonBuffer = new Map;
-              let nextClientBlockIndex = 0;
-              const sdkToClientIndex = new Map;
-              const guardedResponse = guardUpstreamIdle(response, UPSTREAM_IDLE_MS, (sinceLastMs) => claudeLog("upstream.stalled", {
-                mode: "stream",
-                model,
-                sinceLastMs,
-                streamEventsSeen,
-                firstChunkAt: firstChunkAt ?? null
-              }));
-              try {
-                for await (const message of guardedResponse) {
-                  if (streamClosed && !awaitingEarlyStopDrain) {
-                    break;
-                  }
-                  if (message.session_id) {
-                    currentSessionId = message.session_id;
-                  }
-                  if (message.type === "assistant" && message.uuid) {
-                    sdkUuidMap.push(message.uuid);
-                  }
-                  nextPassthroughResumeUuid = resumeBoundaryUuid(message) ?? nextPassthroughResumeUuid;
-                  if (earlyStopEnabled) {
-                    if (message.type === "assistant") {
-                      noteAssistantContent(earlyStop, message.message?.content);
-                    } else if (message.type === "user") {
-                      noteUserContent(earlyStop, message.message?.content);
-                      if (shouldEarlyStop(earlyStop) && streamedToolUseIds.size > 0) {
-                        if (openClientBlocks.size > 0) {
-                          if (!pendingEarlyStop) {
-                            pendingEarlyStop = true;
-                            pendingEarlyStopAt = Date.now();
-                            claudeLog("passthrough.early_stop_deferred", {
-                              openBlocks: openClientBlocks.size,
-                              captured: capturedToolUses.length
-                            });
-                          }
-                        } else {
-                          fireEarlyStop("immediate");
-                          break;
+                      const event = message.event;
+                      const eventType = event.type;
+                      const eventIndex = event.index;
+                      if (eventType === "message_delta" || eventType === "message_stop" || eventType === "message_start" && messageStartEmitted) {
+                        releaseHeldDenies(eventType);
+                      }
+                      if (eventType === "message_start") {
+                        turnGenerating = true;
+                      }
+                      if (outputFormat) {
+                        if (eventType === "message_start") {
+                          const startUsage = event.message?.usage;
+                          if (startUsage)
+                            lastUsage = { ...lastUsage, ...startUsage };
+                        } else if (eventType === "message_delta") {
+                          const deltaUsage = event.usage;
+                          if (deltaUsage)
+                            lastUsage = { ...lastUsage, ...deltaUsage };
                         }
+                        continue;
                       }
-                    }
-                  }
-                  if (message.type === "result") {
-                    const resultUsage = message.usage;
-                    if (resultUsage)
-                      lastUsage = { ...lastUsage, ...resultUsage };
-                    if (outputFormat && "structured_output" in message) {
-                      hasStructuredOutput = true;
-                      structuredOutput = message.structured_output;
-                    }
-                  }
-                  if (message.type === "stream_event") {
-                    streamEventsSeen += 1;
-                    if (!firstChunkAt) {
-                      firstChunkAt = Date.now();
-                      claudeLog("upstream.first_chunk", {
-                        mode: "stream",
-                        model,
-                        ttfbMs: firstChunkAt - upstreamStartAt
-                      });
-                    }
-                    const event = message.event;
-                    const eventType = event.type;
-                    const eventIndex = event.index;
-                    if (eventType === "message_delta" || eventType === "message_stop" || eventType === "message_start" && messageStartEmitted) {
-                      releaseHeldDenies(eventType);
-                    }
-                    if (eventType === "message_start") {
-                      turnGenerating = true;
-                    }
-                    if (outputFormat) {
                       if (eventType === "message_start") {
+                        skipBlockIndices.clear();
+                        sdkToClientIndex.clear();
                         const startUsage = event.message?.usage;
                         if (startUsage)
                           lastUsage = { ...lastUsage, ...startUsage };
-                      } else if (eventType === "message_delta") {
-                        const deltaUsage = event.usage;
-                        if (deltaUsage)
-                          lastUsage = { ...lastUsage, ...deltaUsage };
-                      }
-                      continue;
-                    }
-                    if (eventType === "message_start") {
-                      skipBlockIndices.clear();
-                      sdkToClientIndex.clear();
-                      const startUsage = event.message?.usage;
-                      if (startUsage)
-                        lastUsage = { ...lastUsage, ...startUsage };
-                      if (messageStartEmitted) {
-                        if (passthrough && streamedToolUseIds.size > 0) {
-                          flushOpenClientBlocks("turn2_suppression");
-                          sendTerminalDelta("tool_use");
-                          safeEnqueue(encoder.encode(`event: message_stop
+                        if (messageStartEmitted) {
+                          if (passthrough && streamedToolUseIds.size > 0) {
+                            flushOpenClientBlocks("turn2_suppression");
+                            sendTerminalDelta("tool_use");
+                            safeEnqueue(encoder.encode(`event: message_stop
 data: ${JSON.stringify({ type: "message_stop" })}
 
 `), "passthrough_turn2_stop");
-                          claudeLog("passthrough.turn2_suppressed", { mode: "stream", toolUses: streamedToolUseIds.size });
-                          streamClosed = true;
-                          controller.close();
-                          break;
+                            claudeLog("passthrough.turn2_suppressed", { mode: "stream", toolUses: streamedToolUseIds.size });
+                            streamClosed = true;
+                            controller.close();
+                            break;
+                          }
+                          continue;
                         }
-                        continue;
-                      }
-                      messageStartEmitted = true;
-                    }
-                    if (eventType === "message_stop") {
-                      continue;
-                    }
-                    if (eventType === "content_block_start") {
-                      const block = event.content_block;
-                      if (pipelineCtx.hidesInternalTools && (block?.type === "tool_use" || (block?.type === "thinking" || block?.type === "redacted_thinking") && !sdkFeatures.thinkingPassthrough)) {
-                        if (eventIndex !== undefined)
-                          skipBlockIndices.add(eventIndex);
-                        claudeLog("internal_tool.hidden", { mode: "stream", type: block?.type, name: block?.name, index: eventIndex });
-                        continue;
+                        messageStartEmitted = true;
                       }
-                      if (passthrough && !pipelineCtx.supportsThinking && !sdkFeatures.thinkingPassthrough && (block?.type === "thinking" || block?.type === "redacted_thinking")) {
-                        if (eventIndex !== undefined)
-                          skipBlockIndices.add(eventIndex);
-                        claudeLog("passthrough.thinking_stripped", { mode: "stream", type: block.type, index: eventIndex });
+                      if (eventType === "message_stop") {
                         continue;
                       }
-                      if (block?.type === "tool_use" && typeof block.name === "string") {
-                        if (block.name === "ToolSearch") {
+                      if (eventType === "content_block_start") {
+                        const block = event.content_block;
+                        if (pipelineCtx.hidesInternalTools && (block?.type === "tool_use" || (block?.type === "thinking" || block?.type === "redacted_thinking") && !sdkFeatures.thinkingPassthrough)) {
                           if (eventIndex !== undefined)
                             skipBlockIndices.add(eventIndex);
+                          claudeLog("internal_tool.hidden", { mode: "stream", type: block?.type, name: block?.name, index: eventIndex });
                           continue;
                         }
-                        if (passthrough && block.name.startsWith(PASSTHROUGH_MCP_PREFIX)) {
-                          block.name = stripMcpPrefix(block.name);
-                          if (block.id)
-                            streamedToolUseIds.add(block.id);
-                        } else if (block.name.startsWith("mcp__")) {
+                        if (passthrough && !pipelineCtx.supportsThinking && !sdkFeatures.thinkingPassthrough && (block?.type === "thinking" || block?.type === "redacted_thinking")) {
                           if (eventIndex !== undefined)
                             skipBlockIndices.add(eventIndex);
+                          claudeLog("passthrough.thinking_stripped", { mode: "stream", type: block.type, index: eventIndex });
                           continue;
-                        } else if (passthrough && block.id) {
-                          streamedToolUseIds.add(block.id);
                         }
-                        if (passthrough && eventIndex !== undefined && block.name.toLowerCase() === "task") {
-                          taskToolBlockIndices.add(eventIndex);
+                        if (block?.type === "tool_use" && typeof block.name === "string") {
+                          if (block.name === "ToolSearch") {
+                            if (eventIndex !== undefined)
+                              skipBlockIndices.add(eventIndex);
+                            continue;
+                          }
+                          if (passthrough && block.name.startsWith(PASSTHROUGH_MCP_PREFIX)) {
+                            block.name = stripMcpPrefix(block.name);
+                            if (block.id)
+                              streamedToolUseIds.add(block.id);
+                          } else if (block.name.startsWith("mcp__")) {
+                            if (eventIndex !== undefined)
+                              skipBlockIndices.add(eventIndex);
+                            continue;
+                          } else if (passthrough && block.id) {
+                            streamedToolUseIds.add(block.id);
+                          }
+                          if (passthrough && eventIndex !== undefined && block.name.toLowerCase() === "task") {
+                            taskToolBlockIndices.add(eventIndex);
+                          }
+                        }
+                        if (eventIndex !== undefined) {
+                          sdkToClientIndex.set(eventIndex, nextClientBlockIndex++);
                         }
                       }
-                      if (eventIndex !== undefined) {
-                        sdkToClientIndex.set(eventIndex, nextClientBlockIndex++);
-                      }
-                    }
-                    if (eventIndex !== undefined && skipBlockIndices.has(eventIndex)) {
-                      continue;
-                    }
-                    if (eventIndex !== undefined && sdkToClientIndex.has(eventIndex)) {
-                      event.index = sdkToClientIndex.get(eventIndex);
-                    }
-                    if (eventType === "message_delta") {
-                      const deltaUsage = event.usage;
-                      if (deltaUsage)
-                        lastUsage = { ...lastUsage, ...deltaUsage };
-                      const stopReason = event.delta?.stop_reason;
-                      if (stopReason === "tool_use" && skipBlockIndices.size > 0) {
+                      if (eventIndex !== undefined && skipBlockIndices.has(eventIndex)) {
                         continue;
                       }
-                    }
-                    if (passthrough && eventIndex !== undefined && taskToolBlockIndices.has(eventIndex)) {
-                      if (eventType === "content_block_delta") {
-                        const delta = event.delta;
-                        if (delta?.type === "input_json_delta" && typeof delta.partial_json === "string") {
-                          const prev = taskToolJsonBuffer.get(eventIndex) ?? "";
-                          taskToolJsonBuffer.set(eventIndex, prev + delta.partial_json);
+                      if (eventIndex !== undefined && sdkToClientIndex.has(eventIndex)) {
+                        event.index = sdkToClientIndex.get(eventIndex);
+                      }
+                      if (eventType === "message_delta") {
+                        const deltaUsage = event.usage;
+                        if (deltaUsage)
+                          lastUsage = { ...lastUsage, ...deltaUsage };
+                        const stopReason = event.delta?.stop_reason;
+                        if (stopReason === "tool_use" && skipBlockIndices.size > 0) {
                           continue;
                         }
                       }
-                      if (eventType === "content_block_stop") {
-                        const buffered = taskToolJsonBuffer.get(eventIndex);
-                        if (buffered) {
-                          let fixed = buffered;
-                          try {
-                            const parsed = JSON.parse(buffered);
-                            if (typeof parsed.subagent_type === "string") {
-                              parsed.subagent_type = resolveAgentAlias(parsed.subagent_type, validAgentNames);
-                            }
-                            fixed = JSON.stringify(parsed);
-                          } catch {}
-                          const clientIdx = sdkToClientIndex.get(eventIndex) ?? eventIndex;
-                          safeEnqueue(encoder.encode(`event: content_block_delta
+                      if (passthrough && eventIndex !== undefined && taskToolBlockIndices.has(eventIndex)) {
+                        if (eventType === "content_block_delta") {
+                          const delta = event.delta;
+                          if (delta?.type === "input_json_delta" && typeof delta.partial_json === "string") {
+                            const prev = taskToolJsonBuffer.get(eventIndex) ?? "";
+                            taskToolJsonBuffer.set(eventIndex, prev + delta.partial_json);
+                            continue;
+                          }
+                        }
+                        if (eventType === "content_block_stop") {
+                          const buffered = taskToolJsonBuffer.get(eventIndex);
+                          if (buffered) {
+                            let fixed = buffered;
+                            try {
+                              const parsed = JSON.parse(buffered);
+                              if (typeof parsed.subagent_type === "string") {
+                                parsed.subagent_type = resolveAgentAlias(parsed.subagent_type, validAgentNames);
+                              }
+                              fixed = JSON.stringify(parsed);
+                            } catch {}
+                            const clientIdx = sdkToClientIndex.get(eventIndex) ?? eventIndex;
+                            safeEnqueue(encoder.encode(`event: content_block_delta
 data: ${JSON.stringify({
-                            type: "content_block_delta",
-                            index: clientIdx,
-                            delta: { type: "input_json_delta", partial_json: fixed }
-                          })}
+                              type: "content_block_delta",
+                              index: clientIdx,
+                              delta: { type: "input_json_delta", partial_json: fixed }
+                            })}
 
 `), "task_tool_fixed_delta");
-                          taskToolJsonBuffer.delete(eventIndex);
+                            taskToolJsonBuffer.delete(eventIndex);
+                          }
                         }
                       }
-                    }
-                    if (eventType === "content_block_delta" && event.delta?.type === "text_delta" && shouldInjectSilentTurn({
-                      raw: env("DEBUG_FORCE_SILENT_TURN"),
-                      sessionId: agentSessionId
-                    })) {
-                      claudeLog("debug.silent_turn_injected", { sessionId: agentSessionId });
-                      continue;
-                    }
-                    stripNonStandardStreamFields(event);
-                    const payload = encoder.encode(`event: ${eventType}
+                      if (eventType === "content_block_delta" && event.delta?.type === "text_delta" && shouldInjectSilentTurn({
+                        raw: env("DEBUG_FORCE_SILENT_TURN"),
+                        sessionId: agentSessionId
+                      })) {
+                        claudeLog("debug.silent_turn_injected", { sessionId: agentSessionId });
+                        continue;
+                      }
+                      stripNonStandardStreamFields(event);
+                      const payload = encoder.encode(`event: ${eventType}
 data: ${JSON.stringify(event)}
 
 `);
-                    if (eventType === "message_delta") {
-                      pendingTerminalDelta = payload;
-                    } else {
-                      if (!safeEnqueue(payload, `stream_event:${eventType}`)) {
-                        break;
+                      if (eventType === "message_delta") {
+                        pendingTerminalDelta = payload;
+                      } else {
+                        if (!safeEnqueue(payload, `stream_event:${eventType}`)) {
+                          break;
+                        }
+                        eventsForwarded += 1;
                       }
-                      eventsForwarded += 1;
-                    }
-                    if (eventType === "content_block_start") {
-                      const idx = event.index;
-                      if (typeof idx === "number")
-                        openClientBlocks.add(idx);
-                    } else if (eventType === "content_block_stop") {
-                      const idx = event.index;
-                      if (typeof idx === "number")
-                        openClientBlocks.delete(idx);
-                      if (pendingEarlyStop && openClientBlocks.size === 0) {
-                        fireEarlyStop("blocks_closed");
-                        break;
+                      if (eventType === "content_block_start") {
+                        const idx = event.index;
+                        if (typeof idx === "number")
+                          openClientBlocks.add(idx);
+                      } else if (eventType === "content_block_stop") {
+                        const idx = event.index;
+                        if (typeof idx === "number")
+                          openClientBlocks.delete(idx);
+                        if (pendingEarlyStop && openClientBlocks.size === 0) {
+                          fireEarlyStop("blocks_closed");
+                          break;
+                        }
                       }
-                    }
-                    if (passthrough && eventType === "message_delta" && event.delta?.stop_reason === "tool_use" && streamedToolUseIds.size > 0) {
-                      flushOpenClientBlocks("drain_close");
-                      sendTerminalDelta();
-                      safeEnqueue(encoder.encode(`event: message_stop
+                      if (passthrough && eventType === "message_delta" && event.delta?.stop_reason === "tool_use" && streamedToolUseIds.size > 0) {
+                        flushOpenClientBlocks("drain_close");
+                        sendTerminalDelta();
+                        safeEnqueue(encoder.encode(`event: message_stop
 data: ${JSON.stringify({ type: "message_stop" })}
 
 `), "passthrough_tool_stream_stop");
-                      streamClosed = true;
-                      controller.close();
-                      if (earlyStopEnabled) {
-                        awaitingEarlyStopDrain = true;
-                        continue;
+                        streamClosed = true;
+                        controller.close();
+                        if (earlyStopEnabled) {
+                          awaitingEarlyStopDrain = true;
+                          continue;
+                        }
+                        break;
                       }
-                      break;
-                    }
-                    if (eventType === "content_block_delta") {
-                      const delta = event.delta;
-                      if (delta?.type === "text_delta") {
-                        textEventsForwarded += 1;
-                        if (typeof delta.text === "string")
-                          textCharsForwarded += delta.text.length;
+                      if (eventType === "content_block_delta") {
+                        const delta = event.delta;
+                        if (delta?.type === "text_delta") {
+                          textEventsForwarded += 1;
+                          if (typeof delta.text === "string")
+                            textCharsForwarded += delta.text.length;
+                        }
                       }
                     }
                   }
+                } finally {
+                  clearInterval(heartbeat);
+                  releaseHeldDenies("stream_loop_exit");
                 }
-              } finally {
-                clearInterval(heartbeat);
-                releaseHeldDenies("stream_loop_exit");
-              }
-              if (outputFormat) {
-                if (!hasStructuredOutput) {
-                  throw new Error("Structured output was requested but the SDK returned no structured_output result");
-                }
-                const text = structuredOutputText(structuredOutput);
-                const messageId = `msg_${Date.now()}`;
-                safeEnqueue(encoder.encode(`event: message_start
-data: ${JSON.stringify({
-                  type: "message_start",
-                  message: {
-                    id: messageId,
-                    type: "message",
-                    role: "assistant",
-                    content: [],
-                    model: body.model,
-                    stop_reason: null,
-                    stop_sequence: null,
-                    usage: { input_tokens: lastUsage?.input_tokens ?? 0, output_tokens: 0 }
+                if (outputFormat) {
+                  if (!hasStructuredOutput) {
+                    throw new Error("Structured output was requested but the SDK returned no structured_output result");
                   }
-                })}
+                  const text = structuredOutputText(structuredOutput);
+                  const messageId = `msg_${Date.now()}`;
+                  safeEnqueue(encoder.encode(`event: message_start
+data: ${JSON.stringify({
+                    type: "message_start",
+                    message: {
+                      id: messageId,
+                      type: "message",
+                      role: "assistant",
+                      content: [],
+                      model: body.model,
+                      stop_reason: null,
+                      stop_sequence: null,
+                      usage: { input_tokens: lastUsage?.input_tokens ?? 0, output_tokens: 0 }
+                    }
+                  })}
 
 `), "structured_message_start");
-                safeEnqueue(encoder.encode(`event: content_block_start
+                  safeEnqueue(encoder.encode(`event: content_block_start
 data: ${JSON.stringify({
-                  type: "content_block_start",
-                  index: 0,
-                  content_block: { type: "text", text: "" }
-                })}
+                    type: "content_block_start",
+                    index: 0,
+                    content_block: { type: "text", text: "" }
+                  })}
 
 `), "structured_block_start");
-                safeEnqueue(encoder.encode(`event: content_block_delta
+                  safeEnqueue(encoder.encode(`event: content_block_delta
 data: ${JSON.stringify({
-                  type: "content_block_delta",
-                  index: 0,
-                  delta: { type: "text_delta", text }
-                })}
+                    type: "content_block_delta",
+                    index: 0,
+                    delta: { type: "text_delta", text }
+                  })}
 
 `), "structured_text_delta");
-                safeEnqueue(encoder.encode(`event: content_block_stop
+                  safeEnqueue(encoder.encode(`event: content_block_stop
 data: ${JSON.stringify({ type: "content_block_stop", index: 0 })}
 
 `), "structured_block_stop");
-                safeEnqueue(encoder.encode(`event: message_delta
+                  safeEnqueue(encoder.encode(`event: message_delta
 data: ${JSON.stringify({
-                  type: "message_delta",
-                  delta: { stop_reason: "end_turn", stop_sequence: null },
-                  usage: { output_tokens: lastUsage?.output_tokens ?? 0 }
-                })}
+                    type: "message_delta",
+                    delta: { stop_reason: "end_turn", stop_sequence: null },
+                    usage: { output_tokens: lastUsage?.output_tokens ?? 0 }
+                  })}
 
 `), "structured_message_delta");
-                messageStartEmitted = true;
-                eventsForwarded += 5;
-                textEventsForwarded += 1;
-                textCharsForwarded += text.length;
-              }
-              if (passthrough) {
-                recordEnvelopeViolations(checkUndeliveredToolUses(capturedToolUses, streamedToolUseIds));
-              }
-              claudeLog("upstream.completed", {
-                mode: "stream",
-                model,
-                durationMs: Date.now() - upstreamStartAt,
-                streamEventsSeen,
-                eventsForwarded,
-                textEventsForwarded
-              });
-              if (lastUsage)
-                logUsage(requestMeta.requestId, lastUsage);
-              const sessId = currentSessionId || resumeSessionId;
-              if (sessId && discoveredTools.size > 0) {
-                if (!sessionDiscoveredTools.has(sessId))
-                  sessionDiscoveredTools.set(sessId, new Set);
-                for (const t of discoveredTools)
-                  sessionDiscoveredTools.get(sessId).add(t);
-                const newNames = [...discoveredTools].join(", ");
-                const allNames = [...sessionDiscoveredTools.get(sessId)];
-                plog(`[PROXY] ${requestMeta.requestId} discovered=${discoveredTools.size} (${newNames}) session_total=${allNames.length}`);
-              }
-              if (currentSessionId && !isIndependentSession && !sawDuplicateToolUse) {
-                storeSession(profileSessionId, body.messages || [], currentSessionId, profileScopedCwd, sdkUuidMap, lastUsage, earlyStopFired ? nextPassthroughResumeUuid : null);
-              }
-              resolvePendingStore();
-              const classifyNow = () => classifyTurnOutcome({
-                textEvents: textEventsForwarded,
-                toolUses: streamedToolUseIds.size,
-                blocksForwarded: eventsForwarded
-              });
-              const preRecoveryOutcome = classifyNow();
-              if (!streamClosed && messageStartEmitted && shouldAttemptRecovery({
-                outcome: preRecoveryOutcome,
-                alreadyAttempted: silentTurnRecoveryAttempted,
-                clientGone: streamClosed,
-                sessionId: currentSessionId || resumeSessionId,
-                enabled: silentTurnRecoveryEnabled
-              })) {
-                silentTurnRecoveryAttempted = true;
-                const capturedBeforeRecovery = capturedToolUses.length;
-                claudeLog("response.silent_turn_recovery", {
+                  messageStartEmitted = true;
+                  eventsForwarded += 5;
+                  textEventsForwarded += 1;
+                  textCharsForwarded += text.length;
+                }
+                if (passthrough) {
+                  recordEnvelopeViolations(checkUndeliveredToolUses(capturedToolUses, streamedToolUseIds));
+                }
+                claudeLog("upstream.completed", {
                   mode: "stream",
-                  kind: preRecoveryOutcome.kind,
-                  reason: preRecoveryOutcome.kind === "silent" ? preRecoveryOutcome.reason : undefined,
-                  sdkSessionId: currentSessionId || resumeSessionId
+                  model,
+                  durationMs: Date.now() - upstreamStartAt,
+                  streamEventsSeen,
+                  eventsForwarded,
+                  textEventsForwarded
                 });
-                const recoveryLifter = createRecoveryLifter(() => nextClientBlockIndex++);
-                let recoverySessionId;
-                let recoveryBoundaryUuid;
-                try {
-                  for await (const event of guardUpstreamIdle(query(buildQueryOptions({
-                    prompt: SILENT_TURN_NUDGE,
-                    model,
-                    workingDirectory,
-                    clientWorkingDirectory,
-                    systemContext,
-                    claudeExecutable,
-                    passthrough,
-                    stream: true,
-                    sdkAgents,
-                    passthroughMcp,
-                    cleanEnv: profileEnv,
-                    envOverrides,
-                    hasDeferredTools,
-                    resumeSessionId: currentSessionId || resumeSessionId,
-                    isUndo: false,
-                    resumeSessionAtUuid: nextPassthroughResumeUuid,
-                    forkSession: true,
-                    sdkHooks,
-                    blockedTools: pipelineCtx.blockedTools,
-                    incompatibleTools: pipelineCtx.incompatibleTools,
-                    mcpServerName: adapter.getMcpServerName(),
-                    allowedMcpTools: pipelineCtx.allowedMcpTools,
-                    onStderr,
-                    effort,
-                    thinking,
-                    taskBudget,
-                    outputFormat,
-                    betas,
-                    settingSources,
-                    codeSystemPrompt: sdkFeatures.codeSystemPrompt,
-                    clientSystemPrompt: sdkFeatures.clientSystemPrompt === false ? false : undefined,
-                    memory: sdkFeatures.memory,
-                    dreaming: sdkFeatures.dreaming,
-                    sharedMemory: sdkFeatures.sharedMemory,
-                    webFetchPreflight: sdkFeatures.webFetchPreflight,
-                    claudeAiConnectors: sdkFeatures.claudeAiConnectors,
-                    maxBudgetUsd: sdkFeatures.maxBudgetUsd,
-                    fallbackModel: sdkFeatures.fallbackModel,
-                    sdkDebug: sdkFeatures.sdkDebug,
-                    additionalDirectories: sdkFeatures.additionalDirectories ? sdkFeatures.additionalDirectories.split(",").map((d) => d.trim()).filter(Boolean) : undefined,
-                    advisorModel
-                  }, requestAbort.controller)), UPSTREAM_IDLE_MS, (sinceLastMs) => claudeLog("upstream.stalled", { mode: "silent_recovery", model, sinceLastMs }))) {
-                    const recoveryMessage = event;
-                    if (recoveryMessage.session_id)
-                      recoverySessionId = recoveryMessage.session_id;
-                    recoveryBoundaryUuid = resumeBoundaryUuid(recoveryMessage) ?? recoveryBoundaryUuid;
-                    if (recoveryMessage.type !== "stream_event")
-                      continue;
-                    const lifted = recoveryLifter.lift(event.event);
-                    if (!lifted)
-                      continue;
-                    safeEnqueue(encoder.encode(`event: ${lifted.frame.type}
+                if (lastUsage)
+                  logUsage(requestMeta.requestId, lastUsage);
+                const sessId = currentSessionId || resumeSessionId;
+                if (sessId && discoveredTools.size > 0) {
+                  if (!sessionDiscoveredTools.has(sessId))
+                    sessionDiscoveredTools.set(sessId, new Set);
+                  for (const t of discoveredTools)
+                    sessionDiscoveredTools.get(sessId).add(t);
+                  const newNames = [...discoveredTools].join(", ");
+                  const allNames = [...sessionDiscoveredTools.get(sessId)];
+                  plog(`[PROXY] ${requestMeta.requestId} discovered=${discoveredTools.size} (${newNames}) session_total=${allNames.length}`);
+                }
+                if (currentSessionId && !isIndependentSession && !sawDuplicateToolUse) {
+                  storeSession(profileSessionId, body.messages || [], currentSessionId, profileScopedCwd, sdkUuidMap, lastUsage, earlyStopFired ? nextPassthroughResumeUuid : null);
+                  commitSessionTurn();
+                }
+                const classifyNow = () => classifyTurnOutcome({
+                  textEvents: textEventsForwarded,
+                  toolUses: streamedToolUseIds.size,
+                  blocksForwarded: eventsForwarded
+                });
+                const preRecoveryOutcome = classifyNow();
+                if (!streamClosed && messageStartEmitted && shouldAttemptRecovery({
+                  outcome: preRecoveryOutcome,
+                  alreadyAttempted: silentTurnRecoveryAttempted,
+                  clientGone: streamClosed,
+                  sessionId: currentSessionId || resumeSessionId,
+                  enabled: silentTurnRecoveryEnabled
+                })) {
+                  silentTurnRecoveryAttempted = true;
+                  const capturedBeforeRecovery = capturedToolUses.length;
+                  claudeLog("response.silent_turn_recovery", {
+                    mode: "stream",
+                    kind: preRecoveryOutcome.kind,
+                    reason: preRecoveryOutcome.kind === "silent" ? preRecoveryOutcome.reason : undefined,
+                    sdkSessionId: currentSessionId || resumeSessionId
+                  });
+                  const recoveryLifter = createRecoveryLifter(() => nextClientBlockIndex++);
+                  let recoverySessionId;
+                  let recoveryBoundaryUuid;
+                  try {
+                    for await (const event of runSdkQueryAttempt(buildQueryOptions({
+                      prompt: SILENT_TURN_NUDGE,
+                      model,
+                      workingDirectory,
+                      clientWorkingDirectory,
+                      systemContext,
+                      claudeExecutable,
+                      passthrough,
+                      stream: true,
+                      sdkAgents,
+                      passthroughMcp,
+                      cleanEnv: profileEnv,
+                      envOverrides,
+                      hasDeferredTools,
+                      resumeSessionId: currentSessionId || resumeSessionId,
+                      isUndo: false,
+                      resumeSessionAtUuid: nextPassthroughResumeUuid,
+                      forkSession: true,
+                      sdkHooks,
+                      blockedTools: pipelineCtx.blockedTools,
+                      incompatibleTools: pipelineCtx.incompatibleTools,
+                      mcpServerName: adapter.getMcpServerName(),
+                      allowedMcpTools: pipelineCtx.allowedMcpTools,
+                      onStderr,
+                      effort,
+                      thinking,
+                      taskBudget,
+                      outputFormat,
+                      betas,
+                      settingSources,
+                      codeSystemPrompt: sdkFeatures.codeSystemPrompt,
+                      clientSystemPrompt: sdkFeatures.clientSystemPrompt === false ? false : undefined,
+                      memory: sdkFeatures.memory,
+                      dreaming: sdkFeatures.dreaming,
+                      sharedMemory: sdkFeatures.sharedMemory,
+                      webFetchPreflight: sdkFeatures.webFetchPreflight,
+                      claudeAiConnectors: sdkFeatures.claudeAiConnectors,
+                      maxBudgetUsd: sdkFeatures.maxBudgetUsd,
+                      fallbackModel: sdkFeatures.fallbackModel,
+                      sdkDebug: sdkFeatures.sdkDebug,
+                      additionalDirectories: sdkFeatures.additionalDirectories ? sdkFeatures.additionalDirectories.split(",").map((d) => d.trim()).filter(Boolean) : undefined,
+                      advisorModel
+                    }, requestAbort.controller), requestAbort.controller.signal, requestMeta, "silent_recovery")) {
+                      const recoveryMessage = event;
+                      if (recoveryMessage.session_id)
+                        recoverySessionId = recoveryMessage.session_id;
+                      recoveryBoundaryUuid = resumeBoundaryUuid(recoveryMessage) ?? recoveryBoundaryUuid;
+                      if (recoveryMessage.type !== "stream_event")
+                        continue;
+                      const lifted = recoveryLifter.lift(event.event);
+                      if (!lifted)
+                        continue;
+                      safeEnqueue(encoder.encode(`event: ${lifted.frame.type}
 data: ${JSON.stringify(lifted.frame)}
 
 `), `silent_recovery_${lifted.kind}`);
-                    if (lifted.kind === "block_start") {
-                      eventsForwarded += 1;
-                    } else if (lifted.kind === "text_delta") {
-                      textEventsForwarded += 1;
-                      textCharsForwarded += lifted.textChars;
-                      silentTurnRecovered = true;
+                      if (lifted.kind === "block_start") {
+                        eventsForwarded += 1;
+                      } else if (lifted.kind === "text_delta") {
+                        textEventsForwarded += 1;
+                        textCharsForwarded += lifted.textChars;
+                        silentTurnRecovered = true;
+                      }
                     }
+                  } catch (recoveryError) {
+                    claudeLog("response.silent_turn_recovery_failed", {
+                      mode: "stream",
+                      error: recoveryError instanceof Error ? recoveryError.message : String(recoveryError)
+                    });
                   }
-                } catch (recoveryError) {
-                  claudeLog("response.silent_turn_recovery_failed", {
+                  if (capturedToolUses.length > capturedBeforeRecovery) {
+                    silentTurnRecovered = true;
+                  }
+                  if (silentTurnRecovered && recoverySessionId && !isIndependentSession && !sawDuplicateToolUse) {
+                    currentSessionId = recoverySessionId;
+                    nextPassthroughResumeUuid = recoveryBoundaryUuid;
+                    sdkUuidMap.length = 0;
+                    for (let i = 0;i < allMessages.length; i++)
+                      sdkUuidMap.push(null);
+                    storeSession(profileSessionId, body.messages || [], recoverySessionId, profileScopedCwd, sdkUuidMap, lastUsage, recoveryBoundaryUuid ?? null);
+                    commitSessionTurn();
+                  }
+                  claudeLog("response.silent_turn_recovery_result", {
                     mode: "stream",
-                    error: recoveryError instanceof Error ? recoveryError.message : String(recoveryError)
+                    recovered: silentTurnRecovered,
+                    textEvents: textEventsForwarded,
+                    forkedSession: recoverySessionId ?? null
                   });
-                }
-                if (capturedToolUses.length > capturedBeforeRecovery) {
-                  silentTurnRecovered = true;
-                }
-                if (silentTurnRecovered && recoverySessionId && !isIndependentSession && !sawDuplicateToolUse) {
-                  currentSessionId = recoverySessionId;
-                  nextPassthroughResumeUuid = recoveryBoundaryUuid;
-                  sdkUuidMap.length = 0;
-                  for (let i = 0;i < allMessages.length; i++)
-                    sdkUuidMap.push(null);
-                  storeSession(profileSessionId, body.messages || [], recoverySessionId, profileScopedCwd, sdkUuidMap, lastUsage, recoveryBoundaryUuid ?? null);
-                }
-                claudeLog("response.silent_turn_recovery_result", {
-                  mode: "stream",
-                  recovered: silentTurnRecovered,
-                  textEvents: textEventsForwarded,
-                  forkedSession: recoverySessionId ?? null
-                });
-                if (silentTurnRecovered && preRecoveryOutcome.kind === "silent") {
-                  diagnosticLog2.session(`${requestMeta.requestId} silent_turn reason=${preRecoveryOutcome.reason} ` + `blocks=${eventsForwarded} out=${lastUsage?.output_tokens ?? 0} ` + `recovery=succeeded`, requestMeta.requestId);
-                }
-              }
-              if (!streamClosed) {
-                const unseenToolUses = capturedToolUses.filter((tu) => !streamedToolUseIds.has(tu.id));
-                if (passthrough && unseenToolUses.length > 0 && messageStartEmitted) {
-                  for (let i = 0;i < unseenToolUses.length; i++) {
-                    const tu = unseenToolUses[i];
-                    const blockIndex = eventsForwarded + i;
-                    streamedToolUseIds.add(tu.id);
-                    safeEnqueue(encoder.encode(`event: content_block_start
+                  if (silentTurnRecovered && preRecoveryOutcome.kind === "silent") {
+                    diagnosticLog2.session(`${requestMeta.requestId} silent_turn reason=${preRecoveryOutcome.reason} ` + `blocks=${eventsForwarded} out=${lastUsage?.output_tokens ?? 0} ` + `recovery=succeeded`, requestMeta.requestId);
+                  }
+                }
+                if (!streamClosed) {
+                  const unseenToolUses = capturedToolUses.filter((tu) => !streamedToolUseIds.has(tu.id));
+                  if (passthrough && unseenToolUses.length > 0 && messageStartEmitted) {
+                    for (let i = 0;i < unseenToolUses.length; i++) {
+                      const tu = unseenToolUses[i];
+                      const blockIndex = eventsForwarded + i;
+                      streamedToolUseIds.add(tu.id);
+                      safeEnqueue(encoder.encode(`event: content_block_start
 data: ${JSON.stringify({
-                      type: "content_block_start",
-                      index: blockIndex,
-                      content_block: { type: "tool_use", id: tu.id, name: tu.name, input: {} }
-                    })}
+                        type: "content_block_start",
+                        index: blockIndex,
+                        content_block: { type: "tool_use", id: tu.id, name: tu.name, input: {} }
+                      })}
 
 `), "passthrough_tool_block_start");
-                    safeEnqueue(encoder.encode(`event: content_block_delta
+                      safeEnqueue(encoder.encode(`event: content_block_delta
 data: ${JSON.stringify({
-                      type: "content_block_delta",
-                      index: blockIndex,
-                      delta: { type: "input_json_delta", partial_json: JSON.stringify(tu.input) }
-                    })}
+                        type: "content_block_delta",
+                        index: blockIndex,
+                        delta: { type: "input_json_delta", partial_json: JSON.stringify(tu.input) }
+                      })}
 
 `), "passthrough_tool_input");
-                    safeEnqueue(encoder.encode(`event: content_block_stop
+                      safeEnqueue(encoder.encode(`event: content_block_stop
 data: ${JSON.stringify({
-                      type: "content_block_stop",
-                      index: blockIndex
-                    })}
+                        type: "content_block_stop",
+                        index: blockIndex
+                      })}
 
 `), "passthrough_tool_block_stop");
+                    }
+                    sendTerminalDelta("tool_use");
                   }
-                  sendTerminalDelta("tool_use");
-                }
-                if (trackFileChanges && passthrough && pipelineCtx.extractFileChangesFromToolUse) {
-                  const passthroughChanges = extractFileChangesFromMessages(body.messages || [], pipelineCtx.extractFileChangesFromToolUse);
-                  fileChanges.push(...passthroughChanges);
-                }
-                if (trackFileChanges) {
-                  const streamFileChangeSummary = formatFileChangeSummary(fileChanges);
-                  if (streamFileChangeSummary && messageStartEmitted) {
-                    const fcBlockIndex = nextClientBlockIndex++;
-                    safeEnqueue(encoder.encode(`event: content_block_start
+                  if (trackFileChanges && passthrough && pipelineCtx.extractFileChangesFromToolUse) {
+                    const passthroughChanges = extractFileChangesFromMessages(body.messages || [], pipelineCtx.extractFileChangesFromToolUse);
+                    fileChanges.push(...passthroughChanges);
+                  }
+                  if (trackFileChanges) {
+                    const streamFileChangeSummary = formatFileChangeSummary(fileChanges);
+                    if (streamFileChangeSummary && messageStartEmitted) {
+                      const fcBlockIndex = nextClientBlockIndex++;
+                      safeEnqueue(encoder.encode(`event: content_block_start
 data: ${JSON.stringify({
-                      type: "content_block_start",
-                      index: fcBlockIndex,
-                      content_block: { type: "text", text: "" }
-                    })}
+                        type: "content_block_start",
+                        index: fcBlockIndex,
+                        content_block: { type: "text", text: "" }
+                      })}
 
 `), "file_changes_block_start");
-                    safeEnqueue(encoder.encode(`event: content_block_delta
+                      safeEnqueue(encoder.encode(`event: content_block_delta
 data: ${JSON.stringify({
-                      type: "content_block_delta",
-                      index: fcBlockIndex,
-                      delta: { type: "text_delta", text: streamFileChangeSummary }
-                    })}
+                        type: "content_block_delta",
+                        index: fcBlockIndex,
+                        delta: { type: "text_delta", text: streamFileChangeSummary }
+                      })}
 
 `), "file_changes_text_delta");
-                    safeEnqueue(encoder.encode(`event: content_block_stop
+                      safeEnqueue(encoder.encode(`event: content_block_stop
 data: ${JSON.stringify({
-                      type: "content_block_stop",
-                      index: fcBlockIndex
-                    })}
+                        type: "content_block_stop",
+                        index: fcBlockIndex
+                      })}
 
 `), "file_changes_block_stop");
-                    claudeLog("response.file_changes", { mode: "stream", count: fileChanges.length });
+                      claudeLog("response.file_changes", { mode: "stream", count: fileChanges.length });
+                    }
                   }
-                }
-                if (messageStartEmitted) {
-                  sendTerminalDelta();
-                  safeEnqueue(encoder.encode(`event: message_stop
+                  if (messageStartEmitted) {
+                    sendTerminalDelta();
+                    safeEnqueue(encoder.encode(`event: message_stop
 data: {"type":"message_stop"}
 
 `), "final_message_stop");
+                  }
+                  try {
+                    controller.close();
+                  } catch {}
+                  streamClosed = true;
+                  claudeLog("stream.ended", {
+                    model,
+                    streamEventsSeen,
+                    eventsForwarded,
+                    textEventsForwarded,
+                    bytesSent,
+                    durationMs: Date.now() - requestStartAt
+                  });
                 }
-                try {
-                  controller.close();
-                } catch {}
-                streamClosed = true;
-                claudeLog("stream.ended", {
-                  model,
-                  streamEventsSeen,
-                  eventsForwarded,
-                  textEventsForwarded,
-                  bytesSent,
-                  durationMs: Date.now() - requestStartAt
-                });
-              }
-              {
-                const streamTotalDurationMs = Date.now() - requestStartAt;
-                claudeLog("response.completed", {
-                  mode: "stream",
-                  model,
-                  durationMs: streamTotalDurationMs,
-                  streamEventsSeen,
-                  eventsForwarded,
-                  textEventsForwarded
-                });
-                const streamQueueWaitMs = requestMeta.queueStartedAt - requestMeta.queueEnteredAt;
-                checkTokenHealth(requestMeta.requestId, currentSessionId || resumeSessionId, lastUsage, allMessages.length, isResume, passthrough);
-                telemetryStore2.record({
-                  requestId: requestMeta.requestId,
-                  timestamp: Date.now(),
-                  adapter: adapter.name,
-                  profileId: profile.id,
-                  requestSource,
-                  model,
-                  requestModel: body.model || undefined,
-                  mode: "stream",
-                  isResume,
-                  isPassthrough: passthrough,
-                  hasDeferredTools,
-                  deferredToolCount: hasDeferredTools ? deferredToolCount : undefined,
-                  toolCount,
-                  discoveredTools: discoveredTools.size > 0 ? [...discoveredTools] : undefined,
-                  sessionDiscoveredCount: sessionDiscoveredTools.get(currentSessionId || resumeSessionId || "")?.size,
-                  lineageType,
-                  messageCount: allMessages.length,
-                  sdkSessionId: currentSessionId || resumeSessionId,
-                  status: 200,
-                  queueWaitMs: streamQueueWaitMs,
-                  proxyOverheadMs: upstreamStartAt - requestStartAt - streamQueueWaitMs,
-                  ttfbMs: firstChunkAt ? firstChunkAt - upstreamStartAt : null,
-                  upstreamDurationMs: Date.now() - upstreamStartAt,
-                  totalDurationMs: streamTotalDurationMs,
-                  contentBlocks: eventsForwarded,
-                  textEvents: textEventsForwarded,
-                  error: null,
-                  inputTokens: lastUsage?.input_tokens,
-                  outputTokens: lastUsage?.output_tokens,
-                  cacheReadInputTokens: lastUsage?.cache_read_input_tokens,
-                  cacheCreationInputTokens: lastUsage?.cache_creation_input_tokens,
-                  cacheHitRate: computeCacheHitRate(lastUsage),
-                  ...envelopeViolations.length > 0 ? { envelopeViolations: [...envelopeViolations] } : {}
-                });
-                const turnOutcome = classifyNow();
-                if (turnOutcome.kind === "silent") {
-                  claudeLog("response.silent_turn", {
+                {
+                  const streamTotalDurationMs = Date.now() - requestStartAt;
+                  claudeLog("response.completed", {
+                    mode: "stream",
                     model,
-                    reason: turnOutcome.reason,
+                    durationMs: streamTotalDurationMs,
                     streamEventsSeen,
                     eventsForwarded,
+                    textEventsForwarded
+                  });
+                  const streamQueueWaitMs = totalQueueWaitMs(requestMeta);
+                  checkTokenHealth(requestMeta.requestId, currentSessionId || resumeSessionId, lastUsage, allMessages.length, isResume, passthrough);
+                  telemetryStore2.record({
+                    requestId: requestMeta.requestId,
+                    timestamp: Date.now(),
+                    adapter: adapter.name,
+                    profileId: profile.id,
+                    requestSource,
+                    model,
+                    requestModel: body.model || undefined,
+                    mode: "stream",
+                    isResume,
+                    isPassthrough: passthrough,
+                    hasDeferredTools,
+                    deferredToolCount: hasDeferredTools ? deferredToolCount : undefined,
+                    toolCount,
+                    discoveredTools: discoveredTools.size > 0 ? [...discoveredTools] : undefined,
+                    sessionDiscoveredCount: sessionDiscoveredTools.get(currentSessionId || resumeSessionId || "")?.size,
+                    lineageType,
+                    messageCount: allMessages.length,
+                    sdkSessionId: currentSessionId || resumeSessionId,
+                    status: 200,
+                    queueWaitMs: streamQueueWaitMs,
+                    sessionQueueWaitMs: requestMeta.sessionQueueWaitMs,
+                    sdkQueueWaitMs: requestMeta.sdkQueueWaitMs,
+                    proxyOverheadMs: Math.max(0, streamTotalDurationMs - streamQueueWaitMs - requestMeta.sdkActiveDurationMs),
+                    ttfbMs: requestMeta.ttfbMs ?? null,
+                    upstreamDurationMs: requestMeta.sdkActiveDurationMs,
+                    totalDurationMs: streamTotalDurationMs,
+                    contentBlocks: eventsForwarded,
+                    textEvents: textEventsForwarded,
+                    error: null,
+                    inputTokens: lastUsage?.input_tokens,
                     outputTokens: lastUsage?.output_tokens,
-                    recovered: silentTurnRecovered,
-                    recoveryAttempted: silentTurnRecoveryAttempted
+                    cacheReadInputTokens: lastUsage?.cache_read_input_tokens,
+                    cacheCreationInputTokens: lastUsage?.cache_creation_input_tokens,
+                    cacheHitRate: computeCacheHitRate(lastUsage),
+                    ...envelopeViolations.length > 0 ? { envelopeViolations: [...envelopeViolations] } : {}
                   });
-                  diagnosticLog2.session(`${requestMeta.requestId} silent_turn reason=${turnOutcome.reason} ` + `blocks=${eventsForwarded} out=${lastUsage?.output_tokens ?? 0} ` + `recovery=${silentTurnRecoveryAttempted ? silentTurnRecovered ? "succeeded" : "failed" : "off"}`, requestMeta.requestId);
+                  const turnOutcome = classifyNow();
+                  if (turnOutcome.kind === "silent") {
+                    claudeLog("response.silent_turn", {
+                      model,
+                      reason: turnOutcome.reason,
+                      streamEventsSeen,
+                      eventsForwarded,
+                      outputTokens: lastUsage?.output_tokens,
+                      recovered: silentTurnRecovered,
+                      recoveryAttempted: silentTurnRecoveryAttempted
+                    });
+                    diagnosticLog2.session(`${requestMeta.requestId} silent_turn reason=${turnOutcome.reason} ` + `blocks=${eventsForwarded} out=${lastUsage?.output_tokens ?? 0} ` + `recovery=${silentTurnRecoveryAttempted ? silentTurnRecovered ? "succeeded" : "failed" : "off"}`, requestMeta.requestId);
+                  }
                 }
-              }
-            } catch (error) {
-              if (isClosedControllerError(error)) {
-                streamClosed = true;
-                claudeLog("stream.client_closed", {
-                  source: "stream_catch",
-                  streamEventsSeen,
-                  eventsForwarded,
-                  textEventsForwarded,
-                  durationMs: Date.now() - requestStartAt
-                });
-                const disposition = clientAbortDisposition({
-                  isIndependentSession,
-                  profileSessionId,
-                  currentSessionId,
-                  sawDuplicateToolUse,
-                  resumeBoundaryUuid: nextPassthroughResumeUuid,
-                  passthrough
-                });
-                if (disposition.action === "store" && currentSessionId) {
-                  storeSession(profileSessionId, body.messages || [], currentSessionId, profileScopedCwd, sdkUuidMap, lastUsage, disposition.resumeUuid);
-                } else if (disposition.action === "evict") {
-                  evictSession(profileSessionId, profileScopedCwd, body.messages || []);
+              } catch (error) {
+                if (isClosedControllerError(error)) {
+                  streamClosed = true;
+                  claudeLog("stream.client_closed", {
+                    source: "stream_catch",
+                    streamEventsSeen,
+                    eventsForwarded,
+                    textEventsForwarded,
+                    durationMs: Date.now() - requestStartAt
+                  });
+                  const disposition = clientAbortDisposition({
+                    isIndependentSession,
+                    profileSessionId,
+                    currentSessionId,
+                    sawDuplicateToolUse,
+                    resumeBoundaryUuid: nextPassthroughResumeUuid,
+                    passthrough
+                  });
+                  if (disposition.action === "store" && currentSessionId) {
+                    storeSession(profileSessionId, body.messages || [], currentSessionId, profileScopedCwd, sdkUuidMap, lastUsage, disposition.resumeUuid);
+                    commitSessionTurn();
+                  } else if (disposition.action === "evict") {
+                    evictSession(profileSessionId, profileScopedCwd, body.messages || []);
+                  }
+                  claudeLog("passthrough.client_abort_settled", { action: disposition.action });
+                  return;
                 }
-                claudeLog("passthrough.client_abort_settled", { action: disposition.action });
-                resolvePendingStore();
-                return;
-              }
-              resolvePendingStore();
-              const stderrOutput = stderrLines.join(`
+                const stderrOutput = stderrLines.join(`
 `).trim();
-              if (stderrOutput && error instanceof Error && !error.message.includes(stderrOutput)) {
-                error.message = `${error.message}
+                if (stderrOutput && error instanceof Error && !error.message.includes(stderrOutput)) {
+                  error.message = `${error.message}
 Subprocess stderr: ${stderrOutput}`;
-              }
-              const errMsg = error instanceof Error ? error.message : String(error);
-              claudeLog("upstream.failed", {
-                mode: "stream",
-                model,
-                durationMs: Date.now() - upstreamStartAt,
-                streamEventsSeen,
-                textEventsForwarded,
-                error: errMsg,
-                ...stderrOutput ? { stderr: stderrOutput } : {}
-              });
-              const streamErr = error instanceof UpstreamIdleError ? {
-                status: 504,
-                type: "upstream_timeout",
-                message: `Upstream stalled: no data for ${error.sinceLastMs}ms`
-              } : classifyError(errMsg, model);
-              claudeLog("proxy.anthropic.error", { error: errMsg, classified: streamErr.type });
-              const sdkTerm = extractSdkTermination(errMsg);
-              const canRecoverAsToolUse = (sdkTerm.reason === "max_turns" || sdkTerm.reason === "aborted" && (sawDuplicateToolUse || earlyStopFired)) && passthrough && capturedToolUses.length > 0 && messageStartEmitted;
-              if (canRecoverAsToolUse) {
-                diagnosticLog2.session(`${requestMeta.requestId} sdk_termination_recovered ${formatSdkTermination(sdkTerm, {
+                }
+                const errMsg = error instanceof Error ? error.message : String(error);
+                claudeLog("upstream.failed", {
+                  mode: "stream",
                   model,
-                  requestSource,
-                  isResume,
-                  hasDeferredTools,
-                  sdkSessionId: resumeSessionId
-                })} captured=${capturedToolUses.length}`, requestMeta.requestId);
-                flushOpenClientBlocks("recovery");
-                const unseenToolUses = capturedToolUses.filter((tu) => !streamedToolUseIds.has(tu.id));
-                for (let i = 0;i < unseenToolUses.length; i++) {
-                  const tu = unseenToolUses[i];
-                  const blockIndex = eventsForwarded + i;
-                  streamedToolUseIds.add(tu.id);
-                  safeEnqueue(encoder.encode(`event: content_block_start
+                  durationMs: Date.now() - upstreamStartAt,
+                  streamEventsSeen,
+                  textEventsForwarded,
+                  error: errMsg,
+                  ...stderrOutput ? { stderr: stderrOutput } : {}
+                });
+                const streamErr = error instanceof UpstreamIdleError ? {
+                  status: 504,
+                  type: "upstream_timeout",
+                  message: `Upstream stalled: no data for ${error.sinceLastMs}ms`
+                } : classifyError(errMsg, model);
+                claudeLog("proxy.anthropic.error", { error: errMsg, classified: streamErr.type });
+                const sdkTerm = extractSdkTermination(errMsg);
+                const canRecoverAsToolUse = canRecoverCapturedToolUses({
+                  reason: sdkTerm.reason,
+                  passthrough,
+                  capturedToolUses: capturedToolUses.length,
+                  abortIsOurs: sawDuplicateToolUse || earlyStopFired
+                }) && messageStartEmitted;
+                if (canRecoverAsToolUse) {
+                  diagnosticLog2.session(`${requestMeta.requestId} sdk_termination_recovered ${formatSdkTermination(sdkTerm, {
+                    model,
+                    requestSource,
+                    isResume,
+                    hasDeferredTools,
+                    sdkSessionId: resumeSessionId
+                  })} captured=${capturedToolUses.length}`, requestMeta.requestId);
+                  flushOpenClientBlocks("recovery");
+                  const unseenToolUses = capturedToolUses.filter((tu) => !streamedToolUseIds.has(tu.id));
+                  for (let i = 0;i < unseenToolUses.length; i++) {
+                    const tu = unseenToolUses[i];
+                    const blockIndex = eventsForwarded + i;
+                    streamedToolUseIds.add(tu.id);
+                    safeEnqueue(encoder.encode(`event: content_block_start
 data: ${JSON.stringify({
-                    type: "content_block_start",
-                    index: blockIndex,
-                    content_block: { type: "tool_use", id: tu.id, name: tu.name, input: {} }
-                  })}
+                      type: "content_block_start",
+                      index: blockIndex,
+                      content_block: { type: "tool_use", id: tu.id, name: tu.name, input: {} }
+                    })}
 
 `), "recover_tool_block_start");
-                  safeEnqueue(encoder.encode(`event: content_block_delta
+                    safeEnqueue(encoder.encode(`event: content_block_delta
 data: ${JSON.stringify({
-                    type: "content_block_delta",
-                    index: blockIndex,
-                    delta: { type: "input_json_delta", partial_json: JSON.stringify(tu.input) }
-                  })}
+                      type: "content_block_delta",
+                      index: blockIndex,
+                      delta: { type: "input_json_delta", partial_json: JSON.stringify(tu.input) }
+                    })}
 
 `), "recover_tool_input");
-                  safeEnqueue(encoder.encode(`event: content_block_stop
+                    safeEnqueue(encoder.encode(`event: content_block_stop
 data: ${JSON.stringify({
-                    type: "content_block_stop",
-                    index: blockIndex
-                  })}
+                      type: "content_block_stop",
+                      index: blockIndex
+                    })}
 
 `), "recover_tool_block_stop");
-                }
-                safeEnqueue(encoder.encode(`event: message_delta
+                  }
+                  safeEnqueue(encoder.encode(`event: message_delta
 data: ${JSON.stringify({
-                  type: "message_delta",
-                  delta: { stop_reason: "tool_use", stop_sequence: null },
-                  usage: { output_tokens: 0 }
-                })}
+                    type: "message_delta",
+                    delta: { stop_reason: "tool_use", stop_sequence: null },
+                    usage: { output_tokens: 0 }
+                  })}
 
 `), "recover_message_delta");
-                safeEnqueue(encoder.encode(`event: message_stop
+                  safeEnqueue(encoder.encode(`event: message_stop
 data: {"type":"message_stop"}
 
 `), "recover_message_stop");
-                recordEnvelopeViolations(checkUndeliveredToolUses(capturedToolUses, streamedToolUseIds));
-                const recoverTotalMs = Date.now() - requestStartAt;
-                const recoverQueueWaitMs = requestMeta.queueStartedAt - requestMeta.queueEnteredAt;
+                  recordEnvelopeViolations(checkUndeliveredToolUses(capturedToolUses, streamedToolUseIds));
+                  const recoverTotalMs = Date.now() - requestStartAt;
+                  const recoverQueueWaitMs = totalQueueWaitMs(requestMeta);
+                  telemetryStore2.record({
+                    requestId: requestMeta.requestId,
+                    timestamp: Date.now(),
+                    adapter: adapter.name,
+                    profileId: profile.id,
+                    requestSource,
+                    model,
+                    requestModel: body.model || undefined,
+                    mode: "stream",
+                    isResume,
+                    isPassthrough: passthrough,
+                    hasDeferredTools,
+                    deferredToolCount: hasDeferredTools ? deferredToolCount : undefined,
+                    toolCount,
+                    lineageType,
+                    messageCount: allMessages.length,
+                    sdkSessionId: resumeSessionId,
+                    status: 200,
+                    queueWaitMs: recoverQueueWaitMs,
+                    sessionQueueWaitMs: requestMeta.sessionQueueWaitMs,
+                    sdkQueueWaitMs: requestMeta.sdkQueueWaitMs,
+                    proxyOverheadMs: Math.max(0, recoverTotalMs - recoverQueueWaitMs - requestMeta.sdkActiveDurationMs),
+                    ttfbMs: requestMeta.ttfbMs ?? null,
+                    upstreamDurationMs: requestMeta.sdkActiveDurationMs,
+                    totalDurationMs: recoverTotalMs,
+                    contentBlocks: eventsForwarded + unseenToolUses.length,
+                    textEvents: textEventsForwarded,
+                    error: null,
+                    ...envelopeViolations.length > 0 ? { envelopeViolations: [...envelopeViolations] } : {}
+                  });
+                  if (!streamClosed) {
+                    try {
+                      controller.close();
+                    } catch {}
+                    streamClosed = true;
+                  }
+                  return;
+                }
+                diagnosticLog2.error(`${requestMeta.requestId} ${formatSdkTermination(sdkTerm, {
+                  model,
+                  requestSource,
+                  isResume,
+                  hasDeferredTools,
+                  sdkSessionId: resumeSessionId
+                })}`, requestMeta.requestId);
+                const streamErrTotalMs = Date.now() - requestStartAt;
+                const streamErrQueueWaitMs = totalQueueWaitMs(requestMeta);
                 telemetryStore2.record({
                   requestId: requestMeta.requestId,
                   timestamp: Date.now(),
@@ -23014,106 +23465,66 @@ data: {"type":"message_stop"}
                   lineageType,
                   messageCount: allMessages.length,
                   sdkSessionId: resumeSessionId,
-                  status: 200,
-                  queueWaitMs: recoverQueueWaitMs,
-                  proxyOverheadMs: upstreamStartAt - requestStartAt - recoverQueueWaitMs,
-                  ttfbMs: firstChunkAt ? firstChunkAt - upstreamStartAt : null,
-                  upstreamDurationMs: Date.now() - upstreamStartAt,
-                  totalDurationMs: recoverTotalMs,
-                  contentBlocks: eventsForwarded + unseenToolUses.length,
-                  textEvents: textEventsForwarded,
-                  error: null,
-                  ...envelopeViolations.length > 0 ? { envelopeViolations: [...envelopeViolations] } : {}
-                });
-                if (!streamClosed) {
-                  try {
-                    controller.close();
-                  } catch {}
-                  streamClosed = true;
-                }
-                return;
-              }
-              diagnosticLog2.error(`${requestMeta.requestId} ${formatSdkTermination(sdkTerm, {
-                model,
-                requestSource,
-                isResume,
-                hasDeferredTools,
-                sdkSessionId: resumeSessionId
-              })}`, requestMeta.requestId);
-              const streamErrTotalMs = Date.now() - requestStartAt;
-              const streamErrQueueWaitMs = requestMeta.queueStartedAt - requestMeta.queueEnteredAt;
-              telemetryStore2.record({
-                requestId: requestMeta.requestId,
-                timestamp: Date.now(),
-                adapter: adapter.name,
-                profileId: profile.id,
-                requestSource,
-                model,
-                requestModel: body.model || undefined,
-                mode: "stream",
-                isResume,
-                isPassthrough: passthrough,
-                hasDeferredTools,
-                deferredToolCount: hasDeferredTools ? deferredToolCount : undefined,
-                toolCount,
-                lineageType,
-                messageCount: allMessages.length,
-                sdkSessionId: resumeSessionId,
-                status: streamErr.status,
-                queueWaitMs: streamErrQueueWaitMs,
-                proxyOverheadMs: upstreamStartAt - requestStartAt - streamErrQueueWaitMs,
-                ttfbMs: firstChunkAt ? firstChunkAt - upstreamStartAt : null,
-                upstreamDurationMs: Date.now() - upstreamStartAt,
-                totalDurationMs: streamErrTotalMs,
-                contentBlocks: eventsForwarded,
-                textEvents: textEventsForwarded,
-                error: streamErr.type
-              });
-              if (messageStartEmitted) {
-                const errorStopReason = textEventsForwarded > 0 ? "end_turn" : "max_tokens";
-                claudeLog("response.error_envelope", {
-                  mode: "stream",
-                  stopReason: errorStopReason,
+                  status: streamErr.status,
+                  queueWaitMs: streamErrQueueWaitMs,
+                  sessionQueueWaitMs: requestMeta.sessionQueueWaitMs,
+                  sdkQueueWaitMs: requestMeta.sdkQueueWaitMs,
+                  proxyOverheadMs: Math.max(0, streamErrTotalMs - streamErrQueueWaitMs - requestMeta.sdkActiveDurationMs),
+                  ttfbMs: requestMeta.ttfbMs ?? null,
+                  upstreamDurationMs: requestMeta.sdkActiveDurationMs,
+                  totalDurationMs: streamErrTotalMs,
+                  contentBlocks: eventsForwarded,
                   textEvents: textEventsForwarded,
-                  classified: streamErr.type
+                  error: streamErr.type
                 });
-                safeEnqueue(encoder.encode(`event: message_delta
+                if (messageStartEmitted) {
+                  const errorStopReason = "max_tokens";
+                  claudeLog("response.error_envelope", {
+                    mode: "stream",
+                    stopReason: errorStopReason,
+                    textEvents: textEventsForwarded,
+                    classified: streamErr.type
+                  });
+                  safeEnqueue(encoder.encode(`event: message_delta
 data: ${JSON.stringify({
-                  type: "message_delta",
-                  delta: { stop_reason: errorStopReason, stop_sequence: null },
-                  usage: { output_tokens: 0 }
-                })}
+                    type: "message_delta",
+                    delta: { stop_reason: errorStopReason, stop_sequence: null },
+                    usage: { output_tokens: 0 }
+                  })}
 
 `), "error_message_delta");
-                safeEnqueue(encoder.encode(`event: error
+                  safeEnqueue(encoder.encode(`event: error
 data: ${JSON.stringify({
-                  type: "error",
-                  error: { type: streamErr.type, message: streamErr.message }
-                })}
+                    type: "error",
+                    error: { type: streamErr.type, message: streamErr.message }
+                  })}
 
 `), "error_event_before_stop");
-                safeEnqueue(encoder.encode(`event: message_stop
+                  safeEnqueue(encoder.encode(`event: message_stop
 data: {"type":"message_stop"}
 
 `), "error_message_stop");
-              } else {
-                safeEnqueue(encoder.encode(`event: error
+                } else {
+                  safeEnqueue(encoder.encode(`event: error
 data: ${JSON.stringify({
-                  type: "error",
-                  error: { type: streamErr.type, message: streamErr.message }
-                })}
+                    type: "error",
+                    error: { type: streamErr.type, message: streamErr.message }
+                  })}
 
 `), "error_event");
+                }
+                if (!streamClosed) {
+                  try {
+                    controller.close();
+                  } catch {}
+                  streamClosed = true;
+                }
+              } finally {
+                requestAbort.detach();
               }
-              if (!streamClosed) {
-                try {
-                  controller.close();
-                } catch {}
-                streamClosed = true;
-              }
-            } finally {
-              requestAbort.detach();
-            }
+            })().finally(() => {
+              resolveStreamCompletion();
+            });
           },
           cancel(reason) {
             requestAbort.abort(reason);
@@ -23122,7 +23533,7 @@ data: ${JSON.stringify({
         });
         const streamSessionId = resumeSessionId || `session_${Date.now()}`;
         streamOwnsAbortLink = true;
-        return new Response(readable, {
+        const streamResponse = new Response(readable, {
           headers: {
             "Content-Type": "text/event-stream",
             "Cache-Control": "no-cache",
@@ -23130,19 +23541,22 @@ data: ${JSON.stringify({
             "X-Claude-Session-ID": streamSessionId
           }
         });
+        responseCompletions.set(streamResponse, streamCompletion);
+        return streamResponse;
       } catch (error) {
         const errMsg = error instanceof Error ? error.message : String(error);
         claudeLog("error.unhandled", {
           durationMs: Date.now() - requestStartAt,
           error: errMsg
         });
-        const classified = classifyError(errMsg);
+        const classified = requestAbort.controller.signal.aborted ? { status: 499, type: "request_cancelled", message: "The request was cancelled" } : classifyError(errMsg);
         claudeLog("proxy.error", { error: errMsg, classified: classified.type });
         const sdkTerm = extractSdkTermination(errMsg);
         diagnosticLog2.error(`${requestMeta.requestId} ${formatSdkTermination(sdkTerm, {
           requestSource: c.req.header("x-meridian-source")?.slice(0, 64) || undefined
         })}`, requestMeta.requestId);
-        const errorQueueWaitMs = requestMeta.queueStartedAt - requestMeta.queueEnteredAt;
+        const errorQueueWaitMs = totalQueueWaitMs(requestMeta);
+        const errorTotalMs = Date.now() - requestStartAt;
         telemetryStore2.record({
           requestId: requestMeta.requestId,
           timestamp: Date.now(),
@@ -23160,10 +23574,12 @@ data: ${JSON.stringify({
           sdkSessionId: undefined,
           status: classified.status,
           queueWaitMs: errorQueueWaitMs,
-          proxyOverheadMs: Date.now() - requestStartAt - errorQueueWaitMs,
+          sessionQueueWaitMs: requestMeta.sessionQueueWaitMs,
+          sdkQueueWaitMs: requestMeta.sdkQueueWaitMs,
+          proxyOverheadMs: Math.max(0, errorTotalMs - errorQueueWaitMs - requestMeta.sdkActiveDurationMs),
           ttfbMs: null,
-          upstreamDurationMs: Date.now() - requestStartAt,
-          totalDurationMs: Date.now() - requestStartAt,
+          upstreamDurationMs: requestMeta.sdkActiveDurationMs,
+          totalDurationMs: errorTotalMs,
           contentBlocks: 0,
           textEvents: 0,
           error: classified.type
@@ -23176,15 +23592,122 @@ data: ${JSON.stringify({
     });
   };
   const handleWithQueue = async (c, endpoint) => {
+    if (draining && c.req.header("x-meridian-internal-hop") !== internalHopToken) {
+      return drainingResponse();
+    }
     const requestId = c.req.header("x-request-id") || randomUUID();
     const queueEnteredAt = Date.now();
     claudeLog("request.enter", { requestId, endpoint });
-    await acquireSession();
-    const queueStartedAt = Date.now();
+    let sessionTurnLease;
+    let finished = false;
+    let leaseReleased = false;
+    let leaseWatchdog;
+    inFlightRequests++;
+    const releaseSessionTurn = (forced) => {
+      if (leaseReleased || !sessionTurnLease)
+        return;
+      leaseReleased = true;
+      if (leaseWatchdog)
+        clearTimeout(leaseWatchdog);
+      if (forced) {
+        claudeLog("session.turn_lease_forced", { requestId, heldMs: SESSION_TURN_MAX_HOLD_MS });
+        plog(`[PROXY] ${requestId} session turn lease force-released after ${SESSION_TURN_MAX_HOLD_MS}ms`);
+      }
+      sessionTurnLease.release();
+    };
+    const finishRequest = () => {
+      if (finished)
+        return;
+      finished = true;
+      releaseSessionTurn(false);
+      inFlightRequests--;
+    };
+    let body;
     try {
-      return await handleMessages(c, { requestId, endpoint, queueEnteredAt, queueStartedAt });
-    } finally {
-      releaseSession();
+      try {
+        body = await c.req.json();
+      } catch (error) {
+        if (c.req.raw.signal.aborted || error instanceof Error && error.name === "AbortError") {
+          finishRequest();
+          return new Response(JSON.stringify({
+            type: "error",
+            error: { type: "request_cancelled", message: "The request was cancelled" }
+          }), { status: 499, headers: { "Content-Type": "application/json" } });
+        }
+        finishRequest();
+        return new Response(JSON.stringify({
+          type: "error",
+          error: { type: "invalid_request_error", message: "Request body must be valid JSON" }
+        }), { status: 400, headers: { "Content-Type": "application/json" } });
+      }
+      if (Array.isArray(body?.messages)) {
+        const adapter = detectAdapter(c);
+        const agentSessionId = adapter.getSessionId(c, body);
+        if (agentSessionId) {
+          try {
+            sessionTurnLease = await processSessionTurns.acquire(`session:${agentSessionId}`, c.req.raw.signal);
+            leaseWatchdog = setTimeout(() => releaseSessionTurn(true), SESSION_TURN_MAX_HOLD_MS);
+            leaseWatchdog.unref?.();
+          } catch (error) {
+            if (c.req.raw.signal.aborted || error instanceof Error && error.name === "AbortError") {
+              const cancelledWaitMs = Date.now() - queueEnteredAt;
+              telemetryStore2.record({
+                requestId,
+                timestamp: Date.now(),
+                adapter: adapter.name,
+                model: "unknown",
+                requestModel: undefined,
+                mode: "non-stream",
+                isResume: false,
+                isPassthrough: envBool("PASSTHROUGH"),
+                hasDeferredTools: undefined,
+                deferredToolCount: undefined,
+                toolCount: undefined,
+                lineageType: undefined,
+                messageCount: Array.isArray(body?.messages) ? body.messages.length : undefined,
+                sdkSessionId: undefined,
+                status: 499,
+                queueWaitMs: cancelledWaitMs,
+                sessionQueueWaitMs: cancelledWaitMs,
+                sdkQueueWaitMs: 0,
+                proxyOverheadMs: 0,
+                ttfbMs: null,
+                upstreamDurationMs: 0,
+                totalDurationMs: cancelledWaitMs,
+                contentBlocks: 0,
+                textEvents: 0,
+                error: "request_cancelled"
+              });
+              finishRequest();
+              return new Response(JSON.stringify({
+                type: "error",
+                error: { type: "request_cancelled", message: "The request was cancelled" }
+              }), { status: 499, headers: { "Content-Type": "application/json" } });
+            }
+            throw error;
+          }
+        }
+      }
+      const requestMeta = {
+        requestId,
+        endpoint,
+        queueEnteredAt,
+        sessionQueueWaitMs: sessionTurnLease?.waitedMs ?? 0,
+        sdkQueueWaitMs: 0,
+        sdkActiveDurationMs: 0,
+        sessionTurnLease
+      };
+      const response = await handleMessages(c, requestMeta, { body });
+      const completion = responseCompletions.get(response);
+      if (completion) {
+        completion.finally(finishRequest).catch(() => {});
+      } else {
+        finishRequest();
+      }
+      return response;
+    } catch (error) {
+      finishRequest();
+      throw error;
     }
   };
   app.post("/v1/messages", (c) => handleWithQueue(c, "/v1/messages"));
@@ -23287,6 +23810,13 @@ data: ${JSON.stringify({
     });
   });
   app.get("/health", async (c) => {
+    if (draining) {
+      return c.json({
+        status: "draining",
+        version: serverVersion,
+        message: "Meridian is shutting down; route new requests to another instance."
+      }, 503);
+    }
     try {
       const healthProfile = resolveProfile(finalConfig.profiles, finalConfig.defaultProfile);
       const profileEnvOverrides = Object.keys(healthProfile.env).length > 0 ? healthProfile.env : undefined;
@@ -23444,6 +23974,8 @@ data: ${JSON.stringify({
     return c.json({ success: false, message: "Token refresh failed. If the problem persists, run 'claude login'." }, 500);
   });
   app.post("/v1/chat/completions", async (c) => {
+    if (draining)
+      return drainingResponse();
     const rawBody = await c.req.json();
     const userAgent = c.req.header("user-agent") ?? "";
     const jcodeSessionId = userAgent.startsWith("jcode/") ? normalizeJcodeSessionId(c.req.header("x-jcode-session")) : undefined;
@@ -23470,16 +24002,16 @@ data: ${JSON.stringify({
     const authz = c.req.header("authorization");
     if (authz)
       internalHeaders["authorization"] = authz;
+    internalHeaders["x-meridian-internal-hop"] = internalHopToken;
     const internalReq = new Request("http://internal/v1/messages", {
       method: "POST",
       headers: internalHeaders,
-      body: JSON.stringify(anthropicBody)
+      body: JSON.stringify(anthropicBody),
+      signal: c.req.raw.signal
     });
     const internalRes = await app.fetch(internalReq);
-    if (!internalRes.ok) {
-      const errBody = await internalRes.text();
-      return c.json({ type: "error", error: { type: "upstream_error", message: errBody } }, internalRes.status);
-    }
+    if (!internalRes.ok)
+      return relayInnerError(internalRes, "anthropic");
     const completionId = `chatcmpl-${randomUUID()}`;
     const created = Math.floor(Date.now() / 1000);
     const model = typeof rawBody.model === "string" && rawBody.model ? rawBody.model : CANONICAL_SONNET_MODEL;
@@ -23492,6 +24024,7 @@ data: ${JSON.stringify({
       }));
     }
     const encoder = new TextEncoder;
+    let internalReader;
     const readable = new ReadableStream({
       async start(controller) {
         const reader = internalRes.body?.getReader();
@@ -23499,6 +24032,7 @@ data: ${JSON.stringify({
           controller.close();
           return;
         }
+        internalReader = reader;
         const decoder = new TextDecoder;
         let buffer = "";
         let streamError = null;
@@ -23551,6 +24085,9 @@ data: ${JSON.stringify({
           }
           controller.close();
         }
+      },
+      cancel(reason) {
+        return internalReader?.cancel(reason);
       }
     });
     return new Response(readable, {
@@ -23562,6 +24099,8 @@ data: ${JSON.stringify({
     });
   });
   app.post("/v1/responses", async (c) => {
+    if (draining)
+      return drainingResponse("openai");
     const rawBody = await c.req.json();
     const anthropicBody = translateResponsesToAnthropic(rawBody);
     if (!anthropicBody) {
@@ -23587,16 +24126,16 @@ data: ${JSON.stringify({
     const xProfile = c.req.header("x-meridian-profile");
     if (xProfile)
       internalHeaders["x-meridian-profile"] = xProfile;
+    internalHeaders["x-meridian-internal-hop"] = internalHopToken;
     const internalReq = new Request("http://internal/v1/messages", {
       method: "POST",
       headers: internalHeaders,
-      body: JSON.stringify(anthropicBody)
+      body: JSON.stringify(anthropicBody),
+      signal: c.req.raw.signal
     });
     const internalRes = await app.fetch(internalReq);
-    if (!internalRes.ok) {
-      const errBody = await internalRes.text();
-      return c.json({ error: { type: "upstream_error", message: errBody, code: null } }, internalRes.status);
-    }
+    if (!internalRes.ok)
+      return relayInnerError(internalRes, "openai");
     const responseId = `resp_${randomUUID().replace(/-/g, "")}`;
     const created = Math.floor(Date.now() / 1000);
     const model = typeof rawBody.model === "string" && rawBody.model ? rawBody.model : CANONICAL_SONNET_MODEL;
@@ -23606,6 +24145,7 @@ data: ${JSON.stringify({
       return c.json(translateAnthropicToResponses(anthropicRes, ctx));
     }
     const encoder = new TextEncoder;
+    let internalReader;
     const readable = new ReadableStream({
       async start(controller) {
         const reader = internalRes.body?.getReader();
@@ -23613,6 +24153,7 @@ data: ${JSON.stringify({
           controller.close();
           return;
         }
+        internalReader = reader;
         const decoder = new TextDecoder;
         let buffer = "";
         const translate = createResponsesSseTranslator(ctx);
@@ -23656,6 +24197,9 @@ data: ${JSON.stringify({ response: { id: responseId, status: "failed", error: {
         } finally {
           controller.close();
         }
+      },
+      cancel(reason) {
+        return internalReader?.cancel(reason);
       }
     });
     return new Response(readable, {
@@ -23668,8 +24212,8 @@ data: ${JSON.stringify({ response: { id: responseId, status: "failed", error: {
   });
   app.get("/v1/models", async (c) => {
     const authStatus = await getClaudeAuthStatusAsync();
-    const isMax = authStatus?.subscriptionType === "max";
-    return c.json({ object: "list", data: buildModelList(isMax) });
+    const extendedContext = subscriptionIncludesExtendedContext(authStatus?.subscriptionType);
+    return c.json({ object: "list", data: buildModelList(extendedContext) });
   });
   app.get("/v1/usage/quota", async (c) => {
     const requestedProfile = c.req.query("profile");
@@ -23905,7 +24449,15 @@ data: ${JSON.stringify({ response: { id: responseId, status: "failed", error: {
       plog(`[PROXY] Plugin loading failed: ${err instanceof Error ? err.message : String(err)}`);
     }
   }
-  return { app, config: finalConfig, initPlugins: initPluginsAsync };
+  return {
+    app,
+    config: finalConfig,
+    initPlugins: initPluginsAsync,
+    beginDrain: () => {
+      draining = true;
+    },
+    getInFlightCount: () => inFlightRequests
+  };
 }
 var processErrorHandlersInstalled = false;
 function installProxyProcessErrorHandlers() {
@@ -23921,7 +24473,7 @@ function installProxyProcessErrorHandlers() {
 }
 async function startProxyServer(config = {}) {
   claudeExecutable = await resolveClaudeExecutableAsync();
-  const { app, config: finalConfig, initPlugins } = createProxyServer(config);
+  const { app, config: finalConfig, initPlugins, beginDrain, getInFlightCount } = createProxyServer(config);
   if (initPlugins)
     await initPlugins();
   if (finalConfig.installProcessErrorHandlers) {
@@ -23950,6 +24502,7 @@ Point any Anthropic-compatible tool at this endpoint:`);
   const idleMs = finalConfig.idleTimeoutSeconds * 1000;
   server.keepAliveTimeout = idleMs;
   server.headersTimeout = idleMs + 1000;
+  const connectionTracker = trackServerConnections(server);
   server.on("error", (error) => {
     if (error.code === "EADDRINUSE" && !finalConfig.silent) {
       console.error(`
@@ -23988,17 +24541,29 @@ Or use a different port:`);
     if (authKeepaliveInterval.unref)
       authKeepaliveInterval.unref();
   }
+  let closePromise;
   return {
     server,
     config: finalConfig,
-    async close() {
-      clearInterval(profileTokenRefreshInterval);
-      if (authKeepaliveInterval)
-        clearInterval(authKeepaliveInterval);
-      stopBackgroundRefresh();
-      await new Promise((resolve3, reject) => {
-        server.close((err) => err ? reject(err) : resolve3());
-      });
+    close() {
+      closePromise ??= (async () => {
+        clearInterval(profileTokenRefreshInterval);
+        if (authKeepaliveInterval)
+          clearInterval(authKeepaliveInterval);
+        stopBackgroundRefresh();
+        beginDrain?.();
+        try {
+          await closeServerWithGracePeriod(server, {
+            graceMs: SHUTDOWN_GRACE_MS,
+            getInFlightCount: () => getInFlightCount?.() ?? 0,
+            warn: finalConfig.silent ? undefined : (message) => console.warn(message),
+            forceCloseConnections: () => connectionTracker.forceCloseAll()
+          });
+        } finally {
+          connectionTracker.dispose();
+        }
+      })();
+      return closePromise;
     }
   };
 }