@duckmind/dm-darwin-x64 0.66.5 → 0.66.6

package/extensions/dm-subagents/src/runs/shared/model-scope.js

@@ -1,4 +1,6 @@
 import { splitKnownThinkingSuffix } from "../../shared/model-info.js";
+export const SCOPED_PATTERN = "scoped";
+const MAX_RENDERED_PATTERNS = 8;
 function stripThinkingSuffix(model) {
   return splitKnownThinkingSuffix(model).baseModel;
 }
@@ -20,16 +22,24 @@ export function checkModelScope(model, scope, source) {
   const baseModel = stripThinkingSuffix(model);
   const severity = source === "explicit" || scope.strict === true ? "error" : "warn";
   const origin = scope.origin ?? "modelScope";
+  const rendered = allow.length <= MAX_RENDERED_PATTERNS ? allow.join(", ") : `${allow.slice(0, MAX_RENDERED_PATTERNS).join(", ")}, … (${allow.length} patterns total)`;
   return {
     model: baseModel,
     severity,
     allowedPatterns: allow,
     origin,
-    message: `Model '${baseModel}' is outside the configured subagent model scope (${origin}). ` + `Allowed patterns: ${allow.join(", ")}.`
+    message: `Model '${baseModel}' is outside the configured subagent model scope (${origin}). ` + `Allowed patterns: ${rendered}.`
   };
 }
-function expandInheritPattern(pattern, parentModel) {
-  return pattern === "inherit" && parentModel ? `${parentModel.provider}/${parentModel.id}` : pattern;
+function expandReservedPatterns(pattern, parentModel, scopedModelIds) {
+  if (pattern === SCOPED_PATTERN) {
+    if (scopedModelIds?.length)
+      return [...scopedModelIds];
+    return parentModel ? [`${parentModel.provider}/${parentModel.id}`] : [pattern];
+  }
+  if (pattern === "inherit")
+    return parentModel ? [`${parentModel.provider}/${parentModel.id}`] : [pattern];
+  return [pattern];
 }
 function assertRecord(value, field, meta, expected = "an object") {
   if (!value || typeof value !== "object" || Array.isArray(value)) {
@@ -71,24 +81,27 @@ function parseScopeRule(input, field, meta) {
     rule.allow = parseAllowList(input.allow, `${field}.allow`, meta);
   return rule;
 }
-export function resolveModelScopesForAgent(config, agentName, parentModel) {
+export function resolveModelScopesForAgent(config, agentName, parentModel, scopedModelIds) {
   if (!config)
     return [];
   const scopes = [];
   if (config.allow) {
-    scopes.push({
-      ...config.enforce !== undefined ? { enforce: config.enforce } : {},
-      ...config.strict !== undefined ? { strict: config.strict } : {},
-      allow: config.allow.map((pattern) => expandInheritPattern(pattern, parentModel)),
+    const globalScope = {
+      allow: config.allow.flatMap((pattern) => expandReservedPatterns(pattern, parentModel, scopedModelIds)),
       origin: "modelScope"
-    });
+    };
+    if (config.enforce !== undefined)
+      globalScope.enforce = config.enforce;
+    if (config.strict !== undefined)
+      globalScope.strict = config.strict;
+    scopes.push(globalScope);
   }
   const agentScope = config.agents?.[agentName];
   if (agentScope?.allow) {
     scopes.push({
       enforce: agentScope.enforce ?? config.enforce,
       strict: agentScope.strict ?? config.strict,
-      allow: agentScope.allow.map((pattern) => expandInheritPattern(pattern, parentModel)),
+      allow: agentScope.allow.flatMap((pattern) => expandReservedPatterns(pattern, parentModel, scopedModelIds)),
       origin: `modelScope.agents.${agentName}`
     });
   }

package/extensions/dm-subagents/src/runs/shared/nested-events.js

@@ -101,6 +101,9 @@ export function inheritedNestedParentAddressOf(runtime) {
     path: parent.path.length ? parent.path : [{ runId: parent.parentRunId, ...parent.parentChildIndex !== undefined ? { stepIndex: parent.parentChildIndex } : {} }]
   };
 }
+export function nestedRunNotActiveMessage(runId) {
+  return `Nested run ${runId} is not active in this fanout child.`;
+}
 export function resolveNestedAsyncDir(rootRunId, run) {
   if (!run.asyncDir)
     return;

package/extensions/dm-subagents/src/runs/shared/parallel-handoff.js

@@ -1,8 +1,9 @@
+import { withHandoffWriteLock, withRepositoryWorktreeLock } from "./worktree-lock.js";
 import * as fs from "node:fs";
 import * as path from "node:path";
 import { writeAtomicJson } from "../../shared/atomic-json.js";
 import { stableJsonDigest } from "../../shared/launch-contract.js";
-import { cleanupWorktrees } from "./worktree.js";
+import { cleanupWorktrees, withWorktreeTransaction } from "./worktree.js";
 import { assertWorkflowLaneKey, normalizeWorkflowLaneMetadata } from "./lane-metadata.js";
 function optionalIdentity(value, label) {
   if (value === undefined)
@@ -142,6 +143,27 @@ function pathInside(root, candidate) {
   const relative = path.relative(root, candidate);
   return relative === "" || relative !== ".." && !relative.startsWith(`..${path.sep}`) && !path.isAbsolute(relative);
 }
+export async function protectRetainedWorktreeForResume(manifestPath, runId, childIndex, signal) {
+  const original = readParallelHandoffManifest(manifestPath);
+  const group = original?.groups.find((item) => item.children.some((child) => child.index === childIndex));
+  if (!group)
+    throw new Error("Retained worktree handoff disappeared before resume admission.");
+  return withWorktreeTransaction(() => withRepositoryWorktreeLock(group.repoRoot, () => withHandoffWriteLock(manifestPath, () => {
+    signal?.throwIfAborted();
+    const cwd = resolveRetainedWorktreeCwd(manifestPath, runId, childIndex);
+    if (!cwd)
+      throw new Error("Retained worktree ownership disappeared before resume admission.");
+    const manifest = readParallelHandoffManifest(manifestPath);
+    const currentGroup = manifest.groups.find((item) => item.children.some((child) => child.index === childIndex));
+    const child = currentGroup.children.find((item) => item.index === childIndex);
+    const task = currentGroup.cleanup.tasks.find((item) => item.index === child.taskIndex);
+    task.preserved = true;
+    task.reason = "retained child resume requires managed worktree cwd";
+    manifest.updatedAt = Date.now();
+    writeAtomicJson(manifestPath, manifest);
+    return cwd;
+  }), { signal }));
+}
 export function resolveRetainedWorktreeCwd(manifestPath, runId, childIndex) {
   const manifest = readParallelHandoffManifest(manifestPath);
   if (!manifest)
@@ -402,7 +424,7 @@ function firstRepositoryRoot(manifest) {
 }
 function formatCleanupCommand(manifestPath, manifest) {
   const repoRoot = firstRepositoryRoot(manifest);
-  return repoRoot ? `subagent({ action: "worktree.cleanup", repo: ${JSON.stringify(repoRoot)}, handoffPath: ${JSON.stringify(manifestPath)}, mode: "plan" })` : undefined;
+  return repoRoot ? `subagent({ action: "worktree.cleanup", options: { repo: ${JSON.stringify(repoRoot)}, handoffPath: ${JSON.stringify(manifestPath)}, mode: "plan" } })` : undefined;
 }
 export function formatStoredParallelHandoffCleanup(manifestPath, manifest) {
   let stored = manifest;
@@ -414,7 +436,7 @@ export function formatStoredParallelHandoffCleanup(manifestPath, manifest) {
     }
   }
   if (!stored)
-    return ["Cleanup eligibility: unknown", "Reason: lane manifest is missing or invalid; removal is not safe.", `Plan command: subagent({ action: "worktree.cleanup", handoffPath: ${JSON.stringify(manifestPath)}, mode: "plan" })`].join(`
+    return ["Cleanup eligibility: unknown", "Reason: lane manifest is missing or invalid; removal is not safe.", `Plan command: subagent({ action: "worktree.cleanup", options: { handoffPath: ${JSON.stringify(manifestPath)}, mode: "plan" } })`].join(`
 `);
   const eligibility = trustedStoredCleanupEligibility(stored);
   const lines = [`Cleanup eligibility: ${eligibility.state}`];
@@ -430,7 +452,10 @@ export function formatStoredParallelHandoffCleanup(manifestPath, manifest) {
   return lines.join(`
 `);
 }
-export function recordParallelHandoffMerge(input) {
+export function recordParallelHandoffMerge(...args) {
+  return withHandoffWriteLock(args[0].manifestPath, () => recordParallelHandoffMergeUnlocked(...args));
+}
+function recordParallelHandoffMergeUnlocked(input) {
   const manifest = readParallelHandoffManifest(input.manifestPath);
   if (!manifest)
     throw new Error(`Parallel handoff manifest not found: ${input.manifestPath}`);
@@ -451,7 +476,10 @@ export function recordParallelHandoffMerge(input) {
   writeAtomicJson(input.manifestPath, updated);
   return { manifest: updated, reference: referenceFor(input.manifestPath, updated), text: formatStoredParallelHandoffCleanup(input.manifestPath, updated) };
 }
-export function recordParallelHandoffSupersession(input) {
+export function recordParallelHandoffSupersession(...args) {
+  return withHandoffWriteLock(args[0].manifestPath, () => recordParallelHandoffSupersessionUnlocked(...args));
+}
+function recordParallelHandoffSupersessionUnlocked(input) {
   const manifest = readParallelHandoffManifest(input.manifestPath);
   if (!manifest)
     throw new Error(`Parallel handoff manifest not found: ${input.manifestPath}`);
@@ -492,7 +520,10 @@ function missingDiff(input) {
     error: "diff artifact unavailable; no patch was captured"
   };
 }
-export function writeParallelHandoffGroup(input) {
+export function writeParallelHandoffGroup(...args) {
+  return withHandoffWriteLock(args[0].manifestPath, () => writeParallelHandoffGroupUnlocked(...args));
+}
+function writeParallelHandoffGroupUnlocked(input) {
   const now = input.now ?? Date.now();
   const existing = readParallelHandoffManifest(input.manifestPath);
   if (existing && (existing.runId !== input.runId || existing.mode !== input.mode || existing.source !== input.source)) {
@@ -564,6 +595,7 @@ export function writeParallelHandoffGroup(input) {
         branch: worktree.branch,
         ...worktree.provider ? { provider: worktree.provider } : {},
         ...worktree.naming ? { naming: worktree.naming } : {},
+        ...worktree.recordedBaseDir ? { recordedBaseDir: worktree.recordedBaseDir } : {},
         worktreeRemoved: false,
         branchRemoved: false,
         preserved: true,
@@ -571,6 +603,17 @@ export function writeParallelHandoffGroup(input) {
       }))
     }
   };
+  for (const task of group.cleanup.tasks) {
+    const previous = existing?.groups.flatMap((item) => item.cleanup.tasks).find((item) => item.path === task.path && item.branch === task.branch);
+    if (previous?.worktreeRemoved)
+      task.worktreeRemoved = true;
+    if (previous?.branchRemoved)
+      task.branchRemoved = true;
+    if (!task.worktreeRemoved && previous?.reason?.includes("retained child resume")) {
+      task.preserved = true;
+      task.reason = previous.reason;
+    }
+  }
   const groups = existing?.groups.filter((candidate) => candidate.stepIndex !== input.stepIndex) ?? [];
   groups.push(group);
   groups.sort((left, right) => left.stepIndex - right.stepIndex);
@@ -663,6 +706,7 @@ export function writeWorktreeSetupHandoff(input) {
           branch: worktree.branch,
           provider: worktree.provider,
           naming: worktree.naming,
+          recordedBaseDir: worktree.recordedBaseDir,
           worktreeRemoved: false,
           branchRemoved: false,
           preserved: true,
@@ -678,7 +722,10 @@ export function formatParallelHandoffReference(reference) {
 export function formatParallelHandoffError(error) {
   return `Worktree handoff unavailable: ${error instanceof Error ? error.message : String(error)}`;
 }
-export function discardPreservedWorktrees(manifestPath, authorization) {
+export function discardPreservedWorktrees(...args) {
+  return withHandoffWriteLock(args[0], () => discardPreservedWorktreesUnlocked(...args));
+}
+function discardPreservedWorktreesUnlocked(manifestPath, authorization) {
   const resolvedPath = path.resolve(manifestPath);
   const manifest = readParallelHandoffManifest(resolvedPath);
   if (!manifest)
@@ -698,6 +745,7 @@ export function discardPreservedWorktrees(manifestPath, authorization) {
         branch: task.branch,
         ...task.provider ? { provider: task.provider } : {},
         ...task.naming ? { naming: task.naming } : {},
+        ...task.recordedBaseDir ? { recordedBaseDir: task.recordedBaseDir } : {},
         index: task.index,
         nodeModulesLinked: false,
         syntheticPaths: []

package/extensions/dm-subagents/src/runs/shared/partial-output.js

@@ -0,0 +1,26 @@
+import { extractTextFromContent } from "../../shared/utils.js";
+function isAssistant(message) {
+  return !!message && typeof message === "object" && message.role === "assistant";
+}
+function isErroredAssistant(message) {
+  const { stopReason, errorMessage } = message;
+  return stopReason === "error" || typeof errorMessage === "string" && errorMessage.length > 0;
+}
+export function createPartialOutputTracker() {
+  let latest;
+  return {
+    observe(event) {
+      if (event.type !== "message_update" && event.type !== "message_end" || !isAssistant(event.message))
+        return;
+      latest = event.type === "message_update" || isErroredAssistant(event.message) ? event.message : undefined;
+    },
+    text() {
+      const text = extractTextFromContent(latest?.content);
+      return text.trim() ? text : undefined;
+    }
+  };
+}
+export function formatPartialOutput(text, cause) {
+  return `Partial output before ${cause}:
+${text}`;
+}

package/extensions/dm-subagents/src/runs/shared/run-history.js

@@ -113,6 +113,47 @@ function appendPrivateHistoryLine(historyPath, line) {
     fs.closeSync(fd);
   }
 }
+function backgroundRunHistoryTask(steps, resultMode) {
+  const step = steps.length === 1 && typeof steps[0] === "object" && steps[0] !== null ? steps[0] : undefined;
+  if (step) {
+    const task = typeof step.launchBindingTask === "string" && step.launchBindingTask ? step.launchBindingTask : step.task;
+    if (typeof task === "string" && task)
+      return task;
+  }
+  return resultMode || "run";
+}
+const TERMINAL_STEP_STATUSES = new Set(["complete", "completed"]);
+const SELF_TERMINAL_STEP_STATUSES = new Set(["complete", "completed", "failed", "rejected"]);
+export function planBackgroundRunHistory(input) {
+  const runTerminal = {
+    ...input.stopped ? { stopped: true } : {},
+    ...input.interrupted ? { interrupted: true } : {},
+    ...input.timedOut ? { timedOut: true } : {}
+  };
+  const task = backgroundRunHistoryTask(input.steps, input.resultMode);
+  const rows = [];
+  for (const [index, step] of input.statusSteps.entries()) {
+    if (typeof step.agent !== "string" || !step.agent)
+      continue;
+    if (step.status === "pending" || step.launched === false)
+      continue;
+    const succeeded = typeof step.status === "string" && TERMINAL_STEP_STATUSES.has(step.status);
+    const ownTerminal = {
+      ...step.timedOut === true ? { timedOut: true } : {},
+      ...step.stopped === true ? { stopped: true } : {}
+    };
+    const terminal = typeof step.status === "string" && SELF_TERMINAL_STEP_STATUSES.has(step.status) ? ownTerminal : { ...runTerminal, ...ownTerminal };
+    const processSignal = input.stepResults?.[index]?.processSignal;
+    rows.push({
+      agent: step.agent,
+      task,
+      exitCode: succeeded ? 0 : 1,
+      durationMs: typeof step.durationMs === "number" ? step.durationMs : input.runDurationMs,
+      terminal: processSignal === undefined ? terminal : { ...terminal, processSignal: typeof processSignal === "string" ? processSignal : null }
+    });
+  }
+  return rows;
+}
 export function recordRun(agent, task, exitCode, durationMs, terminal = {}) {
   try {
     const outcome = terminal.stopped ? "stopped" : terminal.interrupted ? "interrupted" : terminal.timedOut ? "timed_out" : exitCode !== 0 && isUnexplainedProcessSignal(terminal) ? "stopped" : exitCode === 0 ? "completed" : "failed";

package/extensions/dm-subagents/src/runs/shared/runner-launcher.js

@@ -0,0 +1,21 @@
+export function lookupRunnerLauncher(runnerLaunchers, name) {
+  const argv = runnerLaunchers && Object.hasOwn(runnerLaunchers, name) ? runnerLaunchers[name] : undefined;
+  return argv ? { name, argv: [...argv] } : undefined;
+}
+export function runnerLauncherPlacementError(agent, machine) {
+  if (agent.launcher === undefined)
+    return;
+  const runnerType = agent.runner?.type === "external-cli" || agent.runner?.type === "external-job" ? agent.runner.type : undefined;
+  if (!machine && !runnerType)
+    return;
+  return `Agent '${agent.name}' uses launcher '${agent.launcher}', which wraps the local DM background runner, so it cannot run ${machine ? `on machine '${machine}'` : `with runner.type='${runnerType}'`}.`;
+}
+export function resolveAgentRunnerLauncher(agent, runnerLaunchers, machine) {
+  if (agent.launcher === undefined)
+    return {};
+  const placementError = runnerLauncherPlacementError(agent, machine);
+  if (placementError)
+    return { error: placementError };
+  const launcher = lookupRunnerLauncher(runnerLaunchers, agent.launcher);
+  return launcher ? { launcher } : { error: `Agent '${agent.name}' uses launcher '${agent.launcher}', which is not defined in runnerLaunchers in the user subagent config.` };
+}

package/extensions/dm-subagents/src/runs/shared/single-output.js

@@ -77,20 +77,6 @@ export function resolveSingleOutputPath(output, runtimeCwd, requestedCwd, relati
   const baseCwd = requestedCwd ? path.isAbsolute(requestedCwd) ? requestedCwd : path.resolve(runtimeCwd, requestedCwd) : runtimeCwd;
   return path.resolve(baseCwd, output);
 }
-function formatOutputPathInstruction(outputPath, capabilities) {
-  const delivery = !capabilities || hasOutputWriteCapability(capabilities.tools, capabilities.mcpDirectTools) ? `Write your findings to exactly this path: ${outputPath}` : [
-    "Return the complete artifact in your final response.",
-    `The runtime will persist it to exactly this path: ${outputPath}`,
-    "Do not call contact_supervisor merely because no write-capable tool is available."
-  ].join(`
-`);
-  return [
-    delivery,
-    "This path is authoritative for this run.",
-    "Ignore any other output filename or output path mentioned elsewhere, including output destinations in the base agent prompt, system prompt, or task instructions."
-  ].join(`
-`);
-}
 export function requestedOutputPathFromTask(task) {
   for (const line of task.split(/\r?\n/).reverse()) {
     const match = line.match(/^\s*(?:Write your findings to(?: exactly this path)?:|The runtime will persist it to exactly this path:)\s*(.+?)\s*$/i);
@@ -112,20 +98,22 @@ export function outputPathMappingFromTask(task, savedPath) {
 export function injectSingleOutputInstruction(task, outputPath, capabilities) {
   if (!outputPath)
     return task;
-  return `${task}
+  const delivery = !capabilities || hasOutputWriteCapability(capabilities.tools, capabilities.mcpDirectTools) ? `Write your findings to exactly this path: ${outputPath}` : [
+    "Return the complete artifact in your final response.",
+    `The runtime will persist it to exactly this path: ${outputPath}`,
+    "Do not call contact_supervisor merely because no write-capable tool is available."
+  ].join(`
+`);
+  return [
+    `${task}
 
 ---
-**Output:**
-${formatOutputPathInstruction(outputPath, capabilities)}`;
-}
-export function injectOutputPathSystemPrompt(systemPrompt, outputPath, capabilities) {
-  if (!outputPath)
-    return systemPrompt;
-  const instruction = `Runtime output path override:
-${formatOutputPathInstruction(outputPath, capabilities)}`;
-  return systemPrompt ? `${systemPrompt}
-
-${instruction}` : instruction;
+**Output:**`,
+    delivery,
+    "This path is authoritative for this run.",
+    "Ignore any other output filename or output path mentioned elsewhere, including output destinations in the system prompt or the task instructions."
+  ].join(`
+`);
 }
 function countLines(text) {
   if (!text)
@@ -156,6 +144,59 @@ export function formatSavedOutputReference(savedPath, fullOutput) {
     message: `Output saved to: ${absolutePath} (${formatByteSize(bytes)}, ${lines} ${lines === 1 ? "line" : "lines"}). Read this file if needed.`
   };
 }
+const INLINE_OUTPUT_HEAD_CHARS = 2000;
+const MAX_FULL_OUTPUT_FILE_BYTES = 50 * 1024 * 1024;
+const SAVED_OUTPUT_LINE = /\n\nOutput saved to: (.+) \([^()\n]*\)\. Read this file if needed\.$/;
+function readFullOutputFile(filePath) {
+  try {
+    const stat = fs.statSync(filePath);
+    if (!stat.isFile() || stat.size > MAX_FULL_OUTPUT_FILE_BYTES)
+      return;
+    return fs.readFileSync(filePath, "utf-8");
+  } catch {
+    return;
+  }
+}
+export function capInlineOutput(output, files) {
+  const match = files.savedPath ? output.match(SAVED_OUTPUT_LINE) : null;
+  const savedLine = match && files.savedPath && match[1] === path.resolve(files.savedPath) ? match : undefined;
+  const body = savedLine ? output.slice(0, savedLine.index) : output;
+  const filePath = savedLine ? files.savedPath : files.artifactPath;
+  if (body.length <= INLINE_OUTPUT_HEAD_CHARS || !filePath)
+    return output;
+  const fullOutput = readFullOutputFile(filePath);
+  if (fullOutput === undefined || !fullOutput.includes(body))
+    return output;
+  const lineEnd = body.lastIndexOf(`
+`, INLINE_OUTPUT_HEAD_CHARS);
+  let end = lineEnd >= INLINE_OUTPUT_HEAD_CHARS - 200 ? lineEnd : INLINE_OUTPUT_HEAD_CHARS;
+  if (/[\uD800-\uDBFF]/.test(body[end - 1] ?? ""))
+    end -= 1;
+  if (savedLine)
+    return `${body.slice(0, end)}
+…${output.slice(body.length)}`;
+  const reference = formatSavedOutputReference(filePath, fullOutput);
+  return `${body.slice(0, end)}
+…
+Full output: ${reference.path} (${formatByteSize(reference.bytes)}, ${reference.lines} ${reference.lines === 1 ? "line" : "lines"}). Read it if needed.`;
+}
+export function capSummaryOutputs(summary, results) {
+  let capped = summary;
+  for (const result of results ?? []) {
+    if (typeof result.agent !== "string" || typeof result.output !== "string" || result.output.length <= INLINE_OUTPUT_HEAD_CHARS)
+      continue;
+    const artifactPath = result.artifactOutputSaveFailed === true || typeof result.artifactPaths?.outputPath !== "string" ? undefined : result.artifactPaths.outputPath;
+    const savedPath = typeof result.savedOutputPath === "string" && result.savedOutputPath ? result.savedOutputPath : undefined;
+    const section = `${result.agent}:
+${result.output}`;
+    const index = capped.indexOf(section);
+    if (index < 0)
+      continue;
+    capped = `${capped.slice(0, index)}${result.agent}:
+${capInlineOutput(result.output, { artifactPath, savedPath })}${capped.slice(index + section.length)}`;
+  }
+  return capped;
+}
 export function validateFileOnlyOutputMode(outputMode, outputPath, context) {
   if (outputMode === "file-only" && !outputPath) {
     return `${context} sets outputMode: "file-only" but does not configure an output file. Set output to a path or use outputMode: "inline".`;

package/extensions/dm-subagents/src/runs/shared/structured-output.js

@@ -4,12 +4,14 @@ import * as os from "node:os";
 import * as path from "node:path";
 import { pathToFileURL } from "node:url";
 import { DM_CODING_AGENT_PACKAGE_ROOT_ENV } from "../../shared/utils.js";
+import { resolveInstalledPiPackageRoot, resolvePiPackageRoot } from "./dm-spawn.js";
 export const MISSING_STRUCTURED_OUTPUT_CALL_ERROR = "Missing structured_output call; this step has outputSchema and must finish by calling structured_output.";
 export const MISSING_STRUCTURED_ACCEPTANCE_REPORT_ERROR = 'Missing acceptanceReport in structured_output call; acceptance.report is "on".';
 export const STRUCTURED_OUTPUT_REJECTION_ERROR = "structured_output was invoked but no valid output was captured.";
 export const INVALID_STRUCTURED_OUTPUT_SCHEMA_ERROR = "Structured output invocation was rejected: invalid outputSchema.";
 export const STRUCTURED_OUTPUT_VALIDATOR_UNAVAILABLE_ERROR = "Structured output invocation was rejected: validator unavailable.";
 export const MAX_STRUCTURED_OUTPUT_REJECTION_ERROR_BYTES = 4096;
+const MAX_LISTED_ALLOWED_VALUES = 20;
 function utf8Prefix(value, maxBytes) {
   if (Buffer.byteLength(value, "utf8") <= maxBytes)
     return value;
@@ -151,18 +153,25 @@ async function importCompile() {
   } catch (error) {
     failures.push(`direct import failed: ${error instanceof Error ? error.message : String(error)}`);
   }
-  const packageRoot = process.env[DM_CODING_AGENT_PACKAGE_ROOT_ENV];
-  if (packageRoot) {
+  const envRoot = process.env[DM_CODING_AGENT_PACKAGE_ROOT_ENV]?.trim() || undefined;
+  if (!envRoot)
+    failures.push(`${DM_CODING_AGENT_PACKAGE_ROOT_ENV} is not set`);
+  const roots = new Map;
+  for (const [label, root] of [[DM_CODING_AGENT_PACKAGE_ROOT_ENV, envRoot], ["running DM package root", resolvePiPackageRoot()], ["installed DM package root", resolveInstalledPiPackageRoot()]]) {
+    if (root && !roots.has(root))
+      roots.set(root, label);
+  }
+  if (roots.size === 0)
+    failures.push("no DM package root found");
+  for (const [root, label] of roots) {
     try {
-      const compile = await resolveCompileFromPackageRoot(packageRoot);
+      const compile = await resolveCompileFromPackageRoot(root);
       if (compile)
         return compile;
-      failures.push("DM package root typebox/compile did not export a Compile function");
+      failures.push(`${label} ${root}: typebox/compile did not export a Compile function`);
     } catch (error) {
-      failures.push(`DM package root import failed: ${error instanceof Error ? error.message : String(error)}`);
+      failures.push(`${label} ${root}: ${error instanceof Error ? error.message : String(error)}`);
     }
-  } else {
-    failures.push(`${DM_CODING_AGENT_PACKAGE_ROOT_ENV} is not set`);
   }
   throw new Error(`Cannot load typebox/compile for structured output validation (${failures.join("; ")})`);
 }
@@ -298,6 +307,14 @@ function formatValidationError(error) {
   if (error.keyword === "required" && error.params?.requiredProperties?.length) {
     return error.params.requiredProperties.map((property) => `${pathText === "root" ? property : `${pathText}.${property}`}: is required`);
   }
+  if (error.keyword === "enum" && error.params?.allowedValues?.length) {
+    const values = error.params.allowedValues;
+    const extra = values.length - MAX_LISTED_ALLOWED_VALUES;
+    return [`${pathText}: must be one of ${values.slice(0, MAX_LISTED_ALLOWED_VALUES).map((value) => JSON.stringify(value)).join(", ")}${extra > 0 ? `, and ${extra} more` : ""}`];
+  }
+  if (error.keyword === "const" && error.params && "allowedValue" in error.params) {
+    return [`${pathText}: must be ${JSON.stringify(error.params.allowedValue)}`];
+  }
   return [`${pathText}: ${error.message}`];
 }
 function expandedErrorMessages(compile, schema, value, error, limit, seen) {

package/extensions/dm-subagents/src/runs/shared/subagent-control.js

@@ -122,7 +122,8 @@ export function shouldNotifyControlEvent(config, event) {
 export function controlNotificationKey(event, childIntercomTarget) {
   const childKey = childIntercomTarget ?? (event.index !== undefined ? `${event.runId}:${event.index}` : event.runId);
   const contextHash = createHash("sha256").update(formatControlNudge(event)).digest("hex").slice(0, 8);
-  return `${childKey}:${event.type}:${event.reason ?? "idle"}:${contextHash}`;
+  const callKey = event.reason === "tool_open_threshold" && event.toolCallId ? `:${event.toolCallId}` : "";
+  return `${childKey}:${event.type}:${event.reason ?? "idle"}${callKey}:${contextHash}`;
 }
 export function claimControlNotification(config, event, seenKeys, childIntercomTarget) {
   if (!shouldNotifyControlEvent(config, event))
@@ -164,41 +165,52 @@ export function formatControlNudge(event) {
 export function formatControlNoticeMessage(event, childIntercomTarget) {
   const runTarget = event.runId;
   const nudgeMessage = formatControlNudge(event);
-  const steerCommand = `subagent({ action: "steer", id: "${runTarget}", ${event.index !== undefined ? `index: ${event.index}, ` : ""}message: ${JSON.stringify(nudgeMessage)} })`;
+  const steerCommand = `subagent({ action: "steer", id: "${runTarget}", message: ${JSON.stringify(nudgeMessage)}${event.index !== undefined ? `, options: { index: ${event.index} }` : ""} })`;
   const nestedResumeCommand = `subagent({ action: "resume", id: "${runTarget}", message: ${JSON.stringify(nudgeMessage)} })`;
+  const facts = formatLongRunningFacts(event);
+  const head = (title) => [
+    `${title}: ${event.agent}`,
+    `Run: ${runTarget}${event.index !== undefined ? ` step ${event.index + 1}` : ""}`,
+    `Signal: ${event.message}`,
+    facts ? `Facts: ${facts}` : undefined
+  ];
+  const status = `Status: subagent({ action: "status", id: "${runTarget}" })`;
+  const lines = (items) => items.filter((line) => Boolean(line)).join(`
+`);
   if (event.type === "active_long_running") {
-    const facts = formatLongRunningFacts(event);
-    return [
-      `Subagent active but long-running: ${event.agent}`,
-      `Run: ${runTarget}${event.index !== undefined ? ` step ${event.index + 1}` : ""}`,
-      `Signal: ${event.message}`,
-      facts ? `Facts: ${facts}` : undefined,
+    return lines([
+      ...head("Subagent active but long-running"),
       "Hint: Inspect status first. Use steer for a top-level live async child, routed resume for a live nested child, or resume to revive a paused/completed/failed child.",
       `Top-level live async nudge: ${steerCommand}`,
       `Routed live nested nudge: ${nestedResumeCommand}`,
       childIntercomTarget ? `Direct intercom target: ${childIntercomTarget}` : undefined,
-      `Status: subagent({ action: "status", id: "${runTarget}" })`,
+      status,
       `Interrupt: subagent({ action: "interrupt", id: "${runTarget}" })`
-    ].filter((line) => Boolean(line)).join(`
-`);
+    ]);
+  }
+  if (event.reason === "tool_open_threshold" && event.currentTool === "bash") {
+    const command = (label, action) => `${label}: subagent(${JSON.stringify({ action, id: runTarget, options: { ...event.index !== undefined ? { index: event.index } : {}, toolCallId: event.toolCallId } })})`;
+    return lines([
+      ...head("Subagent needs attention"),
+      "Hint: Inspect the running command and recent output before nudging. A queued steer does not cancel an in-flight bash call. A dev server or watch command may intentionally never return. Elapsed time alone does not prove the command is stuck.",
+      "Recovery: For a local DM child explicitly granted subagent_command, yield a needed persistent command or cancel the exact incorrect command, then steer the child. Query command.status to confirm the result. If command controls are unavailable, inspect partial changes and interruption scope before interrupt/resume; interrupt is run-scoped and may affect siblings.",
+      ...event.toolCallId ? [command("Command", "command.status"), command("Yield", "command.yield"), command("Cancel", "command.cancel")] : [],
+      status,
+      `Transcript: subagent({ action: "status", id: "${runTarget}", options: { view: "transcript"${event.index !== undefined ? `, index: ${event.index}` : ""} } })`
+    ]);
   }
   const supervisorHint = event.reason === "supervisor_request" ? "Supervisor request: reply to the pending request. If subagent_supervisor pending is empty, check intercom pending because an external intercom tool may own the request." : undefined;
-  const facts = formatLongRunningFacts(event);
-  return [
-    `Subagent needs attention: ${event.agent}`,
-    `Run: ${runTarget}${event.index !== undefined ? ` step ${event.index + 1}` : ""}`,
-    `Signal: ${event.message}`,
-    facts ? `Facts: ${facts}` : undefined,
+  return lines([
+    ...head("Subagent needs attention"),
     event.recentFailureSummary ? `Recent failures: ${event.recentFailureSummary}` : undefined,
     supervisorHint,
     "Hint: Inspect status first unless the run is clearly blocked. Use steer for a top-level live async child, routed resume for a live nested child, or resume to revive a paused/completed/failed child.",
     `Top-level live async nudge: ${steerCommand}`,
     `Routed live nested nudge: ${nestedResumeCommand}`,
     childIntercomTarget ? `Direct intercom target: ${childIntercomTarget}` : undefined,
-    `Status: subagent({ action: "status", id: "${runTarget}" })`,
+    status,
     `Interrupt: subagent({ action: "interrupt", id: "${runTarget}" })`
-  ].filter((line) => Boolean(line)).join(`
-`);
+  ]);
 }
 export function formatControlIntercomMessage(event, childIntercomTarget) {
   const statusLabel = event.type === "active_long_running" ? "subagent active but long-running" : "subagent needs attention";