@duckmind/dm-darwin-x64 0.66.5 → 0.66.7

package/extensions/dm-subagents/src/runs/shared/worktree.js

@@ -17,7 +17,7 @@ const WORKTREE_NAMING_BRANCH_MAX_BYTES = 256;
 const WORKTREE_COMMAND_OUTPUT_MAX_BYTES = 128 * 1024;
 const WORKTRUNK_COMMAND = process.platform === "win32" ? "git" : "wt";
 const WORKTRUNK_ARG_PREFIX = process.platform === "win32" ? ["wt"] : [];
-export const MACHINE_DIFF_OPTIONS = ["--no-color", "--no-ext-diff", "--no-textconv", "--default-prefix", "--line-prefix=", "--no-relative"];
+export const MACHINE_DIFF_OPTIONS = ["--no-color", "--no-ext-diff", "--no-textconv", "--src-prefix=a/", "--dst-prefix=b/", "--line-prefix=", "--no-relative"];
 const MACHINE_PATCH_OPTIONS = [...MACHINE_DIFF_OPTIONS, "--binary"];
 const PATCH_VALIDATION_OPTIONS = ["apply", "--check", "--cached", "--reverse", "--binary", "--whitespace=nowarn"];
 const DEFAULT_WORKTREE_SETUP_HOOK_TIMEOUT_MS = 30000;
@@ -728,9 +728,11 @@ async function createNativeWorktree(tx, toplevel, cwdRelative, runId, index, bas
     throw new Error(`worktree path or branch already exists: ${worktreePath}, ${naming.requestedBranch}`);
   tx.attempt(index, naming.requestedBranch, worktreePath);
   ensureProjectWorktreeDir(dedicatedRoot, toplevel);
+  const recordedBaseDir = normalizeComparableCwd(path.dirname(worktreePath));
   await tx.git(toplevel, ["worktree", "add", worktreePath, "-b", naming.requestedBranch, baseCommit]);
   const worktree = {
     path: worktreePath,
+    recordedBaseDir,
     agentCwd: worktreePath,
     branch: naming.requestedBranch,
     index,
@@ -797,6 +799,7 @@ async function createWorktrunkWorktree(tx, toplevel, cwdRelative, runId, index,
       throw new Error("Worktrunk provisioning returned a worktree at a different base commit");
     const worktree = {
       path: worktreePath,
+      recordedBaseDir: normalizeComparableCwd(path.dirname(worktreePath)),
       agentCwd: cwdRelative ? path.join(worktreePath, cwdRelative) : worktreePath,
       branch: naming.requestedBranch,
       index,
@@ -934,6 +937,7 @@ function cleanupSingleWorktree(setup, worktree, intent) {
       branch: worktree.branch,
       ...worktree.provider ? { provider: worktree.provider } : {},
       ...worktree.naming ? { naming: worktree.naming } : {},
+      ...worktree.recordedBaseDir ? { recordedBaseDir: worktree.recordedBaseDir } : {},
       worktreeRemoved: false,
       branchRemoved: false,
       preserved: true,
@@ -956,6 +960,7 @@ function cleanupSingleWorktree(setup, worktree, intent) {
         branch: worktree.branch,
         ...worktree.provider ? { provider: worktree.provider } : {},
         ...worktree.naming ? { naming: worktree.naming } : {},
+        ...worktree.recordedBaseDir ? { recordedBaseDir: worktree.recordedBaseDir } : {},
         worktreeRemoved: false,
         branchRemoved: false,
         preserved: true,
@@ -986,6 +991,7 @@ function cleanupSingleWorktree(setup, worktree, intent) {
           branch: worktree.branch,
           ...worktree.provider ? { provider: worktree.provider } : {},
           ...worktree.naming ? { naming: worktree.naming } : {},
+          ...worktree.recordedBaseDir ? { recordedBaseDir: worktree.recordedBaseDir } : {},
           worktreeRemoved: false,
           branchRemoved: false,
           preserved: true,
@@ -1005,6 +1011,7 @@ function cleanupSingleWorktree(setup, worktree, intent) {
           branch: worktree.branch,
           ...worktree.provider ? { provider: worktree.provider } : {},
           ...worktree.naming ? { naming: worktree.naming } : {},
+          ...worktree.recordedBaseDir ? { recordedBaseDir: worktree.recordedBaseDir } : {},
           worktreeRemoved: false,
           branchRemoved: false,
           preserved: true,
@@ -1034,6 +1041,7 @@ function cleanupSingleWorktree(setup, worktree, intent) {
     branch: worktree.branch,
     ...worktree.provider ? { provider: worktree.provider } : {},
     ...worktree.naming ? { naming: worktree.naming } : {},
+    ...worktree.recordedBaseDir ? { recordedBaseDir: worktree.recordedBaseDir } : {},
     worktreeRemoved,
     branchRemoved,
     ...errors.length ? { errors } : {}
@@ -1081,6 +1089,7 @@ async function compensateSetup(tx) {
       branch: attempt.branch,
       provider: known?.provider ?? "native",
       naming: known?.naming,
+      recordedBaseDir: known?.recordedBaseDir,
       worktreeRemoved: false,
       branchRemoved: false
     };

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

@@ -28,7 +28,7 @@ export function createAtomicJsonWriter(options = {}) {
   const renameRetryDelaysMs = retryRenameErrors ? retryDelaysMs : [];
   const directoryRetryDelaysMs = retryDirectoryErrors ? retryDelaysMs : [];
   const wait = options.wait ?? waitForFileSystemRetry;
-  return (filePath, payload) => {
+  return (filePath, payload, beforeRename) => {
     runFileSystemOperationWithRetry(() => {
       fsImpl.mkdirSync(path.dirname(filePath), { recursive: true });
     }, { retryDelaysMs: directoryRetryDelaysMs, wait });
@@ -36,6 +36,7 @@ export function createAtomicJsonWriter(options = {}) {
     let writeError;
     try {
       fsImpl.writeFileSync(tempPath, JSON.stringify(payload, null, 2), mode === undefined ? "utf-8" : { encoding: "utf-8", mode });
+      beforeRename?.();
       renameWithRetry(fsImpl, tempPath, filePath, renameRetryDelaysMs, wait);
     } catch (error) {
       writeError = error;

package/extensions/dm-subagents/src/shared/disabled-features.js

@@ -0,0 +1,101 @@
+export const SUBAGENT_FEATURES = {
+  "agent-management": {
+    actions: ["create", "update", "delete", "eject", "disable", "enable", "reset", "refine", "refine.show", "refine.rollback"],
+    params: ["config"]
+  },
+  watchdog: {
+    actions: ["watchdog.status", "watchdog.check", "watchdog.configure", "watchdog.recommend-model"],
+    params: ["scope", "target", "thinking"]
+  },
+  panes: {
+    actions: ["inspector.open", "inspector.command", "inspector.status", "inspector.close", "project.open", "project.status", "project.close"],
+    params: ["focus"]
+  },
+  missions: {
+    actions: ["mission.create", "mission.list", "mission.show", "mission.update", "mission.resolve-decision", "mission.attach-run", "mission.close"],
+    params: ["mission", "missionUpdate", "missionStatus", "missionScope", "missionId", "runMode", "runStatus", "summary"]
+  },
+  "lane-management": {
+    actions: ["lane.status", "lane.recordMerge", "lane.recordSupersession", "worktree.discard", "worktree.cleanup"],
+    params: ["handoffPath", "laneId", "merge", "supersession", "repo", "planId"]
+  },
+  "spawn-budget-grants": { actions: ["grant-spawn-budget"], params: ["additional"] },
+  preflight: { actions: [], params: ["preflight"] },
+  "lane-metadata": { actions: [], params: ["lane"] },
+  gates: { actions: [], params: ["gate"] },
+  "usage-budgets": { actions: [], params: ["usageBudget"] },
+  "tool-budgets": { actions: [], params: ["toolBudget"] },
+  "control-overrides": { actions: [], params: ["control"] },
+  "extension-bindings": { actions: [], params: ["extensionBindings"] },
+  "external-machines": { actions: [], params: ["machine"] },
+  "workflow-scripts": { actions: ["validate"], params: ["workflow", "args", "preflight", "globalConcurrencyLimit", "maxSubagentSpawnsPerRun"] }
+};
+const SCHEDULE_SURFACE = {
+  actions: ["schedule.create", "schedule.list", "schedule.show", "schedule.history", "schedule.pause", "schedule.resume", "schedule.run", "schedule.run-due", "schedule.delete"],
+  params: ["name", "at", "every", "sessionOnly", "quiet", "on", "timezone", "overlap", "catchUp"]
+};
+export function validateDisabledFeatures(value) {
+  if (value === undefined)
+    return;
+  if (!Array.isArray(value))
+    throw new Error("config.disabledFeatures must be an array of feature names");
+  const seen = new Set;
+  for (const entry of value) {
+    if (entry === "schedules")
+      throw new Error(`config.disabledFeatures does not accept "schedules"; set config.scheduledRuns.enabled to false instead`);
+    if (typeof entry !== "string" || !Object.hasOwn(SUBAGENT_FEATURES, entry)) {
+      throw new Error(`config.disabledFeatures entry ${JSON.stringify(entry)} is not one of: ${Object.keys(SUBAGENT_FEATURES).join(", ")}`);
+    }
+    if (seen.has(entry))
+      throw new Error(`config.disabledFeatures lists "${entry}" more than once`);
+    seen.add(entry);
+  }
+}
+function featureSurface(feature) {
+  if (feature === "schedules")
+    return { ...SCHEDULE_SURFACE, disabledBy: "scheduledRuns.enabled=false" };
+  return { ...SUBAGENT_FEATURES[feature], disabledBy: `disabledFeatures "${feature}"` };
+}
+export function resolveDisabledFeatureSurface(config) {
+  const features = new Set(config.disabledFeatures);
+  if (config.scheduledRuns?.enabled === false)
+    features.add("schedules");
+  const params = new Map;
+  const actions = new Map;
+  for (const feature of features) {
+    const surface = featureSurface(feature);
+    for (const param of surface.params)
+      if (feature === "workflow-scripts" || !params.has(param))
+        params.set(param, surface.disabledBy);
+    for (const action of surface.actions)
+      actions.set(action, surface.disabledBy);
+  }
+  return { features, params, actions };
+}
+export function disabledFeatureUseError(request, surface, label = "subagent") {
+  const params = request;
+  const action = typeof params.action === "string" ? params.action.trim() : undefined;
+  const disabledAction = action === undefined ? undefined : surface.actions.get(action);
+  if (disabledAction)
+    return `${label} action '${action}' is disabled by config ${disabledAction}.`;
+  for (const [param, disabledBy] of surface.params) {
+    if (params[param] !== undefined)
+      return `${label} option '${param}' is disabled by config ${disabledBy}.`;
+  }
+  if (params.workflowScript !== undefined && surface.features.has("workflow-scripts")) {
+    return `${label} workflow scripts are disabled by config ${featureSurface("workflow-scripts").disabledBy}.`;
+  }
+  return;
+}
+export function disabledFeatureNotice(surface) {
+  if (surface.features.size === 0)
+    return;
+  const lines = [...surface.features].map((feature) => {
+    const { actions, params, disabledBy } = featureSurface(feature);
+    const parts = [`options ${params.join(", ")}`, ...actions.length > 0 ? [`actions ${actions.join(", ")}`] : []];
+    return `- ${disabledBy}: ${parts.join("; ")}`;
+  });
+  return `Disabled by config in this session. The reference below still lists these, but calls that use them are rejected:
+${lines.join(`
+`)}`;
+}

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

@@ -0,0 +1,14 @@
+export function getCurrentSystemMessage(messages) {
+  return [...messages].reverse().find((message) => message.role === "system");
+}
+export function toToolDeclaration(tool) {
+  return {
+    name: tool.name,
+    description: tool.description,
+    parameters: tool.parameters,
+    ...tool.constrainedSampling === undefined ? {} : { constrainedSampling: tool.constrainedSampling }
+  };
+}
+export function declarationsEqual(left, right) {
+  return JSON.stringify(toToolDeclaration(left)) === JSON.stringify(toToolDeclaration(right));
+}

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

@@ -0,0 +1,41 @@
+const READ_ONLY = new Set([
+  "read",
+  "grep",
+  "find",
+  "ls",
+  "web_search",
+  "fetch_content",
+  "get_search_content",
+  "intercom",
+  "contact_supervisor",
+  "structured_output"
+]);
+const IMPLEMENTATION = /\b(?:implement|modify|edit|refactor|ship|land)\b|\b(?:fix|patch)\s+(?:(?:the|a|an|this|that)\s+)?(?:it|bug|defect|issues?|problems?|failures?|regressions?|tests?|errors?|code|source|implementation|files?|module|config)\b|\b(?:create|update|add|remove|replace|delete|write)\s+(?:(?:the|a|an)\s+)?(?:code|files?|tests?|source|module|config|implementation|changes?)\b/i;
+const NO_EDIT = /\b(?:do not|don't|must not|without)\s+(?:edit|modify|write|touch|change)(?:(?!\b(?:but|and|then)\b)[^.;,:!?\n])*/gi;
+function requiresMutation(task) {
+  const scoped = task.replace(NO_EDIT, " ");
+  return !/\b(?:review only|read.only|analy[sz]e only)\b/i.test(scoped) && IMPLEMENTATION.test(scoped);
+}
+const PROVIDER_FAILURE = /\b(?:provider.*unavailable|model.*unavailable|overloaded|service unavailable|connection (?:error|reset|closed|aborted|refused)|fetch failed|network error|socket hang up|50[0234]|internal server error|cold.?start|empty response|no output)\b/i;
+const TOOL_FAILURE = /^[\w.:@/-]+ failed (?:\(exit \d+\):|with exit code \d+)/i;
+export function implementationToolsError(agent, task, tools, mcpDirectTools) {
+  if (!requiresMutation(task) || tools === undefined || tools.some((tool) => !READ_ONLY.has(tool)) || mcpDirectTools?.length)
+    return;
+  return `Agent '${agent}' was given an implementation task, but its tool allowlist has no mutation-capable tools.`;
+}
+export function implementationMutationError(input) {
+  if (!requiresMutation(input.task) || input.attempted || input.unavailable || input.tools !== undefined && input.tools.every((tool) => READ_ONLY.has(tool)) && !input.mcpDirectTools?.length)
+    return;
+  return `Agent '${input.agent}' completed an implementation task without attempting a mutation. Review its result before accepting it.`;
+}
+export function dmRetryDelay(run, attempt) {
+  if (attempt >= 3 || run.exitCode === 0 || run.stopped || run.timedOut || run.interrupted || run.completionDiagnostic || run.observedMutationAttempt || run.toolCount !== 0 || run.finalOutput?.trim() || Object.values(run.usage).some((value) => value !== 0))
+    return;
+  const error = run.error?.trim();
+  if (!error && run.messages.length === 0 && run.durationMs <= 2000)
+    return [250, 750, 1500][attempt];
+  if (error && !TOOL_FAILURE.test(error) && PROVIDER_FAILURE.test(error) && (run.messages.length === 0 || run.messages.length === 1 && run.messages[0]?.errorMessage?.trim() === error)) {
+    return [250, 750, 1500][attempt];
+  }
+  return;
+}

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

@@ -0,0 +1,48 @@
+export function onDmBeforeSettle(dm, handler) {
+  let active = true;
+  if (!dm.on)
+    return () => {
+      active = false;
+    };
+  const host = dm;
+  const unsubscribe = host.on("agent_before_settle", (event) => active ? handler(event) : undefined);
+  dm.on("agent_end", (event, ctx) => {
+    if (!active || !ctx || ctx.signal?.aborted || typeof ctx.hasPendingMessages === "function" && ctx.hasPendingMessages())
+      return;
+    const final = [...event.messages].reverse().find((message) => message.role === "assistant");
+    if (!final || final.stopReason !== "stop")
+      return;
+    const contextMessages = (ctx.sessionManager.getBranch?.() ?? ctx.sessionManager.getEntries?.() ?? []).flatMap((entry) => {
+      if (entry.type === "message")
+        return [entry.message];
+      if (entry.type === "custom_message")
+        return [{
+          role: "custom",
+          customType: entry.customType,
+          content: entry.content,
+          details: entry.details
+        }];
+      return [];
+    });
+    const result = handler({
+      outcome: "completed",
+      context: { pendingMessages: [], contextMessages },
+      entries: []
+    });
+    for (const entry of result?.entries ?? []) {
+      if (entry.type !== "custom_message" || typeof entry.customType !== "string" || typeof entry.content !== "string")
+        continue;
+      dm.sendMessage({
+        customType: entry.customType,
+        content: entry.content,
+        display: entry.display === true,
+        details: entry.details
+      }, { triggerTurn: result?.continue === true });
+    }
+  });
+  return () => {
+    active = false;
+    if (typeof unsubscribe === "function")
+      unsubscribe();
+  };
+}

package/extensions/dm-subagents/src/shared/edit-distance.js

@@ -0,0 +1,23 @@
+export function editDistance(left, right) {
+  const previous = Array.from({ length: right.length + 1 }, (_, index) => index);
+  for (let leftIndex = 1;leftIndex <= left.length; leftIndex += 1) {
+    let diagonal = previous[0];
+    previous[0] = leftIndex;
+    for (let rightIndex = 1;rightIndex <= right.length; rightIndex += 1) {
+      const above = previous[rightIndex];
+      previous[rightIndex] = left[leftIndex - 1] === right[rightIndex - 1] ? diagonal : Math.min(diagonal, above, previous[rightIndex - 1]) + 1;
+      diagonal = above;
+    }
+  }
+  return previous[right.length];
+}
+export function hasSingleAdjacentTransposition(left, right) {
+  if (left.length !== right.length)
+    return false;
+  const mismatch = [...left].findIndex((character, index) => character !== right[index]);
+  return mismatch >= 0 && left[mismatch] === right[mismatch + 1] && left[mismatch + 1] === right[mismatch] && left.slice(mismatch + 2) === right.slice(mismatch + 2);
+}
+export function closestMatch(requested, candidates) {
+  const lower = requested.toLowerCase();
+  return [...candidates].map((candidate) => ({ candidate, distance: editDistance(lower, candidate.toLowerCase()) })).filter(({ candidate, distance }) => distance <= Math.max(1, Math.floor(candidate.length / 4)) || hasSingleAdjacentTransposition(lower, candidate.toLowerCase())).sort((left, right) => left.distance - right.distance || left.candidate.localeCompare(right.candidate))[0]?.candidate;
+}

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

@@ -1,6 +1,10 @@
+export const MODEL_ONLY_TOOL = { exposure: "model-only" };
 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 isUnboundExtensionRuntimeError(error) {
+  return error instanceof Error && /extension runtime not initialized/i.test(error.message);
+}
 export function withCachedUiContext(ctx, onStale, run) {
   if (!ctx)
     return;

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

@@ -0,0 +1,89 @@
+import { randomUUID } from "node:crypto";
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import { performance } from "node:perf_hooks";
+import { waitForFileSystemRetry } from "./file-system-retry.js";
+function startIdentity(pid) {
+  if (process.platform !== "linux")
+    return;
+  try {
+    const raw = fs.readFileSync(`/proc/${pid}/stat`, "utf-8");
+    return raw.slice(raw.lastIndexOf(")") + 1).trim().split(/\s+/)[19];
+  } catch {
+    return;
+  }
+}
+function readOwner(lockPath) {
+  try {
+    const owner = JSON.parse(fs.readFileSync(path.join(lockPath, "owner.json"), "utf-8"));
+    if (typeof owner.token !== "string" || !/^[A-Za-z0-9-]{1,64}$/.test(owner.token) || typeof owner.hostname !== "string" || !Number.isSafeInteger(owner.pid) || owner.pid <= 0)
+      return;
+    return owner;
+  } catch {
+    return;
+  }
+}
+function deadOwner(owner) {
+  if (owner.hostname !== os.hostname())
+    return false;
+  try {
+    process.kill(owner.pid, 0);
+  } catch (error) {
+    return error.code === "ESRCH";
+  }
+  const current = startIdentity(owner.pid);
+  return owner.processStart !== undefined && current !== undefined && owner.processStart !== current;
+}
+export function tryLease(lockPath) {
+  const owner = { token: randomUUID(), pid: process.pid, hostname: os.hostname(), processStart: startIdentity(process.pid) };
+  try {
+    fs.mkdirSync(lockPath, { mode: 448 });
+  } catch (error) {
+    if (error.code !== "EEXIST")
+      throw error;
+    const previous = readOwner(lockPath);
+    if (!previous || !deadOwner(previous))
+      return;
+    const retired = `${lockPath}.retired-${previous.token}`;
+    try {
+      fs.renameSync(lockPath, retired);
+    } catch (error) {
+      if (error.code === "ENOENT" || readOwner(retired)?.token === previous.token)
+        return;
+      throw error;
+    }
+    if (readOwner(retired)?.token !== previous.token)
+      throw new Error(`Retired lock owner changed during recovery: ${lockPath}`);
+    return tryLease(lockPath);
+  }
+  try {
+    fs.writeFileSync(path.join(lockPath, "owner.json"), JSON.stringify(owner), { flag: "wx", mode: 384 });
+  } catch (error) {
+    fs.rmSync(lockPath, { recursive: true, force: true });
+    throw error;
+  }
+  return () => {
+    if (readOwner(lockPath)?.token === owner.token)
+      fs.rmSync(lockPath, { recursive: true });
+  };
+}
+export function withFileLease(filePath, action, waitMs = 200) {
+  const requested = path.resolve(filePath);
+  const absolute = path.join(fs.realpathSync.native(path.dirname(requested)), path.basename(requested));
+  const lockPath = `${absolute}.write-lock`;
+  const deadline = performance.now() + waitMs;
+  let release = tryLease(lockPath);
+  while (!release) {
+    const remaining = deadline - performance.now();
+    if (remaining <= 0)
+      throw new Error(`Timed out waiting for another process to finish updating ${absolute}.`);
+    waitForFileSystemRetry(Math.min(10, remaining));
+    release = tryLease(lockPath);
+  }
+  try {
+    return action();
+  } finally {
+    release();
+  }
+}

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

@@ -138,7 +138,6 @@ export function createForkContextResolver(sessionManager, requestedContext, opti
           entries[0].parentSession = parentSessionFile;
         }
         if (snapshotDir || sanitizeUnsafeThinkingBlocks(entries)) {
-          sanitizeUnsafeThinkingBlocks(entries);
           fs.writeFileSync(sessionFile, `${entries.map((entry) => JSON.stringify(entry)).join(`
 `)}
 `, "utf-8");

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

@@ -24,14 +24,9 @@ export function formatContextUsage(usage, contextLimit) {
 }
 export function formatModelThinking(model, thinking) {
   const parsed = model ? splitKnownThinkingSuffix(model) : undefined;
-  let displayModel = parsed?.baseModel ?? model;
+  const displayModel = parsed?.baseModel ?? model;
   const explicitThinking = THINKING_LEVELS.find((level) => level === thinking?.trim());
   const displayThinking = parsed?.thinkingSuffix ? parsed.thinkingSuffix.slice(1) : explicitThinking;
-  if (displayModel) {
-    const slashIdx = displayModel.lastIndexOf("/");
-    if (slashIdx !== -1)
-      displayModel = displayModel.slice(slashIdx + 1);
-  }
   return [displayModel, displayThinking ? `thinking ${displayThinking}` : undefined].filter(Boolean).join(" · ");
 }
 export function formatUsage(u, model) {

package/extensions/dm-subagents/src/shared/model-info.js

@@ -21,6 +21,14 @@ export function resolveEffectiveThinking(model, configThinking) {
     return thinkingSuffix.slice(1);
   return THINKING_LEVELS.find((level) => level === configThinking);
 }
+export function childThinkingLevel(...sources) {
+  for (const source of sources) {
+    const level = THINKING_LEVELS.find((candidate) => candidate === source?.thinking);
+    if (level)
+      return level;
+  }
+  return;
+}
 export function splitKnownThinkingSuffix(model) {
   const colonIdx = model.lastIndexOf(":");
   if (colonIdx === -1)
@@ -33,6 +41,21 @@ export function splitKnownThinkingSuffix(model) {
     thinkingSuffix: `:${suffix}`
   };
 }
+export function qualifyModelWithProvider(model, provider, availableModels) {
+  if (!model)
+    return;
+  if (!provider)
+    return model;
+  const exactFullId = availableModels?.find((entry) => entry.provider === provider && entry.fullId === model);
+  if (exactFullId)
+    return exactFullId.fullId;
+  const idMatch = availableModels?.find((entry) => entry.provider === provider && entry.id === model);
+  if (idMatch)
+    return idMatch.fullId;
+  if (model.startsWith(`${provider}/`))
+    return model;
+  return `${provider}/${model}`;
+}
 export function findModelInfo(model, availableModels, preferredProvider) {
   if (!model || !availableModels || availableModels.length === 0)
     return;

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

@@ -0,0 +1,12 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { fileURLToPath } from "node:url";
+const packagePath = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..", "..", "package.json");
+export function readInstalledPackageVersion() {
+  const parsed = JSON.parse(fs.readFileSync(packagePath, "utf-8"));
+  if (typeof parsed.version !== "string" || !parsed.version.trim()) {
+    throw new Error(`Invalid package version in '${packagePath}'.`);
+  }
+  return parsed.version;
+}
+export const loadedPackageVersion = readInstalledPackageVersion();

package/extensions/dm-subagents/src/shared/parent-wake.js

@@ -0,0 +1,67 @@
+export const PARENT_WAKE_TEXT = "Inspect subagent updates above. Answer pending supervisor requests within your authority. For completed work, read saved results and resume the already-authorized parent task, or report completion. If approval is required, explicitly ask the user. Do not silently yield, rerun completed work, or infer new authorization.";
+const WAKE_PENDING_MS = 1e4;
+const reservationsSymbol = Symbol.for("dm.idle-wake.v1");
+const wakeGlobal = globalThis;
+const reservations = wakeGlobal[reservationsSymbol] ?? (wakeGlobal[reservationsSymbol] = new WeakMap);
+export function createParentWake(dm, now = Date.now) {
+  let ctx;
+  let session;
+  let held = false;
+  const reservation = () => {
+    if (!session)
+      return { sessionId: "" };
+    const current = reservations.get(session.manager);
+    if (current?.sessionId === session.id)
+      return current;
+    const next = { sessionId: session.id };
+    reservations.set(session.manager, next);
+    return next;
+  };
+  const reserved = () => {
+    const { sentAt } = reservation();
+    return sentAt !== undefined && now() - sentAt < WAKE_PENDING_MS;
+  };
+  return {
+    sendMessage(message, options) {
+      if (options?.triggerTurn !== true) {
+        dm.sendMessage(message, options);
+        return false;
+      }
+      if (held) {
+        dm.sendMessage(message, { triggerTurn: false });
+        return true;
+      }
+      if (!ctx.isIdle()) {
+        dm.sendMessage(message, options);
+        return false;
+      }
+      dm.sendMessage(message, { triggerTurn: false });
+      if (!reserved()) {
+        reservation().sentAt = now();
+        dm.sendUserMessage(PARENT_WAKE_TEXT, { deliverAs: "steer" });
+      }
+      return true;
+    },
+    isPending: () => reservation().sentAt !== undefined && (reserved() || !ctx.isIdle()),
+    bindSession(context) {
+      ctx = context;
+      session = { manager: context.sessionManager, id: context.sessionManager.getSessionId() };
+      held = false;
+    },
+    agentStarted() {
+      reservation().sentAt = undefined;
+      held = false;
+    },
+    userAborted: () => {
+      held = true;
+    },
+    releaseHold: () => {
+      held = false;
+    },
+    isHeld: () => held,
+    sessionShutdown(reason) {
+      if (reason !== "reload")
+        reservation().sentAt = undefined;
+    }
+  };
+}

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

@@ -5,6 +5,7 @@ import * as path from "node:path";
 import { streamSimple } from "@duckmind/dm-ai/compat";
 import { resolveModelCandidate } from "../runs/shared/model-resolution.js";
 import { splitKnownThinkingSuffix, toModelInfo } from "./model-info.js";
+import { opencodeSessionHeaders } from "./opencode-session-headers.js";
 const MAX_INHERITED_SESSION_BYTES = 64 * 1024;
 const MIN_USEFUL_SPILL_BYTES = 320;
 const MAX_ITEM_SUMMARY_CHARS = 160;
@@ -403,6 +404,8 @@ 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 sessionId = ctx.sessionManager.getSessionId();
+  const sessionHeaders = opencodeSessionHeaders(model, sessionId);
   let sharedSummary;
   const summarize = async (payload) => {
     sharedSummary ??= (async () => {
@@ -416,9 +419,10 @@ export async function createPrunedForkSessionWriter(ctx, config, signal) {
       };
       const options = {
         maxTokens: Math.min(MAX_SUMMARY_TOKENS, typeof model.maxTokens === "number" && model.maxTokens > 0 ? model.maxTokens : MAX_SUMMARY_TOKENS),
-        signal
+        signal,
+        sessionId
       };
-      const stream = legacyStream ? legacyStream.call(ctx.modelRegistry, model, context, options) : streamSimple(model, context, { ...options, apiKey: auth.apiKey, headers: auth.headers });
+      const stream = legacyStream ? legacyStream.call(ctx.modelRegistry, model, context, { ...options, ...sessionHeaders ? { headers: sessionHeaders } : {} }) : streamSimple(model, context, { ...options, apiKey: auth.apiKey, headers: { ...auth.headers, ...sessionHeaders } });
       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}` : ""}`);