@duckmind/dm-linux-x64 0.65.5 → 0.65.6

package/extensions/dm-subagents/src/shared/atomic-json.js

@@ -23,6 +23,7 @@ export function createAtomicJsonWriter(options = {}) {
   const mode = options.mode;
   const retryRenameErrors = options.retryRenameErrors ?? process.platform === "win32";
   const retryDirectoryErrors = options.retryDirectoryErrors ?? retryRenameErrors;
+  const ignoreCleanupErrorAfterSuccess = options.ignoreCleanupErrorAfterSuccess ?? false;
   const retryDelaysMs = options.retryDelaysMs ?? DEFAULT_FILE_SYSTEM_RETRY_DELAYS_MS;
   const renameRetryDelaysMs = retryRenameErrors ? retryDelaysMs : [];
   const directoryRetryDelaysMs = retryDirectoryErrors ? retryDelaysMs : [];
@@ -43,7 +44,7 @@ export function createAtomicJsonWriter(options = {}) {
       try {
         fsImpl.rmSync(tempPath, { force: true });
       } catch (cleanupError) {
-        if (writeError === undefined)
+        if (writeError === undefined && !ignoreCleanupErrorAfterSuccess)
           throw cleanupError;
       }
     }

package/extensions/dm-subagents/src/shared/child-cache-retention.js

@@ -0,0 +1,19 @@
+export function childCacheRetention(env = process.env) {
+  return env.DM_SUBAGENT_CACHE_RETENTION || undefined;
+}
+export function childCacheRetentionEnv(env) {
+  const retention = childCacheRetention(env);
+  return retention ? { PI_CACHE_RETENTION: retention } : {};
+}
+export function pinChildCacheRetention(agent, env) {
+  if (!agent?.streamFunction)
+    return;
+  const retention = childCacheRetention(env);
+  if (!retention)
+    return;
+  const base = agent.streamFunction;
+  agent.streamFunction = (model, context, options) => base(model, context, {
+    ...options,
+    env: { ...options?.env ?? {}, PI_CACHE_RETENTION: retention }
+  });
+}

package/extensions/dm-subagents/src/shared/fork-context.js

@@ -1,8 +1,6 @@
-import { randomUUID } from "node:crypto";
 import * as fs from "node:fs";
 import * as path from "node:path";
 import { SessionManager } from "@duckmind/dm-coding-agent";
-import { findModelInfo } from "./model-info.js";
 export function resolveSubagentContext(value) {
   return value === "fork" ? "fork" : "fresh";
 }
@@ -27,14 +25,6 @@ export function canPreferForkFromSnapshot(input) {
     return false;
   }
 }
-export function forkedChildRequiresThinkingOff(model, availableModels, preferredProvider) {
-  if (!model)
-    return true;
-  const info = findModelInfo(model, availableModels, preferredProvider);
-  if (!info)
-    return true;
-  return info.provider.toLowerCase() === "anthropic" || info.api?.toLowerCase() === "anthropic-messages";
-}
 function isUnsafeAnthropicThinkingBlock(message, block) {
   if (!message || !block || typeof block !== "object" || !("type" in block))
     return false;
@@ -50,37 +40,18 @@ function isUnsafeAnthropicThinkingBlock(message, block) {
   const signature = "thinkingSignature" in record ? record.thinkingSignature : ("signature" in record) ? record.signature : undefined;
   return record.redacted === true || typeof signature === "string" && signature.length > 0;
 }
-function createEntryId(entries) {
-  const ids = new Set(entries.map((entry) => entry.id).filter((id) => typeof id === "string"));
-  for (let attempt = 0;attempt < 100; attempt++) {
-    const id = randomUUID().slice(0, 8);
-    if (!ids.has(id))
-      return id;
-  }
-  return randomUUID();
-}
-function appendThinkingOffEntry(entries) {
-  const last = entries[entries.length - 1];
-  if (last?.type === "thinking_level_change" && last.thinkingLevel === "off")
-    return;
-  const parent = [...entries].reverse().find((entry) => typeof entry.id === "string");
-  entries.push({
-    type: "thinking_level_change",
-    id: createEntryId(entries),
-    parentId: parent?.id ?? null,
-    timestamp: new Date().toISOString(),
-    thinkingLevel: "off"
-  });
-}
 function sanitizeUnsafeThinkingBlocks(entries) {
   let sanitized = false;
+  const entriesById = new Map(entries.flatMap((entry) => entry.id ? [[entry.id, entry]] : []));
   for (const entry of entries) {
-    if (entry.type !== "message" || entry.message?.role !== "assistant" || !Array.isArray(entry.message.content))
+    const targetMessage = entry.type === "context_edit" && entry.targetId ? entriesById.get(entry.targetId)?.message : entry.message;
+    const contentOwner = entry.type === "context_edit" ? entry.replacement : targetMessage;
+    if (targetMessage?.role !== "assistant" || !contentOwner || !Array.isArray(contentOwner.content))
       continue;
-    const filtered = entry.message.content.filter((block) => !isUnsafeAnthropicThinkingBlock(entry.message, block));
-    if (filtered.length === entry.message.content.length)
+    const filtered = contentOwner.content.filter((block) => !isUnsafeAnthropicThinkingBlock(targetMessage, block));
+    if (filtered.length === contentOwner.content.length)
       continue;
-    entry.message.content = filtered;
+    contentOwner.content = filtered;
     sanitized = true;
   }
   return sanitized;
@@ -97,29 +68,12 @@ function readSessionEntries(sessionFile) {
     }
   });
 }
-export function alignForkedSessionCwd(sessionFile, cwd) {
-  const entries = readSessionEntries(sessionFile);
-  const header = entries[0];
-  if (header?.type !== "session")
-    throw new Error(`Forked session ${sessionFile} does not start with a session header.`);
-  const resolvedCwd = path.resolve(cwd);
-  const effectiveCwd = fs.realpathSync.native(resolvedCwd);
-  if (header.cwd === effectiveCwd)
-    return;
-  header.cwd = effectiveCwd;
-  fs.writeFileSync(sessionFile, `${entries.map((entry) => JSON.stringify(entry)).join(`
-`)}
-`, "utf-8");
-}
 export function createForkContextResolver(sessionManager, requestedContext, options = {}) {
   if (resolveSubagentContext(requestedContext) !== "fork") {
     return {
       prepareSessionForIndex: async () => {},
       sessionFileForIndex: () => {
         return;
-      },
-      thinkingOverrideForIndex: () => {
-        return;
       }
     };
   }
@@ -133,53 +87,65 @@ export function createForkContextResolver(sessionManager, requestedContext, opti
   }
   const openSession = options.openSession ?? sessionManager.openSession ?? ((file, dir) => SessionManager.open(file, dir));
   const sessionDir = path.join(path.dirname(parentSessionFile), path.basename(parentSessionFile, ".jsonl"), "forks");
-  const cachedResolutions = new Map;
+  const cachedSessionFiles = new Map;
   const preparedIndexes = new Set;
   const preparationPromises = new Map;
   const resolveFork = (index = 0) => {
-    const cached = cachedResolutions.get(index);
+    const cached = cachedSessionFiles.get(index);
     if (cached)
       return cached;
     try {
       if (!fs.existsSync(parentSessionFile)) {
         throw new Error(`Parent session file does not exist: ${parentSessionFile}. DM has not persisted enough history to fork yet.`);
       }
-      const sourceManager = openSession(parentSessionFile, sessionDir);
-      const sessionFile = sourceManager.createBranchedSession(leafId);
+      let sourceManager;
+      let snapshotDir;
+      if (!options.openSession && !sessionManager.openSession) {
+        fs.mkdirSync(sessionDir, { recursive: true });
+        snapshotDir = fs.mkdtempSync(path.join(sessionDir, ".snapshot-"));
+        const snapshotFile = path.join(snapshotDir, "parent.jsonl");
+        fs.copyFileSync(parentSessionFile, snapshotFile);
+        sourceManager = openSession(snapshotFile, sessionDir);
+      } else {
+        sourceManager = openSession(parentSessionFile, sessionDir);
+      }
+      let sessionFile;
+      try {
+        sessionFile = sourceManager.createDetachedBranchedSession?.(leafId) ?? sourceManager.createBranchedSession(leafId);
+      } finally {
+        if (snapshotDir) {
+          sourceManager.dispose?.();
+          fs.rmSync(snapshotDir, { recursive: true, force: true });
+        }
+      }
       if (!sessionFile) {
         throw new Error("Session manager did not return a forked session file.");
       }
-      const forceThinkingOff = (sanitized) => sanitized && (options.forceThinkingOffForIndex?.(index) ?? true);
-      let thinkingOverride;
       if (!fs.existsSync(sessionFile)) {
         const header = sourceManager.getHeader?.();
         const entries = sourceManager.getEntries?.();
         if (!header || !entries) {
           throw new Error(`Session manager returned a forked session file that does not exist and cannot be persisted by fallback: ${sessionFile}`);
         }
-        if (forceThinkingOff(sanitizeUnsafeThinkingBlocks(entries))) {
-          appendThinkingOffEntry(entries);
-          thinkingOverride = "off";
-        }
+        sanitizeUnsafeThinkingBlocks(entries);
         fs.mkdirSync(path.dirname(sessionFile), { recursive: true });
         fs.writeFileSync(sessionFile, `${[header, ...entries].map((entry) => JSON.stringify(entry)).join(`
 `)}
 `, "utf-8");
       } else {
         const entries = readSessionEntries(sessionFile);
-        if (sanitizeUnsafeThinkingBlocks(entries)) {
-          if (forceThinkingOff(true)) {
-            appendThinkingOffEntry(entries);
-            thinkingOverride = "off";
-          }
+        if (snapshotDir && entries[0]?.type === "session") {
+          entries[0].parentSession = parentSessionFile;
+        }
+        if (snapshotDir || sanitizeUnsafeThinkingBlocks(entries)) {
+          sanitizeUnsafeThinkingBlocks(entries);
           fs.writeFileSync(sessionFile, `${entries.map((entry) => JSON.stringify(entry)).join(`
 `)}
 `, "utf-8");
         }
       }
-      const resolution = { sessionFile, ...thinkingOverride ? { thinkingOverride } : {} };
-      cachedResolutions.set(index, resolution);
-      return resolution;
+      cachedSessionFiles.set(index, sessionFile);
+      return sessionFile;
     } catch (error) {
       const cause = error instanceof Error ? error : new Error(String(error));
       throw new Error(`Failed to create forked subagent session: ${cause.message}`, { cause });
@@ -187,12 +153,12 @@ export function createForkContextResolver(sessionManager, requestedContext, opti
   };
   return {
     async prepareSessionForIndex(index = 0) {
-      const resolution = resolveFork(index);
+      const sessionFile = resolveFork(index);
       if (!options.pruneSession || preparedIndexes.has(index))
         return;
       let preparation = preparationPromises.get(index);
       if (!preparation) {
-        preparation = options.pruneSession(resolution.sessionFile).then(() => {
+        preparation = options.pruneSession(sessionFile).then(() => {
           preparedIndexes.add(index);
         });
         preparationPromises.set(index, preparation);
@@ -203,10 +169,7 @@ export function createForkContextResolver(sessionManager, requestedContext, opti
       if (options.pruneSession && !preparedIndexes.has(index)) {
         throw new Error(`Pruned fork session ${index} was used before pruning completed.`);
       }
-      return resolveFork(index).sessionFile;
-    },
-    thinkingOverrideForIndex(index = 0) {
-      return resolveFork(index).thinkingOverride;
+      return resolveFork(index);
     }
   };
 }

package/extensions/dm-subagents/src/shared/fork-session-cwd.js

@@ -0,0 +1,24 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+export function alignForkedSessionCwd(sessionFile, cwd) {
+  const lines = fs.readFileSync(sessionFile, "utf-8").split(`
+`).filter((line) => line.trim().length > 0);
+  const entries = lines.map((line, index) => {
+    try {
+      return JSON.parse(line);
+    } catch (error) {
+      const cause = error instanceof Error ? error : new Error(String(error));
+      throw new Error(`Unable to inspect forked session ${sessionFile}: invalid JSONL on line ${index + 1}: ${cause.message}`, { cause });
+    }
+  });
+  const header = entries[0];
+  if (header?.type !== "session")
+    throw new Error(`Forked session ${sessionFile} does not start with a session header.`);
+  const effectiveCwd = fs.realpathSync.native(path.resolve(cwd));
+  if (header.cwd === effectiveCwd)
+    return;
+  header.cwd = effectiveCwd;
+  fs.writeFileSync(sessionFile, `${entries.map((entry) => JSON.stringify(entry)).join(`
+`)}
+`, "utf-8");
+}

package/extensions/dm-subagents/src/shared/jsonl-writer.js

@@ -21,6 +21,14 @@ export function createJsonlWriter(filePath, source, deps = {}) {
   let closed = false;
   let bytesWritten = 0;
   const maxBytes = deps.maxBytes ?? DEFAULT_MAX_JSONL_BYTES;
+  stream.on?.("error", () => {
+    closed = true;
+    stream = undefined;
+    if (backpressured) {
+      backpressured = false;
+      source.resume();
+    }
+  });
   return {
     writeLine(line) {
       if (!stream || closed || !line.trim())

package/extensions/dm-subagents/src/shared/launch-contract.js

@@ -1,7 +1,7 @@
 import { createHash } from "node:crypto";
 import * as fs from "node:fs";
-export const AGENT_DEFINITION_PROJECTION_VERSION = 1;
-export const LAUNCH_BINDING_PROJECTION_VERSION = 1;
+export const AGENT_DEFINITION_PROJECTION_VERSION = 2;
+export const LAUNCH_BINDING_PROJECTION_VERSION = 2;
 function stableJson(value) {
   if (Array.isArray(value))
     return `[${value.map(stableJson).join(",")}]`;
@@ -36,11 +36,12 @@ export function projectAgentDefinition(agent) {
     inheritSkills: agent.inheritSkills,
     model: agent.model,
     modelProvider: agent.modelProvider,
-    fallbackModels: agent.fallbackModels,
     fast: agent.fast,
     thinking: agent.thinking,
     tools: agent.tools,
+    excludeTools: agent.excludeTools,
     allowNestedSubagents: agent.allowNestedSubagents,
+    allowedAgents: agent.allowedAgents,
     mcpDirectTools: agent.mcpDirectTools,
     extensions: agent.extensions,
     subagentOnlyExtensions: agent.subagentOnlyExtensions,
@@ -48,6 +49,7 @@ export function projectAgentDefinition(agent) {
     skills: agent.skills,
     skillPath: agent.skillPath,
     output: agent.output,
+    outputSchema: agent.outputSchema,
     defaultReads: agent.defaultReads,
     defaultProgress: agent.defaultProgress,
     defaultContext: agent.defaultContext,
@@ -57,20 +59,19 @@ export function projectAgentDefinition(agent) {
     acceptanceRole: agent.acceptanceRole,
     interactive: agent.interactive,
     maxSubagentDepth: agent.maxSubagentDepth,
-    completionGuard: agent.completionGuard,
     toolBudget: agent.toolBudget,
     memory: agent.memory
   };
 }
 export function agentDefinitionDigest(agent) {
-  return stableJsonDigest(projectAgentDefinition(agent));
+  return agent.definitionDigest ?? stableJsonDigest(projectAgentDefinition(agent));
 }
 export function projectLaunchBinding(input) {
   return {
     version: LAUNCH_BINDING_PROJECTION_VERSION,
     definitionDigest: input.definitionDigest,
     taskDigest: input.task === undefined ? undefined : stableJsonDigest(input.task),
-    modelCandidates: input.modelCandidates,
+    model: input.model,
     fast: input.fast,
     thinking: input.thinking,
     systemPromptDigest: input.systemPrompt === undefined || input.systemPrompt === null ? undefined : stableJsonDigest(input.systemPrompt),
@@ -80,6 +81,7 @@ export function projectLaunchBinding(input) {
     inheritSkills: input.inheritSkills,
     skills: input.skills,
     tools: input.tools,
+    excludeTools: input.excludeTools,
     extensions: input.extensions,
     subagentOnlyExtensions: input.subagentOnlyExtensions,
     mcpDirectTools: input.mcpDirectTools,
@@ -92,3 +94,32 @@ export function projectLaunchBinding(input) {
 export function launchBindingDigest(input) {
   return stableJsonDigest(projectLaunchBinding(input));
 }
+export function resolveLaunchBinding(source) {
+  const identity = "agent" in source ? {
+    definitionDigest: agentDefinitionDigest(source.agent),
+    systemPromptMode: source.agent.systemPromptMode,
+    inheritProjectContext: source.agent.inheritProjectContext,
+    inheritGlobalContext: source.agent.inheritGlobalContext,
+    inheritSkills: source.agent.inheritSkills
+  } : source;
+  return {
+    definitionDigest: identity.definitionDigest,
+    launchContractDigest: launchBindingDigest({
+      ...identity,
+      task: source.task,
+      model: source.model,
+      fast: source.fast,
+      thinking: source.thinking || undefined,
+      systemPrompt: source.systemPrompt,
+      skills: source.skills,
+      tools: source.toolPlan.effectiveToolAllowlist,
+      excludeTools: source.toolPlan.excludeTools.length > 0 ? source.toolPlan.excludeTools : undefined,
+      extensions: source.toolPlan.extensionArgs,
+      mcpDirectTools: source.toolPlan.effectiveMcpTools,
+      outputPath: source.outputPath || undefined,
+      outputMode: source.outputMode,
+      structuredOutputSchema: source.structuredOutputSchema,
+      extensionBindings: source.extensionBindings || undefined
+    })
+  };
+}

package/extensions/dm-subagents/src/shared/model-response-aliases.js

@@ -0,0 +1,15 @@
+export function validateModelResponseAliases(value, label = "config.modelResponseAliases") {
+  if (value === undefined)
+    return;
+  if (!value || typeof value !== "object" || Array.isArray(value))
+    throw new Error(`${label} must be a JSON object`);
+  for (const [candidate, aliases] of Object.entries(value)) {
+    const slash = candidate.indexOf("/");
+    if (slash <= 0 || !candidate.slice(0, slash).trim() || !candidate.slice(slash + 1).trim()) {
+      throw new Error(`${label} key ${JSON.stringify(candidate)} must be a non-empty provider/model ID`);
+    }
+    if (!Array.isArray(aliases) || aliases.some((alias) => typeof alias !== "string" || !alias.trim())) {
+      throw new Error(`${label}[${JSON.stringify(candidate)}] must be an array of non-empty response ID strings`);
+    }
+  }
+}

package/extensions/dm-subagents/src/shared/opencode-session-headers.js

@@ -0,0 +1,15 @@
+const OPENCODE_HOST = "opencode.ai";
+function matchesOpenCodeHost(baseUrl) {
+  try {
+    return new URL(baseUrl).hostname === OPENCODE_HOST;
+  } catch {
+    return false;
+  }
+}
+export function opencodeSessionHeaders(model, sessionId) {
+  if (!sessionId)
+    return;
+  if (model.provider !== "opencode" && model.provider !== "opencode-go" && !matchesOpenCodeHost(model.baseUrl))
+    return;
+  return { "x-opencode-session": sessionId, "x-opencode-client": "dm" };
+}

package/extensions/dm-subagents/src/shared/pruned-fork.js

@@ -2,8 +2,8 @@ import { Buffer } from "node:buffer";
 import { createHash } from "node:crypto";
 import * as fs from "node:fs";
 import * as path from "node:path";
-import { completeSimple } from "@duckmind/dm-ai/compat";
-import { resolveModelCandidate } from "../runs/shared/model-fallback.js";
+import { streamSimple } from "@duckmind/dm-ai/compat";
+import { resolveModelCandidate } from "../runs/shared/model-resolution.js";
 import { splitKnownThinkingSuffix, toModelInfo } from "./model-info.js";
 const MAX_INHERITED_SESSION_BYTES = 64 * 1024;
 const MIN_USEFUL_SPILL_BYTES = 320;
@@ -67,36 +67,43 @@ function stringsInValue(value) {
     return Object.values(value).flatMap(stringsInValue);
   return [];
 }
+function pushContentStrings(strings, role, content) {
+  if (role === "toolResult")
+    strings.push(...textBlocks(content).map(({ block }) => block.text));
+  if (role === "assistant" && Array.isArray(content)) {
+    for (const blockValue of content) {
+      if (!blockValue || typeof blockValue !== "object" || Array.isArray(blockValue))
+        continue;
+      const block = blockValue;
+      if (block.type === "text" && typeof block.text === "string")
+        strings.push(block.text);
+      else if (block.type === "thinking" && typeof block.thinking === "string")
+        strings.push(block.thinking);
+      else if (block.type === "toolCall")
+        strings.push(stableJson(block.arguments ?? {}), ...stringsInValue(block.arguments));
+    }
+  }
+  if (role === "user") {
+    if (typeof content === "string")
+      strings.push(content);
+    else
+      strings.push(...textBlocks(content).map(({ block }) => block.text));
+  }
+}
 function modelFacingStrings(entries) {
   const strings = [];
+  const entriesById = new Map(entries.flatMap((entry) => entry.id ? [[entry.id, entry]] : []));
   for (const entry of entries) {
     const message = entry.type === "message" && entry.message && typeof entry.message === "object" ? entry.message : undefined;
-    if (message?.role === "toolResult")
-      strings.push(...textBlocks(message.content).map(({ block }) => block.text));
-    if (message?.role === "assistant" && Array.isArray(message.content)) {
-      for (const blockValue of message.content) {
-        if (!blockValue || typeof blockValue !== "object" || Array.isArray(blockValue))
-          continue;
-        const block = blockValue;
-        if (block.type === "text" && typeof block.text === "string")
-          strings.push(block.text);
-        else if (block.type === "thinking" && typeof block.thinking === "string")
-          strings.push(block.thinking);
-        else if (block.type === "toolCall")
-          strings.push(stableJson(block.arguments ?? {}), ...stringsInValue(block.arguments));
-      }
-    }
-    if (message?.role === "user") {
-      if (typeof message.content === "string")
-        strings.push(message.content);
-      else
-        strings.push(...textBlocks(message.content).map(({ block }) => block.text));
+    if (message)
+      pushContentStrings(strings, message.role, message.content);
+    if (entry.type === "context_edit" && entry.replacement && entry.targetId) {
+      const target = entriesById.get(entry.targetId);
+      const role = target?.type === "custom_message" ? "user" : target?.message?.role;
+      pushContentStrings(strings, role, entry.replacement.content);
     }
     if (entry.type === "custom_message") {
-      if (typeof entry.content === "string")
-        strings.push(entry.content);
-      else
-        strings.push(...textBlocks(entry.content).map(({ block }) => block.text));
+      pushContentStrings(strings, "user", entry.content);
     }
     if ((entry.type === "compaction" || entry.type === "branch_summary") && typeof entry.summary === "string")
       strings.push(entry.summary);
@@ -148,23 +155,21 @@ function collectOverflowItems(entries) {
       apply
     });
   };
-  for (const entry of entries) {
-    const message = entry.type === "message" && entry.message && typeof entry.message === "object" ? entry.message : undefined;
-    const role = message?.role;
-    if (role === "toolResult" && message) {
-      const toolCallId = typeof message.toolCallId === "string" ? message.toolCallId : undefined;
-      const toolName = typeof message.toolName === "string" ? message.toolName : undefined;
-      for (const { block } of textBlocks(message.content)) {
+  const collectContent = (entry, source, owner, userLabel = "User:") => {
+    if (source.role === "toolResult") {
+      const toolCallId = typeof source.toolCallId === "string" ? source.toolCallId : undefined;
+      const toolName = typeof source.toolName === "string" ? source.toolName : undefined;
+      for (const { block } of textBlocks(owner.content)) {
         const body = block.text;
-        add(entry, "tool-result", `Tool result: ${toolName ?? "unknown"}${toolCallId ? ` ${toolCallId}` : ""}${message.isError === true ? " (error)" : ""}`, body, (summary, ref) => {
+        add(entry, "tool-result", `Tool result: ${toolName ?? "unknown"}${toolCallId ? ` ${toolCallId}` : ""}${source.isError === true ? " (error)" : ""}`, body, (summary, ref) => {
           block.text = `${summary}
 Recovery ref: ${ref}`;
-        }, { toolCallId, toolName, isError: message.isError === true });
+        }, { toolCallId, toolName, isError: source.isError === true });
       }
-      continue;
+      return true;
     }
-    if (role === "assistant" && message && Array.isArray(message.content)) {
-      for (const blockValue of message.content) {
+    if (source.role === "assistant" && Array.isArray(owner.content)) {
+      for (const blockValue of owner.content) {
         if (!blockValue || typeof blockValue !== "object" || Array.isArray(blockValue))
           continue;
         const block = blockValue;
@@ -187,42 +192,43 @@ Recovery ref: ${ref}`;
           }, { toolCallId: block.id, toolName: block.name });
         }
       }
-      continue;
+      return true;
     }
-    if (role === "user" && message) {
-      if (typeof message.content === "string") {
-        const body = message.content;
-        add(entry, "user-text", "User:", body, (summary, ref) => {
-          message.content = `${summary}
+    if (source.role !== "user")
+      return false;
+    if (typeof owner.content === "string") {
+      const body = owner.content;
+      add(entry, "user-text", userLabel, body, (summary, ref) => {
+        owner.content = `${summary}
 Recovery ref: ${ref}`;
-        });
-      } else {
-        for (const { block } of textBlocks(message.content)) {
-          const body = block.text;
-          add(entry, "user-text", "User:", body, (summary, ref) => {
-            block.text = `${summary}
+      });
+    } else {
+      for (const { block } of textBlocks(owner.content)) {
+        const body = block.text;
+        add(entry, "user-text", userLabel, body, (summary, ref) => {
+          block.text = `${summary}
 Recovery ref: ${ref}`;
-          });
-        }
+        });
+      }
+    }
+    return true;
+  };
+  const entriesById = new Map(entries.flatMap((entry) => entry.id ? [[entry.id, entry]] : []));
+  for (const entry of entries) {
+    const message = entry.type === "message" && entry.message && typeof entry.message === "object" ? entry.message : undefined;
+    if (message && collectContent(entry, message, message))
+      continue;
+    if (entry.type === "context_edit" && entry.replacement && entry.targetId) {
+      const target = entriesById.get(entry.targetId);
+      if (target?.type === "custom_message") {
+        collectContent(entry, { role: "user" }, entry.replacement, `Extension message: ${String(target.customType ?? "unknown")}`);
+      } else if (target?.message) {
+        collectContent(entry, target.message, entry.replacement);
       }
       continue;
     }
     if (entry.type === "custom_message") {
-      if (typeof entry.content === "string") {
-        const body = entry.content;
-        add(entry, "user-text", `Extension message: ${String(entry.customType ?? "unknown")}`, body, (summary, ref) => {
-          entry.content = `${summary}
-Recovery ref: ${ref}`;
-        });
-      } else {
-        for (const { block } of textBlocks(entry.content)) {
-          const body = block.text;
-          add(entry, "user-text", `Extension message: ${String(entry.customType ?? "unknown")}`, body, (summary, ref) => {
-            block.text = `${summary}
-Recovery ref: ${ref}`;
-          });
-        }
-      }
+      collectContent(entry, { role: "user" }, entry, `Extension message: ${String(entry.customType ?? "unknown")}`);
       continue;
     }
     if ((entry.type === "compaction" || entry.type === "branch_summary") && typeof entry.summary === "string") {
@@ -397,22 +403,23 @@ export async function createPrunedForkSessionWriter(ctx, config, signal) {
   const model = ctx.modelRegistry.find(named.provider, named.id);
   if (!model)
     throw new Error(`Pruned fork model '${config.model}' was not found as '${baseModel}'.`);
-  const auth = await ctx.modelRegistry.getApiKeyAndHeaders(model);
-  if (auth.ok === false)
-    throw new Error(`Pruned fork model auth failed for ${baseModel}: ${auth.error}`);
   let sharedSummary;
   const summarize = async (payload) => {
     sharedSummary ??= (async () => {
-      const response = await completeSimple(model, {
+      const legacyStream = ctx.modelRegistry.streamSimple;
+      const auth = legacyStream ? undefined : await ctx.modelRegistry.getApiKeyAndHeaders(model);
+      if (auth && !auth.ok)
+        throw new Error(auth.error);
+      const context = {
         systemPrompt: SYSTEM_PROMPT,
         messages: [{ role: "user", content: [{ type: "text", text: payload }], timestamp: Date.now() }]
-      }, {
-        apiKey: auth.apiKey,
-        headers: auth.headers,
-        env: auth.env,
+      };
+      const options = {
         maxTokens: Math.min(MAX_SUMMARY_TOKENS, typeof model.maxTokens === "number" && model.maxTokens > 0 ? model.maxTokens : MAX_SUMMARY_TOKENS),
         signal
-      });
+      };
+      const stream = legacyStream ? legacyStream.call(ctx.modelRegistry, model, context, options) : streamSimple(model, context, { ...options, apiKey: auth.apiKey, headers: auth.headers });
+      const response = await stream.result();
       if (response.stopReason === "error" || response.stopReason === "aborted") {
         throw new Error(`Pruned fork summarization stopped with ${response.stopReason}${response.errorMessage ? `: ${response.errorMessage}` : ""}`);
       }