@rynfar/meridian 1.62.3 → 1.62.5

package/dist/{cli-3ysfatce.js → cli-dya07jbg.js}

@@ -153,30 +153,44 @@ function parseAgentDescriptions(taskDescription) {
   }
   return agents;
 }
-function buildAgentDefinitions(taskDescription, mcpToolNames) {
+function mapModelTier(model) {
+  if (!model)
+    return "inherit";
+  const lower = model.toLowerCase();
+  if (lower.includes("opus"))
+    return "opus";
+  if (lower.includes("fable") || lower.includes("mythos"))
+    return "fable";
+  if (lower.includes("haiku"))
+    return "haiku";
+  if (lower.includes("sonnet"))
+    return "sonnet";
+  return "inherit";
+}
+function buildAgentDefinitions(taskDescription, mcpToolNames, modelTier = "inherit") {
   const descriptions = parseAgentDescriptions(taskDescription);
   const agents = {};
   for (const [name, description] of descriptions) {
     agents[name] = {
       description,
       prompt: buildAgentPrompt(name, description),
-      model: "inherit",
+      model: modelTier,
       ...mcpToolNames?.length ? { tools: [...mcpToolNames] } : {}
     };
   }
   if (descriptions.size > 0) {
-    ensureDefaultAgents(agents, mcpToolNames);
+    ensureDefaultAgents(agents, mcpToolNames, modelTier);
     addCaseVariants(agents);
   }
   return agents;
 }
-function ensureDefaultAgents(agents, mcpToolNames) {
+function ensureDefaultAgents(agents, mcpToolNames, modelTier) {
   for (const [name, description] of Object.entries(DEFAULT_AGENT_TYPES)) {
     if (!agents[name]) {
       agents[name] = {
         description,
         prompt: buildAgentPrompt(name, description),
-        model: "inherit",
+        model: modelTier,
         ...mcpToolNames?.length ? { tools: [...mcpToolNames] } : {}
       };
     }
@@ -223,10 +237,10 @@ function parseAgentNamesFromSchema(taskTool) {
     return [];
   return enumNames.filter((n) => typeof n === "string");
 }
-function buildAgentDefinitionsFromTool(taskTool, mcpToolNames) {
+function buildAgentDefinitionsFromTool(taskTool, mcpToolNames, modelTier = "inherit") {
   const rawDescription = getNested(taskTool, "description");
   const description = typeof rawDescription === "string" ? rawDescription : "";
-  const fromDescription = buildAgentDefinitions(description, mcpToolNames);
+  const fromDescription = buildAgentDefinitions(description, mcpToolNames, modelTier);
   if (Object.keys(fromDescription).length > 0)
     return fromDescription;
   const names = parseAgentNamesFromSchema(taskTool);
@@ -240,11 +254,11 @@ function buildAgentDefinitionsFromTool(taskTool, mcpToolNames) {
     agents[name] = {
       description: desc,
       prompt: buildAgentPrompt(name, desc),
-      model: "inherit",
+      model: modelTier,
       ...mcpToolNames?.length ? { tools: [...mcpToolNames] } : {}
     };
   }
-  ensureDefaultAgents(agents, mcpToolNames);
+  ensureDefaultAgents(agents, mcpToolNames, modelTier);
   addCaseVariants(agents);
   return agents;
 }
@@ -1974,13 +1988,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 +2126,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 +2143,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;
@@ -2199,7 +2205,7 @@ var init_opencode = __esm(() => {
         if (Array.isArray(body.tools)) {
           const taskTool = body.tools.find((t) => t.name === "task" || t.name === "Task");
           if (taskTool) {
-            sdkAgents = buildAgentDefinitionsFromTool(taskTool, [...allowedMcpTools]);
+            sdkAgents = buildAgentDefinitionsFromTool(taskTool, [...allowedMcpTools], mapModelTier(body.model));
           }
         }
         let sdkHooks = undefined;
@@ -2278,6 +2284,9 @@ var init_opencode2 = __esm(() => {
     getSessionId(c) {
       return c.req.header("x-opencode-session") ?? c.req.header("x-session-affinity");
     },
+    getAgentMode(c) {
+      return c.req.header("x-opencode-agent-mode");
+    },
     extractWorkingDirectory(body) {
       return extractClientCwd(body);
     },
@@ -2314,7 +2323,7 @@ var init_opencode2 = __esm(() => {
       const taskTool = body.tools.find((t) => t.name === "task" || t.name === "Task");
       if (!taskTool)
         return {};
-      return buildAgentDefinitionsFromTool(taskTool, [...mcpToolNames]);
+      return buildAgentDefinitionsFromTool(taskTool, [...mcpToolNames], mapModelTier(body.model));
     },
     buildSdkHooks(body, sdkAgents) {
       const validAgentNames = Object.keys(sdkAgents);
@@ -11111,6 +11120,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;
@@ -11121,43 +11141,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) {
@@ -20032,6 +20078,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 "";
@@ -20347,15 +20400,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;
@@ -20363,7 +20421,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);
@@ -20383,7 +20441,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 } : {}
     };
@@ -20581,7 +20640,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);
@@ -20611,7 +20671,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);
@@ -20646,13 +20707,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);
@@ -20666,7 +20728,8 @@ function storeSession(sessionId, messages, claudeSessionId, workingDirectory, sd
     messageHashes,
     messageBlockHashes,
     sdkMessageUuids,
-    ...passthroughResumeUuid ? { passthroughResumeUuid } : {},
+    ...passthroughToolCallAssistantUuid ? { passthroughToolCallAssistantUuid } : {},
+    ...passthroughToolCallIds ? { passthroughToolCallIds } : {},
     ...contextUsage ? { contextUsage } : {}
   };
   if (sessionId)
@@ -20676,7 +20739,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);
   }
 }
 
@@ -20836,21 +20899,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;
     }
@@ -21294,8 +21357,10 @@ data: ${JSON.stringify(lastError)}
         }
         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;
+        const declaredAgentMode = adapter.getAgentMode?.(c, body) ?? c.req.header("x-opencode-agent-mode") ?? null;
+        const isSubagentRequest = declaredAgentMode === "subagent" || requestSource?.startsWith("subagent-") === true;
+        const agentMode = isSubagentRequest ? "subagent" : declaredAgentMode;
         const requestedModel = typeof body.model === "string" ? body.model : "sonnet";
         let model = mapModelToClaudeModel(requestedModel, authStatus?.subscriptionType, agentMode);
         const envOverrides = explicitModelPin(requestedModel);
@@ -21389,12 +21454,12 @@ data: ${JSON.stringify(lastError)}
         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;
+        const isIndependentSession = !agentSessionId && (requestSource?.startsWith("fork-") || isSubagentRequest) || isClientDrivenLoop || false;
         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;
+        const declaresConcurrentFlow = requestSource?.startsWith("fork-") === true || isSubagentRequest;
         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.";
@@ -21457,15 +21522,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}]`;
@@ -21531,17 +21597,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
                 });
               }
@@ -21551,7 +21628,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 {
@@ -21569,13 +21646,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) => {
@@ -21590,7 +21660,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 = [];
@@ -21693,11 +21763,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;
@@ -21718,10 +21792,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) {
@@ -21753,13 +21827,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();
@@ -21797,8 +21873,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,
@@ -22031,25 +22107,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();
@@ -22093,11 +22177,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 };
@@ -22129,6 +22214,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)) {
@@ -22283,8 +22372,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({
@@ -22325,6 +22420,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)
@@ -22346,14 +22442,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;
@@ -22378,33 +22476,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;
@@ -22455,8 +22526,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,
@@ -22716,38 +22787,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 };
@@ -22757,6 +22832,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();
@@ -22796,16 +22873,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;
                         }
@@ -22929,10 +23009,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");
@@ -22947,6 +23023,7 @@ data: ${JSON.stringify({ type: "message_stop" })}
                           awaitingEarlyStopDrain = true;
                           continue;
                         }
+                        exitedBeforeCanonicalTerminal = true;
                         break;
                       }
                       if (eventType === "content_block_delta") {
@@ -23042,8 +23119,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,
@@ -23068,7 +23151,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,
@@ -23086,7 +23170,7 @@ data: ${JSON.stringify({
                       hasDeferredTools,
                       resumeSessionId: currentSessionId || resumeSessionId,
                       isUndo: false,
-                      resumeSessionAtUuid: nextPassthroughResumeUuid,
+                      resumeSessionAtUuid: nextPassthroughToolCallAssistantUuid,
                       forkSession: true,
                       sdkHooks,
                       blockedTools: pipelineCtx.blockedTools,
@@ -23116,7 +23200,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);
@@ -23145,11 +23234,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", {
@@ -23327,18 +23417,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)) {
@@ -23366,7 +23457,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, {
@@ -23549,6 +23640,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()}`;