@duckmind/dm-windows-x64 0.61.4 → 0.61.9

package/extensions/dm-subagents/src/shared/capacity-resilient-json.js

@@ -0,0 +1,77 @@
+import { isStorageCapacityError } from "./file-system-retry.js";
+import { writeAtomicJson } from "./atomic-json.js";
+const defaultTimerApi = {
+  setTimeout: (handler, delayMs) => setTimeout(handler, delayMs),
+  clearTimeout: (handle) => clearTimeout(handle)
+};
+export function createCapacityResilientJsonWriter(options = {}) {
+  const defaultWrite = options.write ?? writeAtomicJson;
+  const keepAlive = options.keepAlive ?? false;
+  const retryDelayMs = options.retryDelayMs ?? 1000;
+  const timerApi = options.timerApi ?? defaultTimerApi;
+  const onError = options.onError ?? ((error, filePath) => console.error(`Failed to persist JSON '${filePath}':`, error));
+  const onSuccess = options.onSuccess;
+  const reportError = (error, filePath) => {
+    try {
+      onError(error, filePath);
+    } catch (callbackError) {
+      console.error(`Failed to report JSON persistence error for '${filePath}':`, callbackError);
+    }
+  };
+  const notifySuccess = (filePath, payload) => {
+    if (!onSuccess)
+      return;
+    try {
+      onSuccess(filePath, payload);
+    } catch (error) {
+      reportError(error, filePath);
+    }
+  };
+  const pending = new Map;
+  let retryTimer;
+  const scheduleRetry = () => {
+    if (retryTimer !== undefined)
+      return;
+    retryTimer = timerApi.setTimeout(() => {
+      retryTimer = undefined;
+      for (const [filePath, entry] of pending) {
+        try {
+          entry.write(filePath, entry.payload);
+          pending.delete(filePath);
+          notifySuccess(filePath, entry.payload);
+        } catch (error) {
+          if (isStorageCapacityError(error))
+            continue;
+          pending.delete(filePath);
+          reportError(error, filePath);
+        }
+      }
+      if (pending.size > 0)
+        scheduleRetry();
+    }, retryDelayMs);
+    if (!keepAlive && typeof retryTimer === "object" && retryTimer !== null && "unref" in retryTimer && typeof retryTimer.unref === "function") {
+      retryTimer.unref();
+    }
+  };
+  return {
+    write(filePath, payload, writeOperation = defaultWrite) {
+      try {
+        writeOperation(filePath, payload);
+        pending.delete(filePath);
+        notifySuccess(filePath, payload);
+      } catch (error) {
+        if (!isStorageCapacityError(error))
+          throw error;
+        pending.set(filePath, { payload, write: writeOperation });
+        scheduleRetry();
+      }
+    },
+    pendingCount: () => pending.size,
+    dispose: () => {
+      if (retryTimer !== undefined)
+        timerApi.clearTimeout(retryTimer);
+      retryTimer = undefined;
+      pending.clear();
+    }
+  };
+}

package/extensions/dm-subagents/src/shared/child-session-name.js

@@ -0,0 +1,15 @@
+import { previewDisplayText } from "./display-text.js";
+import { PROMPT_REDACTED } from "./utils.js";
+const TASK_EXCERPT_MAX_CHARS = 60;
+export const CHILD_SESSION_NAME_MAX_CHARS = 80;
+export function deriveChildSessionName(input) {
+  const agent = input.agent?.trim() ?? "";
+  const rawLabel = input.label?.trim() ?? "";
+  const rawTask = input.task?.trim() ?? "";
+  const excerptSource = rawLabel && rawLabel !== PROMPT_REDACTED ? rawLabel : rawTask && rawTask !== PROMPT_REDACTED ? rawTask : "";
+  const excerpt = excerptSource ? previewDisplayText(excerptSource, TASK_EXCERPT_MAX_CHARS) : "";
+  const base = agent && excerpt ? `${agent}: ${excerpt}` : agent || excerpt;
+  if (!base)
+    return;
+  return previewDisplayText(base, CHILD_SESSION_NAME_MAX_CHARS);
+}

package/extensions/dm-subagents/src/shared/child-transcript.js

@@ -1,6 +1,35 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
 import { extractTextFromContent, extractToolArgsPreview } from "./utils.js";
+const MAX_TOOL_PAYLOAD_BYTES = 32 * 1024;
+const TOOL_PAYLOAD_TRUNCATION_MARKER = `
+
+… payload truncated`;
+function boundedPayload(value, maxBytes = MAX_TOOL_PAYLOAD_BYTES) {
+  let text;
+  if (typeof value === "string")
+    text = value;
+  else {
+    try {
+      const serialized = JSON.stringify(value, null, 2);
+      if (serialized === undefined)
+        return;
+      text = serialized;
+    } catch {
+      return;
+    }
+  }
+  if (!text.trim())
+    return;
+  const payload = Buffer.from(text, "utf-8");
+  if (payload.length <= maxBytes)
+    return text;
+  const markerBytes = Buffer.byteLength(TOOL_PAYLOAD_TRUNCATION_MARKER, "utf-8");
+  let end = Math.max(0, maxBytes - markerBytes);
+  while (end > 0 && (payload[end] & 192) === 128)
+    end--;
+  return `${payload.subarray(0, end).toString("utf-8")}${TOOL_PAYLOAD_TRUNCATION_MARKER}`;
+}
 export const CHILD_TRANSCRIPT_ARTIFACT_VERSION = 1;
 const DEFAULT_MAX_CHILD_TRANSCRIPT_BYTES = 50 * 1024 * 1024;
 function errorMessage(error) {
@@ -100,6 +129,27 @@ export function createChildTranscriptWriter(input) {
   }
   const writeMessage = (sourceEventType, message) => {
     const text = extractTextFromContent(message.content);
+    if (message.role === "toolResult") {
+      const output = boundedPayload(text);
+      writeRecord({
+        ...baseRecord("message"),
+        sourceEventType,
+        role: message.role,
+        toolCallId: message.toolCallId,
+        toolName: message.toolName,
+        isError: message.isError,
+        ...output ? { text: output, outputTruncated: output.includes("… payload truncated") } : {},
+        message: {
+          role: message.role,
+          toolCallId: message.toolCallId,
+          toolName: message.toolName,
+          isError: message.isError,
+          content: output ? [{ type: "text", text: output }] : [],
+          ...message.timestamp !== undefined ? { timestamp: message.timestamp } : {}
+        }
+      });
+      return;
+    }
     writeRecord({
       ...baseRecord("message"),
       sourceEventType,
@@ -130,11 +180,14 @@ export function createChildTranscriptWriter(input) {
       }
       if (event.type === "tool_execution_start" && event.toolName) {
         const args = eventArgs(event);
+        const argsPayload = boundedPayload(args);
         writeRecord({
           ...baseRecord("tool_start"),
           sourceEventType: event.type,
+          ...event.toolCallId ? { toolCallId: event.toolCallId } : {},
           toolName: event.toolName,
-          ...Object.keys(args).length > 0 ? { argsPreview: extractToolArgsPreview(args) } : {}
+          ...Object.keys(args).length > 0 ? { argsPreview: extractToolArgsPreview(args) } : {},
+          ...argsPayload ? { argsPayload } : {}
         });
         return;
       }
@@ -142,7 +195,9 @@ export function createChildTranscriptWriter(input) {
         writeRecord({
           ...baseRecord("tool_end"),
           sourceEventType: event.type,
-          ...event.toolName ? { toolName: event.toolName } : {}
+          ...event.toolCallId ? { toolCallId: event.toolCallId } : {},
+          ...event.toolName ? { toolName: event.toolName } : {},
+          ...typeof event.isError === "boolean" ? { isError: event.isError } : {}
         });
       }
     },

package/extensions/dm-subagents/src/shared/completion-owner.js

@@ -0,0 +1,7 @@
+import { randomUUID } from "node:crypto";
+const COMPLETION_OWNER_KEY = Symbol.for("dm-subagents.completion-owner-id");
+export function currentCompletionOwnerId() {
+  const runtime = globalThis;
+  runtime[COMPLETION_OWNER_KEY] ??= randomUUID();
+  return runtime[COMPLETION_OWNER_KEY];
+}

package/extensions/dm-subagents/src/shared/display-text.js

@@ -0,0 +1,142 @@
+function codePointWidth(codePoint) {
+  return codePoint > 65535 ? 2 : 1;
+}
+function isWhitespaceOrControl(codePoint) {
+  if (codePoint <= 32 || codePoint >= 127 && codePoint <= 159)
+    return true;
+  if (codePoint >= 55296 && codePoint <= 57343)
+    return true;
+  return String.fromCodePoint(codePoint).trim().length === 0;
+}
+function consumeControlString(value, index, osc) {
+  while (index < value.length) {
+    const codePoint = value.codePointAt(index);
+    const width = codePointWidth(codePoint);
+    if (osc && codePoint === 7)
+      return index + width;
+    if (codePoint === 156)
+      return index + width;
+    if (codePoint === 27 && value.charCodeAt(index + 1) === 92)
+      return index + 2;
+    index += width;
+  }
+  return value.length;
+}
+function consumeCsi(value, index) {
+  while (index < value.length) {
+    const codePoint = value.codePointAt(index);
+    const width = codePointWidth(codePoint);
+    if (codePoint >= 64 && codePoint <= 126)
+      return index + width;
+    index += width;
+  }
+  return value.length;
+}
+export function sanitizeDisplayText(value) {
+  const output = [];
+  let pendingSpace = false;
+  const appendSpace = () => {
+    if (output.length > 0)
+      pendingSpace = true;
+  };
+  const appendText = (text) => {
+    if (pendingSpace)
+      output.push(" ");
+    output.push(text);
+    pendingSpace = false;
+  };
+  for (let index = 0;index < value.length; ) {
+    const codePoint = value.codePointAt(index);
+    const width = codePointWidth(codePoint);
+    if (codePoint === 27) {
+      const next = value.charCodeAt(index + 1);
+      appendSpace();
+      if (next === 91) {
+        index = consumeCsi(value, index + 2);
+        continue;
+      }
+      if (next === 93 || next === 80 || next === 88 || next === 94 || next === 95) {
+        index = consumeControlString(value, index + 2, next === 93);
+        continue;
+      }
+      index += next ? 2 : 1;
+      continue;
+    }
+    if (codePoint === 155) {
+      appendSpace();
+      index = consumeCsi(value, index + width);
+      continue;
+    }
+    if (codePoint === 144 || codePoint === 152 || codePoint === 157 || codePoint === 158 || codePoint === 159) {
+      appendSpace();
+      index = consumeControlString(value, index + width, codePoint === 157);
+      continue;
+    }
+    if (isWhitespaceOrControl(codePoint))
+      appendSpace();
+    else
+      appendText(String.fromCodePoint(codePoint));
+    index += width;
+  }
+  return output.join("");
+}
+export function truncateDisplayText(value, maxLength) {
+  if (maxLength <= 0)
+    return "";
+  if (value.length <= maxLength)
+    return value;
+  let output = "";
+  for (const char of value) {
+    if (output.length + char.length > maxLength)
+      break;
+    output += char;
+  }
+  return output;
+}
+export function previewDisplayText(value, maxLength) {
+  const normalized = sanitizeDisplayText(value);
+  if (normalized.length <= maxLength)
+    return normalized;
+  if (maxLength <= 3)
+    return truncateDisplayText(normalized, maxLength);
+  return `${truncateDisplayText(normalized, maxLength - 3)}...`;
+}
+const BINARY_CONTENT_PLACEHOLDER = "[binary content omitted for safe display]";
+function isUnsafeTerminalCodePoint(codePoint) {
+  const terminalControl = codePoint <= 31 && codePoint !== 9 && codePoint !== 10 || codePoint >= 127 && codePoint <= 159;
+  const bidiControl = codePoint === 1564 || codePoint === 8206 || codePoint === 8207 || codePoint >= 8234 && codePoint <= 8238 || codePoint >= 8294 && codePoint <= 8297;
+  const privateUse = codePoint >= 57344 && codePoint <= 63743 || codePoint >= 983040 && codePoint <= 1048573 || codePoint >= 1048576 && codePoint <= 1114109;
+  const invalidScalar = codePoint >= 55296 && codePoint <= 57343;
+  const nonCharacter = codePoint >= 64976 && codePoint <= 65007 || (codePoint & 65535) === 65534 || (codePoint & 65535) === 65535;
+  return terminalControl || bidiControl || privateUse || invalidScalar || nonCharacter;
+}
+function looksLikeBinaryContent(text) {
+  if (text.includes("\x00"))
+    return true;
+  let suspiciousControls = 0;
+  let replacementCharacters = 0;
+  let codePoints = 0;
+  for (const character of text) {
+    codePoints++;
+    const codePoint = character.codePointAt(0) ?? 0;
+    if (codePoint <= 8 || codePoint >= 14 && codePoint <= 31)
+      suspiciousControls++;
+    if (codePoint === 65533)
+      replacementCharacters++;
+  }
+  if (codePoints === 0)
+    return false;
+  return suspiciousControls >= 4 && suspiciousControls / codePoints >= 0.1 || replacementCharacters >= 3 && replacementCharacters / codePoints >= 0.1;
+}
+export function safeTerminalText(value) {
+  const normalized = value.replace(/\r\n/g, `
+`);
+  if (looksLikeBinaryContent(normalized))
+    return BINARY_CONTENT_PLACEHOLDER;
+  let safe = "";
+  for (const character of normalized) {
+    const codePoint = character.codePointAt(0) ?? 0;
+    safe += isUnsafeTerminalCodePoint(codePoint) ? `[U+${codePoint.toString(16).toUpperCase().padStart(4, "0")}]` : character;
+  }
+  return safe;
+}

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

@@ -0,0 +1,17 @@
+export function isStaleExtensionContextError(error) {
+  return error instanceof Error && /extension ctx is stale|extension context no longer active|stale after session replacement or reload/i.test(error.message);
+}
+export function withCachedUiContext(ctx, onStale, run) {
+  if (!ctx)
+    return;
+  try {
+    if (!ctx.hasUI)
+      return;
+    return run(ctx);
+  } catch (error) {
+    if (!isStaleExtensionContextError(error))
+      throw error;
+    onStale();
+    return;
+  }
+}

package/extensions/dm-subagents/src/shared/file-coalescer.js

@@ -15,6 +15,15 @@ export function createFileCoalescer(handler, defaultDelayMs, timerApi = defaultT
       pending.set(file, timer);
       return true;
     },
+    flush(file) {
+      const timer = pending.get(file);
+      if (timer === undefined)
+        return false;
+      timerApi.clearTimeout(timer);
+      pending.delete(file);
+      handler(file);
+      return true;
+    },
     clear() {
       for (const timer of pending.values()) {
         timerApi.clearTimeout(timer);

package/extensions/dm-subagents/src/shared/file-system-retry.js

@@ -0,0 +1,56 @@
+const WAIT_BUFFER = typeof SharedArrayBuffer !== "undefined" ? new SharedArrayBuffer(4) : undefined;
+const WAIT_VIEW = WAIT_BUFFER ? new Int32Array(WAIT_BUFFER) : undefined;
+const RETRYABLE_FILE_SYSTEM_ERROR_CODES = new Set(["EACCES", "EBUSY", "EPERM"]);
+const STORAGE_CAPACITY_ERROR_CODES = new Set(["EDQUOT", "EMFILE", "ENFILE", "ENOSPC"]);
+export const FS_RETRY_MAX_TOTAL_MS_ENV = "DM_SUBAGENT_FS_RETRY_MAX_TOTAL_MS";
+const BASE_FILE_SYSTEM_RETRY_DELAYS_MS = [10, 25, 50, 100, 200, 500, 1000, 2000, 4000];
+export function resolveFileSystemRetryDelays(env = process.env, base = BASE_FILE_SYSTEM_RETRY_DELAYS_MS) {
+  const raw = env[FS_RETRY_MAX_TOTAL_MS_ENV];
+  if (raw === undefined || raw.trim() === "")
+    return base;
+  const budget = Number(raw);
+  if (!Number.isInteger(budget) || budget < 0) {
+    throw new Error(`${FS_RETRY_MAX_TOTAL_MS_ENV} must be a non-negative integer number of milliseconds.`);
+  }
+  let spent = 0;
+  return base.map((delayMs) => {
+    const allowed = Math.max(0, Math.min(delayMs, budget - spent));
+    spent += allowed;
+    return allowed;
+  });
+}
+export const DEFAULT_FILE_SYSTEM_RETRY_DELAYS_MS = resolveFileSystemRetryDelays();
+export function waitForFileSystemRetry(delayMs) {
+  if (delayMs <= 0)
+    return;
+  if (WAIT_VIEW) {
+    try {
+      Atomics.wait(WAIT_VIEW, 0, 0, delayMs);
+      return;
+    } catch {}
+  }
+  const end = Date.now() + delayMs;
+  while (Date.now() < end) {}
+}
+export function isRetryableFileSystemError(error) {
+  const code = error?.code;
+  return typeof code === "string" && RETRYABLE_FILE_SYSTEM_ERROR_CODES.has(code);
+}
+export function isStorageCapacityError(error) {
+  const code = error?.code;
+  return typeof code === "string" && STORAGE_CAPACITY_ERROR_CODES.has(code);
+}
+export function runFileSystemOperationWithRetry(operation, options = {}) {
+  const retryDelaysMs = options.retryDelaysMs ?? DEFAULT_FILE_SYSTEM_RETRY_DELAYS_MS;
+  const wait = options.wait ?? waitForFileSystemRetry;
+  for (let attempt = 0;; attempt++) {
+    try {
+      return operation();
+    } catch (error) {
+      const delayMs = retryDelaysMs[attempt];
+      if (delayMs === undefined || !isRetryableFileSystemError(error))
+        throw error;
+      wait(delayMs);
+    }
+  }
+}

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

@@ -2,9 +2,39 @@ 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";
 }
+export function resolveSubagentLaunchContext(input) {
+  if (input.explicitContext !== undefined)
+    return input.explicitContext;
+  const preferredContext = input.defaultSubagentContext ?? input.agentDefaultContext ?? "fresh";
+  return preferredContext === "fork" && input.canUseImplicitFork ? "fork" : "fresh";
+}
+export function canPreferFork(sessionManager) {
+  return canPreferForkFromSnapshot({
+    parentSessionFile: sessionManager.getSessionFile(),
+    leafId: sessionManager.getLeafId?.() ?? null
+  });
+}
+export function canPreferForkFromSnapshot(input) {
+  if (!input.parentSessionFile || !input.leafId)
+    return false;
+  try {
+    return fs.existsSync(input.parentSessionFile);
+  } catch {
+    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;
@@ -16,8 +46,9 @@ function isUnsafeAnthropicThinkingBlock(message, block) {
     return true;
   if (block.type !== "thinking" || !isAnthropic)
     return false;
-  const signature = "thinkingSignature" in block ? block.thinkingSignature : ("signature" in block) ? block.signature : undefined;
-  return block.redacted === true || typeof signature === "string" && signature.length > 0;
+  const record = 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"));
@@ -52,8 +83,6 @@ function sanitizeUnsafeThinkingBlocks(entries) {
     entry.message.content = filtered;
     sanitized = true;
   }
-  if (sanitized)
-    appendThinkingOffEntry(entries);
   return sanitized;
 }
 function readSessionEntries(sessionFile) {
@@ -68,9 +97,24 @@ 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;
       },
@@ -87,10 +131,11 @@ export function createForkContextResolver(sessionManager, requestedContext, opti
   if (!leafId) {
     throw new Error("Forked subagent context requires a current leaf to fork from.");
   }
-  const explicitOpenSession = options.openSession ?? sessionManager.openSession;
-  const openSession = explicitOpenSession ?? ((file, dir) => SessionManager.open(file, dir));
-  const sessionDir = sessionManager.getSessionDir?.();
+  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 preparedIndexes = new Set;
+  const preparationPromises = new Map;
   const resolveFork = (index = 0) => {
     const cached = cachedResolutions.get(index);
     if (cached)
@@ -99,47 +144,65 @@ export function createForkContextResolver(sessionManager, requestedContext, opti
       if (!fs.existsSync(parentSessionFile)) {
         throw new Error(`Parent session file does not exist: ${parentSessionFile}. DM has not persisted enough history to fork yet.`);
       }
-      let sourceManager;
-      try {
-        const sessionFile = typeof sessionManager.createDetachedBranchedSession === "function" ? sessionManager.createDetachedBranchedSession(leafId) : (sourceManager = openSession(parentSessionFile, sessionDir)).createBranchedSession(leafId);
-        if (!sessionFile) {
-          throw new Error("Session manager did not return a forked session file.");
+      const sourceManager = openSession(parentSessionFile, sessionDir);
+      const sessionFile = sourceManager.createBranchedSession(leafId);
+      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}`);
         }
-        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 (sanitizeUnsafeThinkingBlocks(entries))
-            thinkingOverride = "off";
-          fs.mkdirSync(path.dirname(sessionFile), { recursive: true });
-          fs.writeFileSync(sessionFile, `${[header, ...entries].map((entry) => JSON.stringify(entry)).join(`
+        if (forceThinkingOff(sanitizeUnsafeThinkingBlocks(entries))) {
+          appendThinkingOffEntry(entries);
+          thinkingOverride = "off";
+        }
+        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)) {
+      } else {
+        const entries = readSessionEntries(sessionFile);
+        if (sanitizeUnsafeThinkingBlocks(entries)) {
+          if (forceThinkingOff(true)) {
+            appendThinkingOffEntry(entries);
             thinkingOverride = "off";
-            fs.writeFileSync(sessionFile, `${entries.map((entry) => JSON.stringify(entry)).join(`
+          }
+          fs.writeFileSync(sessionFile, `${entries.map((entry) => JSON.stringify(entry)).join(`
 `)}
 `, "utf-8");
-          }
         }
-        const resolution = { sessionFile, ...thinkingOverride ? { thinkingOverride } : {} };
-        cachedResolutions.set(index, resolution);
-        return resolution;
-      } finally {
-        sourceManager?.dispose?.();
       }
+      const resolution = { sessionFile, ...thinkingOverride ? { thinkingOverride } : {} };
+      cachedResolutions.set(index, resolution);
+      return resolution;
     } catch (error) {
       const cause = error instanceof Error ? error : new Error(String(error));
       throw new Error(`Failed to create forked subagent session: ${cause.message}`, { cause });
     }
   };
   return {
+    async prepareSessionForIndex(index = 0) {
+      const resolution = resolveFork(index);
+      if (!options.pruneSession || preparedIndexes.has(index))
+        return;
+      let preparation = preparationPromises.get(index);
+      if (!preparation) {
+        preparation = options.pruneSession(resolution.sessionFile).then(() => {
+          preparedIndexes.add(index);
+        });
+        preparationPromises.set(index, preparation);
+      }
+      await preparation;
+    },
     sessionFileForIndex(index = 0) {
+      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) {

package/extensions/dm-subagents/src/shared/formatters.js

@@ -1,9 +1,26 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
 import { isDynamicParallelStep, isParallelStep } from "./settings.js";
+import { previewDisplayText, sanitizeDisplayText } from "./display-text.js";
 import { splitKnownThinkingSuffix, THINKING_LEVELS } from "./model-info.js";
 export function formatTokens(n) {
-  return n < 1000 ? String(n) : n < 1e4 ? `${(n / 1000).toFixed(1)}k` : `${Math.round(n / 1000)}k`;
+  if (n < 1000)
+    return String(n);
+  if (n < 1e4)
+    return `${(n / 1000).toFixed(1)}k`;
+  if (n < 999500)
+    return `${Math.round(n / 1000)}k`;
+  return `${Number((n / 1e6).toFixed(1))}M`;
+}
+export function formatTokenUsage(usage, legacyLabel = "tok") {
+  return usage.window !== undefined ? `${formatTokens(usage.window)} window · ${formatTokens(usage.total)} spent` : `${formatTokens(usage.total)} ${legacyLabel}`;
+}
+export function formatContextUsage(usage, contextLimit) {
+  if (usage.window === undefined || !Number.isFinite(usage.window) || !Number.isFinite(contextLimit) || contextLimit <= 0)
+    return;
+  const peak = usage.windowPeak !== undefined && Number.isFinite(usage.windowPeak) ? usage.windowPeak : usage.window;
+  const used = Math.max(0, usage.window, peak);
+  return `ctx ${formatTokens(used)}/${formatTokens(contextLimit)} (${Math.round(used / contextLimit * 100)}%)`;
 }
 export function formatModelThinking(model, thinking) {
   const parsed = model ? splitKnownThinkingSuffix(model) : undefined;
@@ -75,19 +92,16 @@ export function formatToolCall(name, args, expanded = false) {
   switch (name) {
     case "bash": {
       const command = typeof args.command === "string" ? args.command : "";
-      const maxLength = expanded ? 240 : 60;
-      return `$ ${command.slice(0, maxLength)}${command.length > maxLength ? "..." : ""}`;
+      return `$ ${previewDisplayText(command, expanded ? 240 : 60)}`;
     }
     case "read":
     case "write":
     case "edit": {
       const target = typeof args.path === "string" ? args.path : typeof args.file_path === "string" ? args.file_path : "";
-      return `${name} ${shortenPath(target)}`;
+      return `${name} ${sanitizeDisplayText(shortenPath(target))}`;
     }
     default: {
-      const s = JSON.stringify(args);
-      const maxLength = expanded ? 160 : 40;
-      return `${name} ${s.slice(0, maxLength)}${s.length > maxLength ? "..." : ""}`;
+      return `${name} ${previewDisplayText(JSON.stringify(args), expanded ? 160 : 40)}`;
     }
   }
 }