@rynfar/meridian 1.62.2 → 1.62.4

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

@@ -1974,13 +1974,6 @@ ${history}
 
 ` + last.text;
 }
-function framePassthroughContinuation(delta) {
-  if (!delta)
-    return delta;
-  return `${PASSTHROUGH_CONTINUATION_LEAD_IN}
-
-${delta}`;
-}
 function stripNonStandardStreamFields(event) {
   if (event && typeof event === "object") {
     const e = event;
@@ -2119,7 +2112,7 @@ function extractSystemText(system) {
   return system.filter((b) => b?.type === "text" && typeof b.text === "string" && b.text).map((b) => b.text).filter((text) => !TRANSPORT_HEADER_BLOCK.test(text)).join(`
 `);
 }
-var HASH_IGNORED_BLOCK_TYPES, HASH_HANDLED_BLOCK_TYPES, HASH_SERIALIZED_BLOCK_TYPES, PASSTHROUGH_CONTINUATION_LEAD_IN, MULTIMODAL_TYPES, TOOL_TARGET_KEYS, TOOL_TARGET_MAX = 80, CONTENT_SUMMARY_MAX = 120, TRANSPORT_HEADER_BLOCK;
+var HASH_IGNORED_BLOCK_TYPES, HASH_HANDLED_BLOCK_TYPES, HASH_SERIALIZED_BLOCK_TYPES, MULTIMODAL_TYPES, TOOL_TARGET_KEYS, TOOL_TARGET_MAX = 80, CONTENT_SUMMARY_MAX = 120, TRANSPORT_HEADER_BLOCK;
 var init_messages = __esm(() => {
   HASH_IGNORED_BLOCK_TYPES = new Set(["thinking", "redacted_thinking"]);
   HASH_HANDLED_BLOCK_TYPES = new Set(["text", "tool_use", "tool_result"]);
@@ -2136,7 +2129,6 @@ var init_messages = __esm(() => {
     "tool_search_tool_result",
     "container_upload"
   ]);
-  PASSTHROUGH_CONTINUATION_LEAD_IN = "The tool calls from your previous turn were forwarded to the client, which has now executed them — " + "their results follow. The instruction to end that turn without further text applied to it alone and " + "is now discharged: continue the work and respond.";
   MULTIMODAL_TYPES = new Set(["image", "document", "file"]);
   TOOL_TARGET_KEYS = ["filePath", "file_path", "path", "command", "code", "pattern", "query", "url"];
   TRANSPORT_HEADER_BLOCK = /^\s*x-anthropic-[a-z0-9-]*header\s*:/i;
@@ -6516,19 +6508,34 @@ function resolveMaxConcurrent(source = process.env, warn = console.warn) {
   }
   return DEFAULT_MAX_CONCURRENT;
 }
+function assertPositiveLimit(limit) {
+  if (!Number.isSafeInteger(limit) || limit <= 0) {
+    throw new RangeError("Semaphore limit must be a positive integer");
+  }
+  return limit;
+}
 
 class AbortableSemaphore {
-  limit;
   activeCount = 0;
+  currentLimit;
   waiters = [];
   constructor(limit) {
-    this.limit = limit;
-    if (!Number.isSafeInteger(limit) || limit <= 0) {
-      throw new RangeError("Semaphore limit must be a positive integer");
-    }
+    this.currentLimit = assertPositiveLimit(limit);
+  }
+  get limit() {
+    return this.currentLimit;
+  }
+  setLimit(next) {
+    const limit = assertPositiveLimit(next);
+    if (limit === this.currentLimit)
+      return;
+    const raised = limit > this.currentLimit;
+    this.currentLimit = limit;
+    if (raised)
+      this.grantNext();
   }
   get snapshot() {
-    return { active: this.activeCount, queued: this.waiters.length, limit: this.limit };
+    return { active: this.activeCount, queued: this.waiters.length, limit: this.currentLimit };
   }
   acquire(signal) {
     if (signal?.aborted)
@@ -6584,7 +6591,12 @@ class AbortableSemaphore {
   }
 }
 function getProcessSdkSemaphore() {
-  processSdkSemaphore ??= new AbortableSemaphore(resolveMaxConcurrent());
+  const limit = resolveMaxConcurrent();
+  if (!processSdkSemaphore) {
+    processSdkSemaphore = new AbortableSemaphore(limit);
+    return processSdkSemaphore;
+  }
+  processSdkSemaphore.setLimit(limit);
   return processSdkSemaphore;
 }
 
@@ -11091,6 +11103,17 @@ function noteAssistantContent(tracker, content) {
     }
   }
 }
+function noteAssistantMessage(tracker, message) {
+  const m = message;
+  if (m?.type !== "assistant")
+    return;
+  const content = m.message?.content;
+  const before = tracker.expected.size;
+  noteAssistantContent(tracker, content);
+  if (tracker.expected.size > before) {
+    tracker.toolCallAssistantUuid = typeof m.uuid === "string" && m.uuid.length > 0 ? m.uuid : undefined;
+  }
+}
 function noteUserContent(tracker, content) {
   if (!Array.isArray(content))
     return;
@@ -11101,43 +11124,69 @@ function noteUserContent(tracker, content) {
     }
   }
 }
-function shouldEarlyStop(tracker) {
-  if (tracker.fired)
-    return false;
+function allForwardedCallsResolved(tracker) {
   if (tracker.expected.size === 0)
     return false;
   for (const id of tracker.expected) {
     if (!tracker.resolved.has(id))
       return false;
   }
+  return true;
+}
+function isCompleteToolResultContinuation(messages, expectedIds) {
+  if (expectedIds.length === 0 || messages.length === 0)
+    return false;
+  const expected = new Set(expectedIds);
+  const actual = new Set;
+  const echoedCalls = new Set;
+  let sawUser = false;
+  let sawNonToolResult = false;
+  for (const message of messages) {
+    if (message.role === "assistant" && !sawUser) {
+      if (Array.isArray(message.content)) {
+        for (const rawBlock of message.content) {
+          const block = rawBlock;
+          if (block?.type !== "tool_use")
+            continue;
+          if (typeof block.id !== "string" || !expected.has(block.id) || echoedCalls.has(block.id))
+            return false;
+          echoedCalls.add(block.id);
+        }
+      }
+      continue;
+    }
+    if (message.role !== "user" || !Array.isArray(message.content) || sawUser)
+      return false;
+    sawUser = true;
+    for (const rawBlock of message.content) {
+      const block = rawBlock;
+      if (block?.type === "tool_result") {
+        if (sawNonToolResult || typeof block.tool_use_id !== "string")
+          return false;
+        if (!expected.has(block.tool_use_id) || actual.has(block.tool_use_id))
+          return false;
+        actual.add(block.tool_use_id);
+      } else {
+        sawNonToolResult = true;
+      }
+    }
+  }
+  return actual.size === expected.size && (echoedCalls.size === 0 || echoedCalls.size === expected.size);
+}
+function settledToolCallAssistantUuid(tracker) {
+  return allForwardedCallsResolved(tracker) ? tracker.toolCallAssistantUuid : undefined;
+}
+function shouldEarlyStop(tracker) {
+  if (tracker.fired || !settledToolCallAssistantUuid(tracker))
+    return false;
   tracker.fired = true;
   return true;
 }
 function clientAbortDisposition(input) {
   if (input.isIndependentSession || !input.profileSessionId)
     return { action: "none" };
-  if (!input.passthrough)
-    return { action: "evict" };
-  if (input.currentSessionId && !input.sawDuplicateToolUse && input.resumeBoundaryUuid) {
-    return { action: "store", resumeUuid: input.resumeBoundaryUuid };
-  }
   return { action: "evict" };
 }
-function resumeBoundaryUuid(message) {
-  const m = message;
-  if (m?.type !== "user")
-    return;
-  if (typeof m.uuid !== "string" || m.uuid.length === 0)
-    return;
-  const content = m.message?.content;
-  if (!Array.isArray(content))
-    return;
-  const hasResult = content.some((block) => {
-    const b = block;
-    return b?.type === "tool_result";
-  });
-  return hasResult ? m.uuid : undefined;
-}
 
 // src/proxy/envelopeIntegrity.ts
 function checkEmptyToolInputs(contentBlocks, tools) {
@@ -20012,6 +20061,13 @@ function normalizeContextUsage(usage) {
   return lastIteration ?? usage;
 }
 var MIN_SUFFIX_FOR_COMPACTION = 2;
+function withClientAssistantUuid(existing, clientMessageCount, uuid) {
+  const next = existing.slice(0, clientMessageCount + 1);
+  while (next.length < clientMessageCount)
+    next.push(null);
+  next[clientMessageCount] = typeof uuid === "string" && uuid.length > 0 ? uuid : null;
+  return next;
+}
 function computeLineageHash(messages) {
   if (!messages || messages.length === 0)
     return "";
@@ -20327,15 +20383,20 @@ function writeStore(store) {
     }
   }
 }
+function hasLegacyUserDenialBoundary(session) {
+  const legacy = session.passthroughResumeUuid;
+  return typeof legacy === "string" && legacy.length > 0 && !session.passthroughToolCallAssistantUuid;
+}
 function lookupSharedSession(key) {
   const store = readStore();
-  return store[key];
+  const session = store[key];
+  return session && !hasLegacyUserDenialBoundary(session) ? session : undefined;
 }
 function lookupSharedSessionByClaudeId(claudeSessionId) {
   const sessions = Object.values(readStore());
   let newest;
   for (const session of sessions) {
-    if (session.claudeSessionId !== claudeSessionId)
+    if (session.claudeSessionId !== claudeSessionId || hasLegacyUserDenialBoundary(session))
       continue;
     if (!newest || session.lastUsedAt > newest.lastUsedAt) {
       newest = session;
@@ -20343,7 +20404,7 @@ function lookupSharedSessionByClaudeId(claudeSessionId) {
   }
   return newest;
 }
-function storeSharedSession(key, claudeSessionId, messageCount, lineageHash, messageHashes, sdkMessageUuids, contextUsage, messageBlockHashes, passthroughResumeUuid) {
+function storeSharedSession(key, claudeSessionId, messageCount, lineageHash, messageHashes, sdkMessageUuids, contextUsage, messageBlockHashes, passthroughToolCallAssistantUuid, passthroughToolCallIds) {
   const path3 = getStorePath();
   const lockPath = `${path3}.lock`;
   const hasLock = skipLocking ? false : acquireLock(lockPath);
@@ -20363,7 +20424,8 @@ function storeSharedSession(key, claudeSessionId, messageCount, lineageHash, mes
       messageHashes: messageHashes ?? existing?.messageHashes,
       messageBlockHashes: messageBlockHashes ?? existing?.messageBlockHashes,
       sdkMessageUuids: sdkMessageUuids ?? existing?.sdkMessageUuids,
-      passthroughResumeUuid: passthroughResumeUuid === undefined ? existing?.passthroughResumeUuid : passthroughResumeUuid ?? undefined,
+      passthroughToolCallAssistantUuid: passthroughToolCallAssistantUuid === undefined ? existing?.passthroughToolCallAssistantUuid : passthroughToolCallAssistantUuid ?? undefined,
+      passthroughToolCallIds: passthroughToolCallIds === undefined ? existing?.passthroughToolCallIds : passthroughToolCallIds ?? undefined,
       contextUsage: contextUsage ?? existing?.contextUsage,
       ...previousClaudeSessionId ? { previousClaudeSessionId } : {}
     };
@@ -20561,7 +20623,8 @@ function lookupSession(sessionId, messages, workingDirectory) {
         messageHashes: shared.messageHashes,
         messageBlockHashes: shared.messageBlockHashes,
         sdkMessageUuids: shared.sdkMessageUuids,
-        passthroughResumeUuid: shared.passthroughResumeUuid,
+        passthroughToolCallAssistantUuid: shared.passthroughToolCallAssistantUuid,
+        passthroughToolCallIds: shared.passthroughToolCallIds,
         contextUsage: shared.contextUsage
       };
       const result = classifyLineage(state, messages, sessionId);
@@ -20591,7 +20654,8 @@ function lookupSession(sessionId, messages, workingDirectory) {
         messageHashes: shared.messageHashes,
         messageBlockHashes: shared.messageBlockHashes,
         sdkMessageUuids: shared.sdkMessageUuids,
-        passthroughResumeUuid: shared.passthroughResumeUuid,
+        passthroughToolCallAssistantUuid: shared.passthroughToolCallAssistantUuid,
+        passthroughToolCallIds: shared.passthroughToolCallIds,
         contextUsage: shared.contextUsage
       };
       const result = classifyLineage(state, messages, fp);
@@ -20626,13 +20690,14 @@ function getSessionByClaudeId(claudeSessionId) {
       messageHashes: shared.messageHashes,
       messageBlockHashes: shared.messageBlockHashes,
       sdkMessageUuids: shared.sdkMessageUuids,
-      passthroughResumeUuid: shared.passthroughResumeUuid,
+      passthroughToolCallAssistantUuid: shared.passthroughToolCallAssistantUuid,
+      passthroughToolCallIds: shared.passthroughToolCallIds,
       contextUsage: shared.contextUsage
     });
   }
   return newest;
 }
-function storeSession(sessionId, messages, claudeSessionId, workingDirectory, sdkMessageUuids, contextUsage, passthroughResumeUuid) {
+function storeSession(sessionId, messages, claudeSessionId, workingDirectory, sdkMessageUuids, contextUsage, passthroughToolCallAssistantUuid, passthroughToolCallIds) {
   if (!claudeSessionId)
     return;
   const lineageHash = computeLineageHash(messages);
@@ -20646,7 +20711,8 @@ function storeSession(sessionId, messages, claudeSessionId, workingDirectory, sd
     messageHashes,
     messageBlockHashes,
     sdkMessageUuids,
-    ...passthroughResumeUuid ? { passthroughResumeUuid } : {},
+    ...passthroughToolCallAssistantUuid ? { passthroughToolCallAssistantUuid } : {},
+    ...passthroughToolCallIds ? { passthroughToolCallIds } : {},
     ...contextUsage ? { contextUsage } : {}
   };
   if (sessionId)
@@ -20656,7 +20722,7 @@ function storeSession(sessionId, messages, claudeSessionId, workingDirectory, sd
     fingerprintCache.set(fp, state);
   const key = sessionId || fp;
   if (key) {
-    storeSharedSession(key, claudeSessionId, state.messageCount, lineageHash, messageHashes, sdkMessageUuids, contextUsage, messageBlockHashes, passthroughResumeUuid ?? null);
+    storeSharedSession(key, claudeSessionId, state.messageCount, lineageHash, messageHashes, sdkMessageUuids, contextUsage, messageBlockHashes, passthroughToolCallAssistantUuid ?? null, passthroughToolCallIds ?? null);
   }
 }
 
@@ -20816,21 +20882,21 @@ function stripCacheControlDeep(content) {
     return rest;
   });
 }
-function normalizeStructuredUserContent(content) {
+function normalizeStructuredUserContent(content, preserveToolResultWrapper = false) {
   if (!Array.isArray(content))
     return content;
   const normalized = [];
   for (const block of content) {
     if (!block || typeof block !== "object")
       continue;
-    if (block.type === "tool_result" && Array.isArray(block.content) && hasMultimodalContent(block.content)) {
+    if (!preserveToolResultWrapper && block.type === "tool_result" && Array.isArray(block.content) && hasMultimodalContent(block.content)) {
       normalized.push(...normalizeStructuredUserContent(block.content));
       continue;
     }
     if (block.type === "tool_result" && Array.isArray(block.content)) {
       normalized.push({
         ...block,
-        content: normalizeStructuredUserContent(block.content)
+        content: normalizeStructuredUserContent(block.content, preserveToolResultWrapper)
       });
       continue;
     }
@@ -21437,15 +21503,16 @@ data: ${JSON.stringify(lastError)}
             } : undefined
           }, adapterBase);
         }
-        const isResume = lineageResult.type === "continuation" || lineageResult.type === "compaction";
+        let isResume = lineageResult.type === "continuation" || lineageResult.type === "compaction";
         const isUndo = lineageResult.type === "undo";
         const cachedSession = lineageResult.type !== "diverged" ? lineageResult.session : undefined;
-        const resumeSessionId = cachedSession?.claudeSessionId;
+        let resumeSessionId = cachedSession?.claudeSessionId;
         const passthrough = adapter.instancePassthrough !== undefined ? adapter.instancePassthrough : pipelineCtx.passthrough !== undefined ? pipelineCtx.passthrough : envBool("PASSTHROUGH");
         const resumeFrom = lineageResult.type === "continuation" || lineageResult.type === "compaction" ? lineageResult.resumeFrom : undefined;
         const resumeContentFrom = lineageResult.type === "continuation" ? lineageResult.resumeContentFrom : undefined;
         const undoRollbackUuid = isUndo && lineageResult.type === "undo" ? lineageResult.rollbackUuid : undefined;
-        const passthroughResumeUuid = passthrough && isResume ? cachedSession?.passthroughResumeUuid : undefined;
+        let passthroughToolCallAssistantUuid = passthrough && isResume ? cachedSession?.passthroughToolCallAssistantUuid : undefined;
+        const passthroughToolCallIds = passthrough && isResume ? cachedSession?.passthroughToolCallIds : undefined;
         const msgSummary = body.messages?.map((m) => {
           const contentTypes = Array.isArray(m.content) ? m.content.map((b) => b.type).join(",") : "string";
           return `${m.role}[${contentTypes}]`;
@@ -21511,17 +21578,28 @@ data: ${JSON.stringify(lastError)}
         } else {
           messagesToConvert = allMessages;
         }
+        if (passthroughToolCallAssistantUuid && !isCompleteToolResultContinuation(messagesToConvert, passthroughToolCallIds ?? [])) {
+          claudeLog("passthrough.checkpoint_replay", {
+            expectedToolIds: passthroughToolCallIds?.length ?? 0,
+            reason: "incomplete_or_mismatched_results"
+          });
+          isResume = false;
+          resumeSessionId = undefined;
+          passthroughToolCallAssistantUuid = undefined;
+          messagesToConvert = allMessages;
+        }
         const hasMultimodal = messagesToConvert?.some((m) => hasMultimodalContent(m.content));
+        const hasPassthroughToolResults = Boolean(passthroughToolCallAssistantUuid) && messagesToConvert?.some((m) => m.role === "user" && Array.isArray(m.content) && m.content.some((block) => block?.type === "tool_result"));
         let structuredMessages;
         let textPrompt;
-        if (hasMultimodal) {
+        if (hasMultimodal || hasPassthroughToolResults) {
           structuredMessages = [];
           if (isResume) {
             for (const m of messagesToConvert) {
               if (m.role === "user") {
                 structuredMessages.push({
                   type: "user",
-                  message: { role: "user", content: normalizeStructuredUserContent(stripCacheControlDeep(m.content)) },
+                  message: { role: "user", content: normalizeStructuredUserContent(stripCacheControlDeep(m.content), Boolean(passthroughToolCallAssistantUuid)) },
                   parent_tool_use_id: null
                 });
               }
@@ -21531,7 +21609,7 @@ data: ${JSON.stringify(lastError)}
               if (m.role === "user") {
                 structuredMessages.push({
                   type: "user",
-                  message: { role: "user", content: normalizeStructuredUserContent(stripCacheControlDeep(m.content)) },
+                  message: { role: "user", content: normalizeStructuredUserContent(stripCacheControlDeep(m.content), Boolean(passthroughToolCallAssistantUuid)) },
                   parent_tool_use_id: null
                 });
               } else {
@@ -21549,13 +21627,6 @@ data: ${JSON.stringify(lastError)}
           if (structuredMessages.length > 1) {
             structuredMessages = consolidateMultimodalOntoLastUser(structuredMessages);
           }
-          if (passthroughResumeUuid && structuredMessages.length > 0) {
-            structuredMessages.unshift({
-              type: "user",
-              message: { role: "user", content: PASSTHROUGH_CONTINUATION_LEAD_IN },
-              parent_tool_use_id: null
-            });
-          }
         } else {
           const toolIndex = buildToolUseIndex(allMessages ?? messagesToConvert ?? []);
           const promptTurns = (messagesToConvert ?? []).map((m) => {
@@ -21570,7 +21641,7 @@ data: ${JSON.stringify(lastError)}
           const resumeDelta = promptTurns.map((t) => t.text).filter(Boolean).join(`
 
 `) || "";
-          textPrompt = isResume ? passthroughResumeUuid ? framePassthroughContinuation(resumeDelta) : resumeDelta : frameReplayTurns(promptTurns);
+          textPrompt = isResume ? resumeDelta : frameReplayTurns(promptTurns);
         }
         const settingSources = envBool("LOAD_CONTEXT") || sdkFeatures.claudeMd === "full" ? ["user", "project"] : sdkFeatures.claudeMd === "project" ? ["project"] : pipelineCtx.settingSources ?? [];
         const capturedToolUses = [];
@@ -21673,11 +21744,15 @@ data: ${JSON.stringify(lastError)}
               }
               const signature = toolUseSignature(toolName, toolInput);
               const isExactDuplicate = capturedSignatures.has(signature);
+              const isPostCheckpointCall = earlyStopFired;
               const isSameToolRepeat = !earlyStopEnabled && !isExactDuplicate && capturedToolNames.has(toolName);
               const exceedsForcedSingle = forceSingleToolUse && capturedToolUses.length >= 1;
-              if (isExactDuplicate) {
+              if (isExactDuplicate || isPostCheckpointCall) {
                 droppedToolUseIds.add(input.tool_use_id);
-                claudeLog("passthrough.duplicate_tool_use_dropped", { name: toolName });
+                claudeLog("passthrough.duplicate_tool_use_dropped", {
+                  name: toolName,
+                  reason: isPostCheckpointCall ? "hidden_digest" : "exact_duplicate"
+                });
               } else if (isSameToolRepeat || exceedsForcedSingle) {
                 droppedToolUseIds.add(input.tool_use_id);
                 sawDuplicateToolUse = true;
@@ -21698,10 +21773,10 @@ data: ${JSON.stringify(lastError)}
               if (earlyStopEnabled && turnGenerating && !requestAbort.controller.signal.aborted) {
                 await holdDenyUntilTurnEnd();
               }
-              if (isExactDuplicate) {
+              if (isExactDuplicate || isPostCheckpointCall) {
                 return {
                   decision: "block",
-                  reason: "This exact tool call has already been forwarded to the client — do not repeat it. " + "Do not call additional tools and do not generate further text — end your turn now."
+                  reason: "This tool call has already been handled by the client-facing turn — do not repeat it. " + "Do not call additional tools and do not generate further text — end your turn now."
                 };
               }
               if (isSameToolRepeat || exceedsForcedSingle) {
@@ -21733,13 +21808,15 @@ data: ${JSON.stringify(lastError)}
           const upstreamStartAt = Date.now();
           let firstChunkAt;
           let currentSessionId;
-          const sdkUuidMap = cachedSession?.sdkMessageUuids ? [...cachedSession.sdkMessageUuids] : [];
+          let sdkUuidMap = (isResume || isUndo) && cachedSession?.sdkMessageUuids ? [...cachedSession.sdkMessageUuids] : [];
           while (sdkUuidMap.length < allMessages.length)
             sdkUuidMap.push(null);
           claudeLog("upstream.start", { mode: "non_stream", model });
           let lastUsage;
           let lastStopReason;
-          let nextPassthroughResumeUuid;
+          let nextPassthroughToolCallAssistantUuid;
+          let nextPassthroughToolCallIds;
+          let sawCanonicalResult = false;
           try {
             if (!claudeExecutable) {
               claudeExecutable = await resolveClaudeExecutableAsync();
@@ -21777,8 +21854,8 @@ data: ${JSON.stringify(lastError)}
                     hasDeferredTools,
                     resumeSessionId,
                     isUndo,
-                    resumeSessionAtUuid: undoRollbackUuid ?? passthroughResumeUuid,
-                    forkSession: busySessionFork || Boolean(passthroughResumeUuid) || undefined,
+                    resumeSessionAtUuid: undoRollbackUuid ?? passthroughToolCallAssistantUuid,
+                    forkSession: busySessionFork || undefined,
                     sdkHooks,
                     blockedTools: pipelineCtx.blockedTools,
                     incompatibleTools: pipelineCtx.incompatibleTools,
@@ -22011,25 +22088,33 @@ data: ${JSON.stringify(lastError)}
                 claudeLog("passthrough.loop_break", { mode: "non_stream", assistantMessages, captured: capturedToolUses.length });
                 break;
               }
-              if (earlyStopEnabled) {
-                if (message.type === "assistant") {
-                  noteAssistantContent(earlyStop, message.message?.content);
-                } else if (message.type === "user") {
-                  nextPassthroughResumeUuid = resumeBoundaryUuid(message) ?? nextPassthroughResumeUuid;
-                  noteUserContent(earlyStop, message.message?.content);
-                  if (shouldEarlyStop(earlyStop)) {
-                    earlyStopFired = true;
-                    claudeLog("passthrough.early_stop", { mode: "non_stream", captured: capturedToolUses.length });
-                    requestAbort.abort("passthrough turn complete");
-                    break;
+              let assistantAddedForwardedCall = false;
+              if (passthrough && message.type === "assistant" && !earlyStopFired && earlyStop.resolved.size === 0) {
+                const expectedBefore = earlyStop.expected.size;
+                noteAssistantMessage(earlyStop, message);
+                assistantAddedForwardedCall = earlyStop.expected.size > expectedBefore;
+              } else if (passthrough && message.type === "user" && !earlyStopFired) {
+                noteUserContent(earlyStop, message.message?.content);
+                if (earlyStopEnabled && shouldEarlyStop(earlyStop)) {
+                  nextPassthroughToolCallAssistantUuid = settledToolCallAssistantUuid(earlyStop);
+                  nextPassthroughToolCallIds = [...earlyStop.expected];
+                  earlyStopFired = true;
+                  for (let i = capturedToolUses.length - 1;i >= 0; i--) {
+                    if (!earlyStop.expected.has(capturedToolUses[i].id))
+                      capturedToolUses.splice(i, 1);
                   }
+                  claudeLog("passthrough.checkpoint_ready", {
+                    mode: "non_stream",
+                    captured: capturedToolUses.length,
+                    toolCallAssistantUuid: nextPassthroughToolCallAssistantUuid
+                  });
                 }
               }
               if (message.type === "assistant") {
                 releaseHeldDenies("assistant_message");
                 assistantMessages += 1;
-                if (message.uuid) {
-                  sdkUuidMap.push(message.uuid);
+                if (!passthrough || earlyStop.expected.size === 0 || assistantAddedForwardedCall) {
+                  sdkUuidMap = withClientAssistantUuid(sdkUuidMap, allMessages.length, message.uuid);
                 }
                 if (!firstChunkAt) {
                   firstChunkAt = Date.now();
@@ -22073,11 +22158,12 @@ data: ${JSON.stringify(lastError)}
                 const msgUsage = message.message.usage;
                 if (msgUsage)
                   lastUsage = { ...lastUsage, ...msgUsage };
-                if (typeof message.message.stop_reason === "string") {
+                if (!isPassthroughTurn2 && typeof message.message.stop_reason === "string") {
                   lastStopReason = message.message.stop_reason;
                 }
               }
               if (message.type === "result") {
+                sawCanonicalResult = true;
                 const resultUsage = message.usage;
                 if (resultUsage) {
                   lastUsage = { ...lastUsage, ...resultUsage };
@@ -22109,6 +22195,10 @@ data: ${JSON.stringify(lastError)}
             }
           } catch (error) {
             releaseHeldDenies("non_stream_error");
+            if (passthrough && capturedToolUses.length > 0 && !sawCanonicalResult) {
+              evictSession(profileSessionId, profileScopedCwd, body.messages || []);
+              claudeLog("passthrough.noncanonical_session_evicted", { mode: "non_stream", reason: "drain_error" });
+            }
             const stderrOutput = stderrLines.join(`
 `).trim();
             if (stderrOutput && error instanceof Error && !error.message.includes(stderrOutput)) {
@@ -22263,8 +22353,14 @@ Subprocess stderr: ${stderrOutput}`;
             ]);
           }
           if (currentSessionId && !isIndependentSession && !sawDuplicateToolUse) {
-            storeSession(profileSessionId, body.messages || [], currentSessionId, profileScopedCwd, sdkUuidMap, lastUsage, earlyStopFired ? nextPassthroughResumeUuid : null);
-            commitSessionTurn();
+            const checkpointTurn = passthrough && contentBlocks.some((b) => b.type === "tool_use");
+            if (checkpointTurn && (!earlyStopFired || !sawCanonicalResult)) {
+              evictSession(profileSessionId, profileScopedCwd, body.messages || []);
+              claudeLog("passthrough.noncanonical_session_evicted", { mode: "non_stream" });
+            } else {
+              storeSession(profileSessionId, body.messages || [], currentSessionId, profileScopedCwd, sdkUuidMap, lastUsage, earlyStopFired ? nextPassthroughToolCallAssistantUuid : null, earlyStopFired ? nextPassthroughToolCallIds : null);
+              commitSessionTurn();
+            }
           }
           const responseSessionId = currentSessionId || resumeSessionId || `session_${Date.now()}`;
           return new Response(JSON.stringify({
@@ -22305,6 +22401,7 @@ Subprocess stderr: ${stderrOutput}`;
               let bytesSent = 0;
               let streamClosed = false;
               let awaitingEarlyStopDrain = false;
+              let exitedBeforeCanonicalTerminal = false;
               claudeLog("upstream.start", { mode: "stream", model });
               const safeEnqueue = (payload, source) => {
                 if (streamClosed)
@@ -22326,14 +22423,16 @@ Subprocess stderr: ${stderrOutput}`;
                   throw error;
                 }
               };
-              const sdkUuidMap = cachedSession?.sdkMessageUuids ? [...cachedSession.sdkMessageUuids] : [];
+              let sdkUuidMap = (isResume || isUndo) && cachedSession?.sdkMessageUuids ? [...cachedSession.sdkMessageUuids] : [];
               while (sdkUuidMap.length < allMessages.length)
                 sdkUuidMap.push(null);
               let messageStartEmitted = false;
               let lastUsage;
               let hasStructuredOutput = false;
               let structuredOutput;
-              let nextPassthroughResumeUuid;
+              let nextPassthroughToolCallAssistantUuid;
+              let nextPassthroughToolCallIds;
+              let sawCanonicalResult = false;
               const silentTurnRecoveryEnabled = env("SILENT_TURN_RECOVERY") !== "0";
               let silentTurnRecoveryAttempted = false;
               let silentTurnRecovered = false;
@@ -22358,33 +22457,6 @@ data: ${JSON.stringify({
                   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;
@@ -22435,8 +22507,8 @@ data: ${JSON.stringify({ type: "content_block_stop", index: idx })}
                         hasDeferredTools,
                         resumeSessionId,
                         isUndo,
-                        resumeSessionAtUuid: undoRollbackUuid ?? passthroughResumeUuid,
-                        forkSession: busySessionFork || Boolean(passthroughResumeUuid) || undefined,
+                        resumeSessionAtUuid: undoRollbackUuid ?? passthroughToolCallAssistantUuid,
+                        forkSession: busySessionFork || undefined,
                         sdkHooks,
                         blockedTools: pipelineCtx.blockedTools,
                         incompatibleTools: pipelineCtx.incompatibleTools,
@@ -22696,38 +22768,42 @@ data: ${JSON.stringify({ type: "content_block_stop", index: idx })}
                 try {
                   for await (const message of guardedResponse) {
                     if (streamClosed && !awaitingEarlyStopDrain) {
+                      exitedBeforeCanonicalTerminal = true;
                       break;
                     }
                     if (message.session_id) {
                       currentSessionId = message.session_id;
                     }
-                    if (message.type === "assistant" && message.uuid) {
-                      sdkUuidMap.push(message.uuid);
+                    let assistantAddedForwardedCall = false;
+                    if (earlyStopEnabled && message.type === "assistant" && !earlyStopFired) {
+                      const expectedBefore = earlyStop.expected.size;
+                      noteAssistantMessage(earlyStop, message);
+                      assistantAddedForwardedCall = earlyStop.expected.size > expectedBefore;
+                    } else if (earlyStopEnabled && message.type === "user" && !earlyStopFired) {
+                      noteUserContent(earlyStop, message.message?.content);
                     }
-                    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 (earlyStopEnabled && !earlyStopFired) {
+                      const hasCompleteStreamedSet = streamedToolUseIds.size > 0 && earlyStop.expected.size === streamedToolUseIds.size && [...streamedToolUseIds].every((id) => earlyStop.expected.has(id));
+                      if (!turnGenerating && openClientBlocks.size === 0 && hasCompleteStreamedSet && shouldEarlyStop(earlyStop)) {
+                        nextPassthroughToolCallAssistantUuid = settledToolCallAssistantUuid(earlyStop);
+                        nextPassthroughToolCallIds = [...earlyStop.expected];
+                        earlyStopFired = true;
+                        for (let i = capturedToolUses.length - 1;i >= 0; i--) {
+                          if (!earlyStop.expected.has(capturedToolUses[i].id))
+                            capturedToolUses.splice(i, 1);
                         }
+                        claudeLog("passthrough.checkpoint_ready", {
+                          mode: "stream",
+                          captured: capturedToolUses.length,
+                          toolCallAssistantUuid: nextPassthroughToolCallAssistantUuid
+                        });
                       }
                     }
+                    if (message.type === "assistant" && (!passthrough || earlyStop.expected.size === 0 || assistantAddedForwardedCall)) {
+                      sdkUuidMap = withClientAssistantUuid(sdkUuidMap, allMessages.length, message.uuid);
+                    }
                     if (message.type === "result") {
+                      sawCanonicalResult = true;
                       const resultUsage = message.usage;
                       if (resultUsage)
                         lastUsage = { ...lastUsage, ...resultUsage };
@@ -22737,6 +22813,8 @@ data: ${JSON.stringify({ type: "content_block_stop", index: idx })}
                       }
                     }
                     if (message.type === "stream_event") {
+                      if (streamClosed && awaitingEarlyStopDrain)
+                        continue;
                       streamEventsSeen += 1;
                       if (!firstChunkAt) {
                         firstChunkAt = Date.now();
@@ -22776,16 +22854,19 @@ data: ${JSON.stringify({ type: "content_block_stop", index: idx })}
                           lastUsage = { ...lastUsage, ...startUsage };
                         if (messageStartEmitted) {
                           if (passthrough && streamedToolUseIds.size > 0) {
-                            flushOpenClientBlocks("turn2_suppression");
-                            sendTerminalDelta("tool_use");
-                            safeEnqueue(encoder.encode(`event: message_stop
+                            if (!streamClosed) {
+                              flushOpenClientBlocks("turn2_suppression");
+                              sendTerminalDelta("tool_use");
+                              safeEnqueue(encoder.encode(`event: message_stop
 data: ${JSON.stringify({ type: "message_stop" })}
 
 `), "passthrough_turn2_stop");
+                              streamClosed = true;
+                              controller.close();
+                            }
+                            awaitingEarlyStopDrain = true;
                             claudeLog("passthrough.turn2_suppressed", { mode: "stream", toolUses: streamedToolUseIds.size });
-                            streamClosed = true;
-                            controller.close();
-                            break;
+                            continue;
                           }
                           continue;
                         }
@@ -22909,10 +22990,6 @@ data: ${JSON.stringify(event)}
                         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");
@@ -22927,6 +23004,7 @@ data: ${JSON.stringify({ type: "message_stop" })}
                           awaitingEarlyStopDrain = true;
                           continue;
                         }
+                        exitedBeforeCanonicalTerminal = true;
                         break;
                       }
                       if (eventType === "content_block_delta") {
@@ -23022,8 +23100,14 @@ data: ${JSON.stringify({
                   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 checkpointTurn = passthrough && streamedToolUseIds.size > 0;
+                  if (exitedBeforeCanonicalTerminal || checkpointTurn && (!earlyStopFired || !sawCanonicalResult)) {
+                    evictSession(profileSessionId, profileScopedCwd, body.messages || []);
+                    claudeLog("passthrough.noncanonical_session_evicted", { mode: "stream" });
+                  } else {
+                    storeSession(profileSessionId, body.messages || [], currentSessionId, profileScopedCwd, sdkUuidMap, lastUsage, earlyStopFired ? nextPassthroughToolCallAssistantUuid : null, earlyStopFired ? nextPassthroughToolCallIds : null);
+                    commitSessionTurn();
+                  }
                 }
                 const classifyNow = () => classifyTurnOutcome({
                   textEvents: textEventsForwarded,
@@ -23048,7 +23132,8 @@ data: ${JSON.stringify({
                   });
                   const recoveryLifter = createRecoveryLifter(() => nextClientBlockIndex++);
                   let recoverySessionId;
-                  let recoveryBoundaryUuid;
+                  let recoveryToolCallAssistantUuid;
+                  const recoveryEarlyStop = createEarlyStopTracker();
                   try {
                     for await (const event of runSdkQueryAttempt(buildQueryOptions({
                       prompt: SILENT_TURN_NUDGE,
@@ -23066,7 +23151,7 @@ data: ${JSON.stringify({
                       hasDeferredTools,
                       resumeSessionId: currentSessionId || resumeSessionId,
                       isUndo: false,
-                      resumeSessionAtUuid: nextPassthroughResumeUuid,
+                      resumeSessionAtUuid: nextPassthroughToolCallAssistantUuid,
                       forkSession: true,
                       sdkHooks,
                       blockedTools: pipelineCtx.blockedTools,
@@ -23096,7 +23181,12 @@ data: ${JSON.stringify({
                       const recoveryMessage = event;
                       if (recoveryMessage.session_id)
                         recoverySessionId = recoveryMessage.session_id;
-                      recoveryBoundaryUuid = resumeBoundaryUuid(recoveryMessage) ?? recoveryBoundaryUuid;
+                      if (recoveryMessage.type === "assistant") {
+                        noteAssistantMessage(recoveryEarlyStop, recoveryMessage);
+                      } else if (recoveryMessage.type === "user") {
+                        noteUserContent(recoveryEarlyStop, recoveryMessage.message?.content);
+                        recoveryToolCallAssistantUuid = settledToolCallAssistantUuid(recoveryEarlyStop);
+                      }
                       if (recoveryMessage.type !== "stream_event")
                         continue;
                       const lifted = recoveryLifter.lift(event.event);
@@ -23125,11 +23215,12 @@ data: ${JSON.stringify(lifted.frame)}
                   }
                   if (silentTurnRecovered && recoverySessionId && !isIndependentSession && !sawDuplicateToolUse) {
                     currentSessionId = recoverySessionId;
-                    nextPassthroughResumeUuid = recoveryBoundaryUuid;
+                    nextPassthroughToolCallAssistantUuid = recoveryToolCallAssistantUuid;
+                    nextPassthroughToolCallIds = recoveryToolCallAssistantUuid ? [...recoveryEarlyStop.expected] : undefined;
                     sdkUuidMap.length = 0;
                     for (let i = 0;i < allMessages.length; i++)
                       sdkUuidMap.push(null);
-                    storeSession(profileSessionId, body.messages || [], recoverySessionId, profileScopedCwd, sdkUuidMap, lastUsage, recoveryBoundaryUuid ?? null);
+                    storeSession(profileSessionId, body.messages || [], recoverySessionId, profileScopedCwd, sdkUuidMap, lastUsage, recoveryToolCallAssistantUuid ?? null, recoveryToolCallAssistantUuid ? [...recoveryEarlyStop.expected] : null);
                     commitSessionTurn();
                   }
                   claudeLog("response.silent_turn_recovery_result", {
@@ -23307,18 +23398,19 @@ data: {"type":"message_stop"}
                     profileSessionId,
                     currentSessionId,
                     sawDuplicateToolUse,
-                    resumeBoundaryUuid: nextPassthroughResumeUuid,
+                    toolCallAssistantUuid: nextPassthroughToolCallAssistantUuid,
                     passthrough
                   });
-                  if (disposition.action === "store" && currentSessionId) {
-                    storeSession(profileSessionId, body.messages || [], currentSessionId, profileScopedCwd, sdkUuidMap, lastUsage, disposition.resumeUuid);
-                    commitSessionTurn();
-                  } else if (disposition.action === "evict") {
+                  if (disposition.action === "evict") {
                     evictSession(profileSessionId, profileScopedCwd, body.messages || []);
                   }
                   claudeLog("passthrough.client_abort_settled", { action: disposition.action });
                   return;
                 }
+                if (passthrough && streamedToolUseIds.size > 0 && !sawCanonicalResult) {
+                  evictSession(profileSessionId, profileScopedCwd, body.messages || []);
+                  claudeLog("passthrough.noncanonical_session_evicted", { mode: "stream", reason: "drain_error" });
+                }
                 const stderrOutput = stderrLines.join(`
 `).trim();
                 if (stderrOutput && error instanceof Error && !error.message.includes(stderrOutput)) {
@@ -23346,7 +23438,7 @@ Subprocess stderr: ${stderrOutput}`;
                   reason: sdkTerm.reason,
                   passthrough,
                   capturedToolUses: capturedToolUses.length,
-                  abortIsOurs: sawDuplicateToolUse || earlyStopFired
+                  abortIsOurs: sawDuplicateToolUse
                 }) && messageStartEmitted;
                 if (canRecoverAsToolUse) {
                   diagnosticLog2.session(`${requestMeta.requestId} sdk_termination_recovered ${formatSdkTermination(sdkTerm, {
@@ -23529,6 +23621,10 @@ data: ${JSON.stringify({
           cancel(reason) {
             requestAbort.abort(reason);
             requestAbort.detach();
+            if (!isIndependentSession) {
+              evictSession(profileSessionId, profileScopedCwd, body.messages || []);
+              claudeLog("passthrough.client_abort_settled", { action: "evict", source: "stream_cancel" });
+            }
           }
         });
         const streamSessionId = resumeSessionId || `session_${Date.now()}`;