@duckmind/dm-darwin-x64 0.66.4 → 0.66.6

package/extensions/dm-subagents/src/runs/shared/async-status-projection.js

@@ -1,5 +1,6 @@
 import { sanitizeDisplayText, truncateDisplayText } from "../../shared/display-text.js";
 import { formatModelThinking } from "../../shared/formatters.js";
+import { childThinkingLevel } from "../../shared/model-info.js";
 import { HOST_STEP_MAX_COUNT, HOST_STEP_MAX_DETAIL_CHARS, HOST_STEP_MAX_LABEL_CHARS, HOST_STEP_MAX_PROVIDER_CHARS, HOST_STEP_MAX_REASON_CHARS, HOST_STEP_MAX_REF_CHARS, HOST_STEP_MAX_ROLE_CHARS, HOST_STEP_MAX_TARGET_CHARS, hostStepReportName, parseHostStepNode, validHostStepNodes } from "./host-step-status.js";
 import { workflowPreflightLaneForRuntimeKey } from "../../workflows/workflow-preflight.js";
 import { workflowGraphStageNodes } from "./workflow-graph.js";
@@ -495,12 +496,14 @@ export function projectAsyncWorkflowRows(steps, hostStepsOrPreflight, preflightO
 }
 function projectLoadedWorkflowRow(step, index, preflight) {
   const modelThinking = formatModelThinking(step.model, step.thinking) || undefined;
+  const thinking = childThinkingLevel(step);
   const activity = workflowStepActivity(step);
   return {
     name: workflowStepName(step, index),
     state: step.status,
     ...step.context ? { context: step.context } : {},
     ...modelThinking ? { modelThinking } : {},
+    ...thinking ? { thinking } : {},
     ...activity ? { activity } : {},
     ...step.startedAt !== undefined ? { startedAt: step.startedAt } : {},
     ...step.endedAt !== undefined ? { endedAt: step.endedAt } : {},

package/extensions/dm-subagents/src/runs/shared/child-commands.js

@@ -0,0 +1,252 @@
+import { randomUUID } from "node:crypto";
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { Type } from "typebox";
+import { createAtomicJsonWriter } from "../../shared/atomic-json.js";
+import { watchAsyncControlInbox, requestAsyncCommand } from "../background/control-channel.js";
+export const CHILD_COMMAND_TOOL = "subagent_command";
+const writeAtomicJson = createAtomicJsonWriter({ mode: 384 });
+const MAX_OUTPUT_BYTES = 8 * 1024;
+const RECENT_COMMANDS = 20;
+function childCommandStatePath(channelDir) {
+  return path.join(channelDir, "commands.json");
+}
+export function readChildCommandState(channelDir) {
+  try {
+    return JSON.parse(fs.readFileSync(childCommandStatePath(channelDir), "utf8"));
+  } catch (error) {
+    if (error.code === "ENOENT")
+      return;
+    throw error;
+  }
+}
+function active(job) {
+  return job.snapshot.endedAt === undefined;
+}
+function text(result) {
+  return Buffer.from(result.content.filter((part) => part.type === "text").map((part) => part.text).join(`
+`)).subarray(-MAX_OUTPUT_BYTES).toString("utf8");
+}
+export function createChildCommandRuntime(channelDir) {
+  const ownerId = randomUUID();
+  const jobs = new Map;
+  const usedIds = new Set;
+  let closed = false;
+  let disposeInbox;
+  const state = () => ({ ownerId, closed, commands: [...jobs.values()].map((job) => ({ ...job.snapshot })) });
+  const persist = () => writeAtomicJson(childCommandStatePath(channelDir), {
+    ownerId,
+    closed,
+    commands: [...jobs.values()].map((job) => ({ ...job.snapshot, output: job.yielded ? job.snapshot.output : "" }))
+  });
+  const operate = (operation, toolCallId) => {
+    if (operation === "status" && toolCallId === undefined)
+      return state();
+    const job = toolCallId ? jobs.get(toolCallId) : undefined;
+    if (!job)
+      throw new Error(`No retained command '${toolCallId ?? ""}' in this child session.`);
+    if (operation !== "status" && closed)
+      throw new Error("Child command controller is closed.");
+    const before = job.snapshot.state;
+    if (active(job)) {
+      if (operation === "yield" && job.snapshot.state === "running") {
+        job.yielded = true;
+        job.snapshot.state = "yielded";
+        job.yieldResult();
+      } else if (operation === "cancel") {
+        job.snapshot.state = "cancel_requested";
+        job.controller.abort();
+      }
+    }
+    if (job.snapshot.state !== before)
+      persist();
+    return { ownerId, closed, commands: [{ ...job.snapshot }] };
+  };
+  const startInbox = () => {
+    if (disposeInbox)
+      return;
+    disposeInbox = watchAsyncControlInbox(channelDir, {
+      onCommand(request) {
+        const replyPath = commandReplyPath(channelDir, request.id);
+        try {
+          if (request.ownerId !== ownerId)
+            throw new Error("Command request belongs to another child session.");
+          if (Date.now() > request.deadlineAt)
+            throw new Error("Command request expired before delivery.");
+          writeAtomicJson(replyPath, { state: operate(request.operation, request.toolCallId) });
+        } catch (error) {
+          writeAtomicJson(replyPath, { error: error instanceof Error ? error.message : String(error) });
+        }
+      }
+    });
+  };
+  const stop = async () => {
+    closed = true;
+    disposeInbox?.();
+    for (const job of jobs.values())
+      if (active(job)) {
+        job.snapshot.state = "cancel_requested";
+        job.controller.abort();
+      }
+    await Promise.all([...jobs.values()].map((job) => job.settled));
+    if (jobs.size)
+      persist();
+  };
+  return {
+    state,
+    operate,
+    shutdown: stop,
+    async finish() {
+      const pending = [...jobs.values()].filter(active);
+      if (!pending.length)
+        return;
+      await stop();
+      throw new Error(`Child finished with unfinished commands: ${pending.map((job) => job.snapshot.toolCallId).join(", ")}. Commands were cancelled; query or cancel background commands before finishing.`);
+    },
+    wrap(tool) {
+      return {
+        ...tool,
+        parameters: Type.Unsafe({ ...tool.parameters, properties: {
+          ...tool.parameters.properties,
+          yieldTimeMs: Type.Optional(Type.Integer({ minimum: 0, maximum: 30000, description: "Return a managed command handle after this wait; does not terminate the command. Omit to wait for completion." }))
+        } }),
+        description: `${tool.description}
+Optional yieldTimeMs returns a command handle without stopping execution. Use subagent_command to query or cancel it. Finish or cancel every command before completing the task.`,
+        async execute(toolCallId, params, signal, onUpdate, ctx) {
+          if (closed)
+            throw new Error("Child command controller is closed.");
+          if (usedIds.has(toolCallId))
+            throw new Error(`Command id '${toolCallId}' was already used in this child session.`);
+          usedIds.add(toolCallId);
+          const { yieldTimeMs, ...args } = params;
+          const controller = new AbortController;
+          const commandSignal = signal ? AbortSignal.any([signal, controller.signal]) : controller.signal;
+          let yieldResult;
+          const yielded = new Promise((resolve) => {
+            yieldResult = resolve;
+          });
+          const job = { snapshot: { toolCallId, state: "running", startedAt: Date.now(), output: "" }, controller, yieldResult, settled: Promise.resolve() };
+          const completed = [...jobs].filter(([, candidate]) => !active(candidate));
+          for (const [id] of completed.slice(0, Math.max(0, completed.length - RECENT_COMMANDS + 1)))
+            jobs.delete(id);
+          jobs.set(toolCallId, job);
+          persist();
+          startInbox();
+          let timer;
+          if (typeof yieldTimeMs === "number")
+            timer = setTimeout(() => operate("yield", toolCallId), yieldTimeMs);
+          const execution = Promise.resolve().then(() => tool.execute(toolCallId, args, commandSignal, (update) => {
+            job.snapshot.output = text(update);
+            if (job.snapshot.state === "running")
+              onUpdate?.(update);
+          }, ctx)).then((result) => {
+            job.snapshot.output = text(result);
+            job.snapshot.state = "completed";
+            const fullOutputPath = result.details?.fullOutputPath;
+            if (fullOutputPath)
+              job.snapshot.fullOutputPath = fullOutputPath;
+            return result;
+          }, (error) => {
+            job.snapshot.state = controller.signal.aborted ? "cancelled" : "failed";
+            job.snapshot.output = String(error).slice(-MAX_OUTPUT_BYTES);
+            throw error;
+          }).finally(() => {
+            if (timer)
+              clearTimeout(timer);
+            job.snapshot.endedAt = Date.now();
+            persist();
+          });
+          job.settled = execution.then(() => {}, () => {});
+          const result = await Promise.race([execution.then((value) => ({ value })), yielded.then(() => {
+            return;
+          })]);
+          if (result)
+            return result.value;
+          return { content: [{ type: "text", text: `Command is still running (toolCallId: ${toolCallId}). This is not a successful exit. Use subagent_command({ action: "status", toolCallId: ${JSON.stringify(toolCallId)} }) to inspect or wait, or action: "cancel" to stop it.
+${job.snapshot.output}` }], details: { command: { ...job.snapshot } } };
+        }
+      };
+    },
+    tool() {
+      return {
+        name: CHILD_COMMAND_TOOL,
+        label: "Child command",
+        description: "Inspect or cancel bash commands owned by this child. Cancellation stops only the selected command, not the agent. Check terminal state before finishing.",
+        parameters: Type.Object({ action: Type.String({ enum: ["status", "cancel"] }), toolCallId: Type.Optional(Type.String()), waitMs: Type.Optional(Type.Integer({ minimum: 0, maximum: 30000 })) }),
+        async execute(_id, params, signal) {
+          const { action, toolCallId, waitMs = 0 } = params;
+          operate(action, toolCallId);
+          const job = toolCallId ? jobs.get(toolCallId) : undefined;
+          if (job && active(job) && waitMs > 0)
+            await waitForCommand(job.settled, waitMs, signal);
+          const snapshot = operate("status", toolCallId);
+          return { content: [{ type: "text", text: JSON.stringify(snapshot) }], details: snapshot };
+        }
+      };
+    }
+  };
+}
+async function waitForCommand(settled, waitMs, signal) {
+  let timer;
+  let abort;
+  const wait = new Promise((resolve, reject) => {
+    timer = setTimeout(resolve, waitMs);
+    abort = () => reject(new Error("Command wait aborted; command remains managed by the child."));
+    if (signal?.aborted)
+      abort();
+    else
+      signal?.addEventListener("abort", abort, { once: true });
+  });
+  try {
+    await Promise.race([settled, wait]);
+  } finally {
+    clearTimeout(timer);
+    signal?.removeEventListener("abort", abort);
+  }
+}
+function commandReplyPath(channelDir, id) {
+  return path.join(channelDir, "command-replies", `${id}.json`);
+}
+export async function controlChildCommand(channelDir, operation, toolCallId, signal) {
+  const current = readChildCommandState(channelDir);
+  if (!current)
+    throw new Error("No command controller is available for this child. Command controls require a local native DM child with bash.");
+  if (current.closed) {
+    if (operation === "status") {
+      if (toolCallId === undefined)
+        return current;
+      const command = current.commands.find((entry) => entry.toolCallId === toolCallId);
+      if (!command)
+        throw new Error(`No retained command '${toolCallId}' in this child session.`);
+      return { ...current, commands: [command] };
+    }
+    throw new Error("Child command controller is closed.");
+  }
+  if (operation !== "status" && !toolCallId)
+    throw new Error("An exact toolCallId is required; command controls never target the next command.");
+  const id = randomUUID();
+  const deadlineAt = Date.now() + 5000;
+  const request = { type: "command", id, ownerId: current.ownerId, operation, ...toolCallId ? { toolCallId } : {}, deadlineAt };
+  requestAsyncCommand(channelDir, request);
+  const replyPath = commandReplyPath(channelDir, id);
+  try {
+    while (Date.now() < deadlineAt) {
+      if (signal?.aborted)
+        throw new Error("Command control wait aborted; delivery may still be pending.");
+      try {
+        const reply = JSON.parse(fs.readFileSync(replyPath, "utf8"));
+        if (reply.error)
+          throw new Error(reply.error);
+        if (reply.state)
+          return reply.state;
+      } catch (error) {
+        if (error.code !== "ENOENT")
+          throw error;
+      }
+      await new Promise((resolve) => setTimeout(resolve, 20));
+    }
+    throw new Error("Command control acknowledgement timed out. Inspect command status; cancellation is not confirmed.");
+  } finally {
+    fs.rmSync(replyPath, { force: true });
+  }
+}

package/extensions/dm-subagents/src/runs/shared/child-hooks.js

@@ -2,7 +2,7 @@ import { listBackgroundWorkProviders } from "../../api/background-work.js";
 import { ReadonlyDrainObservation } from "./readonly-drain-observation.js";
 import registerFanoutChildSubagentExtension, { createChildSafeState } from "../../extension/fanout-child.js";
 import registerSubagentFastModeExtension from "./fast-mode-extension.js";
-import registerSubagentPromptRuntime from "./subagent-prompt-runtime.js";
+import registerSubagentPromptRuntime, { registerSubagentPromptBoundary } from "./subagent-prompt-runtime.js";
 import { projectRuntimeAcknowledgedExtensions } from "./runtime-acknowledged-extensions.js";
 const promptProofs = new WeakMap;
 function ownedProof(hooks) {
@@ -154,13 +154,14 @@ function childHooks(config, capture, holdFinalDrain) {
       registerSubagentPromptRuntime(dm, runtime, proof.observation);
     } }
   ];
-  if (proof) {
-    proof.factories = hooks.map((hook) => hook.factory);
-    promptProofs.set(hooks[0].factory, proof);
-  }
   if (config.fast)
     hooks.push({ name: "dm-subagents:fast-mode", factory: (dm) => registerSubagentFastModeExtension(dm) });
   if (config.fanoutChild)
     hooks.push({ name: "dm-subagents:fanout-child", factory: (dm) => registerFanoutChildSubagentExtension(dm, runtime) });
+  hooks.push({ name: "dm-subagents:prompt-boundary", factory: (dm) => registerSubagentPromptBoundary(dm, runtime) });
+  if (proof) {
+    proof.factories = hooks.map((hook) => hook.factory);
+    promptProofs.set(hooks[0].factory, proof);
+  }
   return hooks;
 }

package/extensions/dm-subagents/src/runs/shared/child-launch.js

@@ -4,6 +4,7 @@ import { intersectThinkingCeilings } from "../../shared/thinking-ceiling.js";
 import {
   resolveChildDepth
 } from "../../shared/types.js";
+import { extensionOnlyMcpServers } from "./mcp-direct-tool-allowlist.js";
 import { encodeExtensionBindings, DM_SUBAGENT_EXTENSION_BINDINGS_ENV } from "./extension-bindings.js";
 import { intersectSubagentCapabilityCeilings } from "./capability-ceiling.js";
 import {
@@ -41,7 +42,9 @@ function inheritedCapabilityCeiling(inherited) {
 function childProcessEnv(input, toolPlan) {
   const env = {};
   env[DM_SUBAGENT_EXTENSION_BINDINGS_ENV] = encodeExtensionBindings(input.extensionBindings);
-  if (!toolPlan.capabilityCeiling && input.mcpDirectTools?.length)
+  if (toolPlan.builtinMcpTools)
+    env[MCP_DIRECT_TOOLS_ENV] = "__none__";
+  else if (!toolPlan.capabilityCeiling && input.mcpDirectTools?.length)
     env[MCP_DIRECT_TOOLS_ENV] = input.mcpDirectTools.join(",");
   else if (toolPlan.capabilityCeiling && toolPlan.effectiveMcpSelections.length && !toolPlan.capabilityCeiling.denyExtensions) {
     env[MCP_DIRECT_TOOLS_ENV] = toolPlan.effectiveMcpSelections.map((selection) => selection.selector).join(",");
@@ -75,6 +78,7 @@ export function buildInProcessChildLaunch(input) {
     subagentOnlyExtensions: input.subagentOnlyExtensions,
     requiredExtensions,
     mcpDirectTools: input.mcpDirectTools,
+    builtinMcpTools: input.builtinMcpTools,
     cwd: input.cwd,
     requireReadTool: input.requireReadTool,
     structuredOutput: Boolean(input.structuredOutput),
@@ -86,6 +90,11 @@ export function buildInProcessChildLaunch(input) {
     permissionRules: input.permissionRules,
     runtimeSnapshotHost: input.runtimeSnapshotHost
   });
+  if (input.host === "parent" && input.runtimeSnapshotHost && toolPlan.builtinMcpTools?.length) {
+    const servers = extensionOnlyMcpServers(toolPlan.effectiveMcpSelections, input.runtimeSnapshotHost, input.cwd, input.projectTrusted !== false);
+    if (servers.length)
+      throw new Error(`Agent '${input.childAgentName}' selects MCP tools from servers that extensions registered (${servers.join(", ")}). Only background children (async: true) load those extensions; run the agent in the background or add the server to the global mcp.json or a trusted project's .dm/mcp.json.`);
+  }
   toolPlan.capabilityCeiling = intersectSubagentCapabilityCeilings(toolPlan.capabilityCeiling, agentCapabilityCeiling);
   if (toolPlan.capabilityAudit && toolPlan.capabilityCeiling) {
     toolPlan.capabilityAudit = { ...toolPlan.capabilityAudit, ceiling: toolPlan.capabilityCeiling };
@@ -180,10 +189,13 @@ ${input.systemPrompt}` : undefined;
   const session = {
     cwd: input.cwd,
     ...input.machine ? { machine: input.machine } : {},
+    ...input.projectTrusted !== undefined ? { projectTrusted: input.projectTrusted } : {},
     ...input.machine ? { remoteResources: { agent: input.childAgentName, ...input.remoteSkillNames ? { skills: input.remoteSkillNames } : {}, ...input.remoteReads !== undefined ? { reads: input.remoteReads } : {}, ...toolPlan.explicitToolAllowlist ? { toolCeiling: [...toolPlan.effectiveToolAllowlist] } : toolPlan.capabilityCeiling?.allowedTools ? { toolCeiling: [...toolPlan.capabilityCeiling.allowedTools] } : {} } } : {},
     storage: childStorage(input),
+    ...input.parentSessionFile ? { parentSessionFile: input.parentSessionFile } : {},
     ...input.model ? { model: input.model } : {},
     ...toolPlan.explicitToolAllowlist ? { tools: toolPlan.effectiveToolAllowlist } : {},
+    ...toolPlan.builtinMcpTools?.length ? { builtinMcpTools: toolPlan.builtinMcpTools } : {},
     ...!toolPlan.explicitToolAllowlist && toolPlan.excludeTools.length > 0 ? { excludeTools: toolPlan.excludeTools } : {},
     extensionPaths,
     requiredExtensions: toolPlan.requiredExtensions,