@duckmind/dm-linux-x64 0.65.5 → 0.65.6

package/extensions/dm-subagents/src/runs/background/run-status.js

@@ -1,6 +1,8 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
 import { safeTerminalText } from "../../shared/display-text.js";
+import { getArtifactPaths, getArtifactsDir } from "../../shared/artifacts.js";
+import { readFleetTranscript } from "../../tui/fleet-transcript.js";
 import { formatAsyncRunList, formatAsyncRunOutputPath, formatAsyncRunProgressLabel, formatWorkflowStageLine, listAsyncRuns } from "./async-status.js";
 import { formatAsyncResultTranscript, formatAsyncRunTranscript, formatNestedRunTranscript, inspectSubagentFleet } from "./fleet-view.js";
 import { formatNestedRunStatusLines } from "../shared/nested-render.js";
@@ -13,6 +15,7 @@ import { resolveSubagentIntercomTarget } from "../../intercom/intercom-bridge.js
 import { normalizeExternalCliRunnerStatus } from "../shared/external-cli-contract.js";
 import { resolveSubagentResultStatus } from "../../intercom/result-intercom.js";
 import { readProcessTerminal, sanitizeProcessTerminal } from "./process-terminal.js";
+import { readWorkflowTerminalProof } from "./workflow-terminal-proof.js";
 import { formatWaitSubscriptions } from "./wait-subscriptions.js";
 import { resolveAsyncRunLocation } from "./async-resume.js";
 import { resolveSubagentRunId } from "./run-id-resolver.js";
@@ -27,6 +30,9 @@ import { formatRunFanoutBudget, getRunFanoutBudgetSnapshot, readRunFanoutBudgetD
 import { workflowGraphStageNodes } from "../shared/workflow-graph.js";
 import { getExternalJobProvider } from "../../api/external-job-provider.js";
 import { formatTimeoutRecoveryLines } from "../shared/mutation-evidence.js";
+import { formatWorkflowChecklistText, projectWorkflowChecklist } from "../../workflows/workflow-checklist.js";
+import { validHostStepNodes } from "../shared/host-step-status.js";
+import { workflowAsyncChildSteeringGuidance } from "../shared/workflow-async-child-guidance.js";
 function formatProcessTerminal(value) {
   if (!value)
     return "missing";
@@ -62,7 +68,7 @@ function formatWorkflowDebug(status) {
     status.lane ? `Lane: ${status.lane.key}${status.lane.mode ? ` (${status.lane.mode})` : ""}` : undefined
   ].filter((line) => line !== undefined);
   for (const [index, step] of (status.steps ?? []).entries()) {
-    lines.push(`  ${index + 1}. key ${step.workflowKey ?? "n/a"} · ${runStatusStepDisplayName(step)} · ${step.status} · async ${step.async === undefined ? "unknown" : step.async ? "yes" : "no"}${step.runId ? ` · run ${step.runId}` : ""}${step.lane ? ` · lane ${step.lane.key}` : ""}${step.worktreePath ? ` · worktree ${step.worktreePath} · branch ${step.branch ?? "unknown"}` : ""}`);
+    lines.push(`  ${index + 1}. key ${step.workflowKey ?? "n/a"} · ${runStatusStepDisplayName(step)} · ${step.status} · async ${step.async === undefined ? "unknown" : step.async ? "yes" : "no"}${step.runId ? ` · run ${step.runId}` : ""}${step.lane ? ` · lane ${step.lane.key}` : ""}${step.worktreePath ? ` · worktree ${step.worktreePath} · branch ${step.branch ?? "unknown"}${step.provider ? ` · provider ${step.provider}` : ""}` : ""}`);
   }
   return lines;
 }
@@ -73,6 +79,7 @@ function formatRunLifecycleDebug(input) {
     `Run: ${status.runId}`,
     `Dir: ${asyncDir}`,
     `Status file: ${path.join(asyncDir, "status.json")}`,
+    status.workflowReceiptPath ? `Workflow receipt: ${status.workflowReceiptPath}` : undefined,
     `Process terminal file: ${path.join(asyncDir, "process-terminal.json")}`,
     `Session: ${status.sessionId ?? "unknown"}`,
     `State: ${status.state}`,
@@ -219,6 +226,55 @@ function formatRememberedForegroundStatus(run) {
   return lines.join(`
 `);
 }
+function formatLiveForegroundTranscript(control, state, options) {
+  if (!state.currentSessionId || control.sessionId !== state.currentSessionId) {
+    throw new Error(`Foreground run '${control.runId}' is not owned by the current session.`);
+  }
+  if (options.index !== undefined && (!Number.isInteger(options.index) || options.index < 0)) {
+    throw new Error("Transcript index must be a non-negative integer.");
+  }
+  const children = control.activeChildren ? [...control.activeChildren.values()] : control.currentAgent ? [{ index: control.currentIndex ?? 0, agent: control.currentAgent, sessionName: control.sessionName }] : [];
+  const header = [`Run: ${control.runId}`, "State: live foreground"];
+  if (children.length === 0)
+    return `${header.map((line) => safeTerminalText(line)).join(`
+`)}
+Transcript unavailable: no active foreground child.`;
+  if (options.index === undefined && children.length > 1) {
+    throw new Error(`Transcript view requires index for foreground run '${control.runId}'. Active child indexes: ${children.map((child) => child.index).join(", ")}.`);
+  }
+  const child = options.index === undefined ? children[0] : children.find((child) => child.index === options.index);
+  if (!child)
+    throw new Error(`Transcript index ${options.index} is not an active foreground child of '${control.runId}'.`);
+  const root = getArtifactsDir(state.parentSessionFile ?? null, control.cwd ?? state.baseCwd, state.artifactDirPreference);
+  const transcriptPath = getArtifactPaths(root, control.runId, child.agent, child.index).transcriptPath;
+  const transcript = readFleetTranscript(transcriptPath, { trustedRoots: [root] });
+  const lineLimit = Number.isFinite(options.lines) ? Math.max(1, Math.min(500, Math.trunc(options.lines))) : 80;
+  const allLines = transcript.events.flatMap((event) => {
+    const text = event.kind === "tool" ? [`Tool: ${event.name} (${event.status})`, event.argsPayload ?? event.args, event.output ?? event.error].filter(Boolean).join(`
+`) : event.kind === "notice" ? event.text : `${event.kind === "assistant" ? "Assistant" : "Supervisor"}: ${event.text}`;
+    return text.split(/\r?\n/);
+  });
+  let body = allLines.slice(-lineLimit).join(`
+`);
+  let truncated = transcript.truncated || allLines.length > lineLimit || transcript.events.some((event) => event.kind === "tool" && event.outputTruncated) || body.includes("… message truncated");
+  const maxOutputBytes = 32 * 1024;
+  const bytes = Buffer.from(body);
+  if (bytes.length > maxOutputBytes) {
+    let start = bytes.length - maxOutputBytes;
+    while ((bytes[start] & 192) === 128)
+      start++;
+    body = bytes.subarray(start).toString("utf-8");
+    truncated = true;
+  }
+  header.push(`Child: ${child.index} (${child.sessionName?.trim() || child.agent})`, `Transcript: ${transcriptPath}`);
+  if (transcript.warning)
+    header.push(`Transcript warning: ${transcript.warning}`);
+  header.push(`Live transcript tail${truncated ? " (tail truncated)" : ""}:`);
+  if (!body)
+    header.push("Transcript unavailable: no readable activity in the bounded artifact tail yet.");
+  return [...header.map((line) => safeTerminalText(line)), body].filter(Boolean).join(`
+`);
+}
 function formatRememberedForegroundTranscript(run, options) {
   let index = options.index;
   if (index !== undefined && !Number.isInteger(index))
@@ -298,6 +354,12 @@ export function inspectSubagentStatus(params, deps = {}) {
     return inspectSubagentFleet(params, { asyncDirRoot, resultsDir, kill: deps.kill, now: deps.now, state: deps.state, childSafe: Boolean(deps.nested) });
   }
   if (!params.id && !params.runId && !params.dir) {
+    if (params.view === "transcript" && deps.state?.currentSessionId) {
+      const controls = [...deps.state.foregroundControls.values()].filter((control) => control.sessionId === currentSessionId);
+      const foreground = controls.find((control) => control.runId === deps.state?.lastForegroundControlId) ?? controls.sort((left, right) => right.updatedAt - left.updatedAt)[0];
+      if (foreground)
+        return inspectSubagentStatus({ ...params, id: foreground.runId }, deps);
+    }
     if (deps.nested) {
       return {
         content: [{ type: "text", text: "Child-safe subagent status requires an id when no foreground run is active." }],
@@ -340,6 +402,13 @@ export function inspectSubagentStatus(params, deps = {}) {
     } else if (!params.dir && requestedId) {
       const resolved = resolveSubagentRunId(requestedId, { asyncDirRoot, resultsDir, state: deps.state, nested: deps.nested });
       if (resolved?.kind === "foreground") {
+        const control = deps.state?.foregroundControls.get(resolved.id);
+        if (control && deps.state && params.view === "transcript") {
+          return {
+            content: [{ type: "text", text: formatLiveForegroundTranscript(control, deps.state, params) }],
+            details: { mode: "management", results: [] }
+          };
+        }
         const run = deps.state?.foregroundRuns?.get(resolved.id);
         if (run) {
           try {
@@ -410,7 +479,7 @@ export function inspectSubagentStatus(params, deps = {}) {
         const capacity = inspectActiveAsyncCapacityOwner({ runId: diskStatus.runId, sessionId: diskStatus.sessionId, asyncDir }, { rootDir: deps.activeCapacityRoot, liveWorkflowRunIds: new Set(deps.state?.workflowControllers?.keys() ?? []), abandonedSlotReleaseAfterMs: deps.abandonedSlotReleaseAfterMs });
         return {
           content: [{ type: "text", text: formatRunLifecycleDebug({ status: diskStatus, asyncDir, sidecarProcessTerminal: sidecar, overlayProcessTerminal: overlay, capacity }) }],
-          details: { mode: "single", results: [], ...sidecar ?? overlay ? { lifecycleStatus: { processTerminal: sidecar ?? overlay } } : {} }
+          details: { mode: "single", results: [], ...diskStatus.workflowReceiptPath ? { workflowReceiptPath: diskStatus.workflowReceiptPath } : {}, ...sidecar ?? overlay ? { lifecycleStatus: { processTerminal: sidecar ?? overlay } } : {} }
         };
       }
       if (params.view === "transcript") {
@@ -440,7 +509,7 @@ No running work was terminated.` }],
         const capacity = inspectActiveAsyncCapacityOwner({ runId: status.runId, sessionId: status.sessionId, asyncDir }, { rootDir: deps.activeCapacityRoot, liveWorkflowRunIds: new Set(deps.state?.workflowControllers?.keys() ?? []), abandonedSlotReleaseAfterMs: deps.abandonedSlotReleaseAfterMs });
         return {
           content: [{ type: "text", text: formatRunLifecycleDebug({ status, asyncDir, sidecarProcessTerminal: sidecar, overlayProcessTerminal: overlay, capacity }) }],
-          details: { mode: "single", results: [], ...sidecar ?? overlay ? { lifecycleStatus: { processTerminal: sidecar ?? overlay } } : {} }
+          details: { mode: "single", results: [], ...status.workflowReceiptPath ? { workflowReceiptPath: status.workflowReceiptPath } : {}, ...sidecar ?? overlay ? { lifecycleStatus: { processTerminal: sidecar ?? overlay } } : {} }
         };
       }
       if (params.view === "transcript") {
@@ -494,6 +563,11 @@ No running work was terminated.` }],
       }
       const workflowReturnPreview = status.workflow?.value !== undefined ? formatWorkflowJsonPreview(status.workflow.value, 240) : undefined;
       const workflowEmitPreview = status.workflow?.emits.length ? formatWorkflowJsonPreview(status.workflow.emits.at(-1), 240) : undefined;
+      const workflowChildren = parseWorkflowChildSummary(status.workflowChildren);
+      if (workflowChildren && workflowChildren.workflowRunId !== status.runId)
+        throw new Error("workflowChildren.workflowRunId does not match async status runId.");
+      const workflowTerminalProof = workflowChildren ? readWorkflowTerminalProof(asyncDir, status.steps, workflowChildren, validHostStepNodes(status.workflowGraph).length, status.endedAt ?? status.lastUpdate ?? status.startedAt) : undefined;
+      const workflowChildrenByKey = new Map(workflowChildren?.children.map((child) => [child.childId, child]));
       const lines = [
         `Run: ${status.runId}`,
         status.toolCallId ? `Tool call: ${status.toolCallId}` : undefined,
@@ -514,6 +588,14 @@ Extensions denied: ${status.capabilityCeiling.denyExtensions ? "yes" : "no"} (so
         status.mode === "workflow" && workflowReturnPreview !== undefined ? `Return: ${workflowReturnPreview}` : undefined,
         status.mode === "workflow" && workflowEmitPreview !== undefined ? `Latest emit: ${workflowEmitPreview}` : undefined,
         `Progress: ${progressLabel}`,
+        ...status.mode === "workflow" ? formatWorkflowChecklistText(projectWorkflowChecklist({
+          graph: status.workflowGraph,
+          steps: status.steps,
+          hostSteps: validHostStepNodes(status.workflowGraph),
+          preflight: status.preflight,
+          trace: status.workflow?.trace,
+          now: status.lastUpdate ?? status.endedAt ?? Date.now()
+        }), "", { includeItems: false }) : [],
         status.pendingAppends ? `Pending appends: ${status.pendingAppends}` : undefined,
         `Started: ${started}`,
         `Updated: ${updated}`,
@@ -524,11 +606,12 @@ Extensions denied: ${status.capabilityCeiling.denyExtensions ? "yes" : "no"} (so
         reconciliation.message ? `Diagnosis: ${reconciliation.message}` : undefined,
         reconciliation.resultPath && fs.existsSync(reconciliation.resultPath) ? `Result: ${reconciliation.resultPath}` : undefined
       ].filter((line) => Boolean(line));
-      const liveWorkflowControls = status.mode === "workflow" && deps.state?.currentSessionId === status.sessionId && deps.state?.workflowControllers?.has(status.runId) ? [...deps.state?.foregroundControls.values() ?? []].filter((control) => control.parentWorkflowRunId === status.runId && control.sessionId === status.sessionId && Boolean(control.workflowSteeringDir && fs.existsSync(control.workflowSteeringDir)) && (control.activeChildren?.size ?? 0) > 0) : [];
+      const liveWorkflowControls = status.mode === "workflow" && deps.state?.currentSessionId === status.sessionId && deps.state?.workflowControllers?.has(status.runId) ? [...deps.state?.foregroundControls.values() ?? []].filter((control) => control.parentWorkflowRunId === status.runId && control.sessionId === status.sessionId && (control.activeChildren?.size ?? 0) > 0) : [];
       let hasExternalJobFollowUpHint = false;
       for (const [index, step] of (status.steps ?? []).entries()) {
         const stepActivityText = step.status === "running" ? formatActivityLabel(step.lastActivityAt, step.activityState) : undefined;
-        const modelThinking = formatModelThinking(step.model, step.thinking);
+        const workflowChild = step.workflowKey ? workflowChildrenByKey.get(step.workflowKey) : undefined;
+        const modelThinking = formatModelThinking(step.model ?? workflowChild?.model, step.thinking ?? workflowChild?.thinking);
         const modelText = modelThinking ? ` (${modelThinking})` : "";
         const steeringText = formatSteeringSummary(step);
         const steeringSuffix = steeringText ? `, steering: ${steeringText}` : "";
@@ -538,6 +621,13 @@ Extensions denied: ${status.capabilityCeiling.denyExtensions ? "yes" : "no"} (so
         const display = runStatusStepDisplayName(step);
         const phase = step.phase ? `[${step.phase}] ` : "";
         lines.push(`${stepLineLabel(status, index)}: ${phase}${display} ${step.status}${modelText}${stepActivityText ? `, ${stepActivityText}` : ""}${steeringSuffix}${acceptanceText}${budgetText}${errorText}`);
+        if (status.mode === "workflow" && step.runId)
+          lines.push(`  Child run: ${step.runId}`);
+        const structuredOutputPreview = step.structuredOutput === undefined ? undefined : formatWorkflowJsonPreview(step.structuredOutput, 4000);
+        if (structuredOutputPreview !== undefined)
+          lines.push(`  Structured output: ${structuredOutputPreview}`);
+        if (step.structuredOutputPath)
+          lines.push(`  Structured output path: ${step.structuredOutputPath}`);
         lines.push(...formatTimeoutRecoveryLines(step.timeoutRecovery, "  "));
         if (step.runner?.type === "external-cli") {
           const runner = normalizeExternalCliRunnerStatus(step.runner);
@@ -613,9 +703,12 @@ Extensions denied: ${status.capabilityCeiling.denyExtensions ? "yes" : "no"} (so
               lines.push(`Steer live foreground child: subagent({ action: "steer", id: "${control.runId}", index: ${index}, message: "..." })`);
             }
           }
+        lines.push(...workflowAsyncChildSteeringGuidance(status, deps.state));
       }
       if (nestedWarning)
         lines.push(`Warning: ${nestedWarning}`);
+      if (status.workflowReceiptPath)
+        lines.push(`Workflow receipt: ${status.workflowReceiptPath}`);
       if (status.sessionFile)
         lines.push(`Session: ${status.sessionFile}`);
       const allExternal = (status.steps?.length ?? 0) > 0 && status.steps.every((step) => step.runner?.type === "external-cli" || step.runner?.type === "external-job");
@@ -628,11 +721,8 @@ Extensions denied: ${status.capabilityCeiling.denyExtensions ? "yes" : "no"} (so
         lines.push(`Log: ${logPath}`);
       if (fs.existsSync(eventsPath))
         lines.push(`Events: ${eventsPath}`);
-      const workflowChildren = parseWorkflowChildSummary(status.workflowChildren);
-      if (workflowChildren && workflowChildren.workflowRunId !== status.runId)
-        throw new Error("workflowChildren.workflowRunId does not match async status runId.");
       return { content: [{ type: "text", text: lines.join(`
-`) }], details: { mode: "single", results: [], ...status.preflight ? { preflight: status.preflight } : {}, ...status.workflow?.preflightWarnings?.length ? { preflightWarnings: status.workflow.preflightWarnings } : {}, ...workflowChildren ? { workflowChildren } : {}, ...runFanoutBudget ? { runFanoutBudget } : {}, ...processTerminal ? { lifecycleStatus: { processTerminal } } : {} } };
+`) }], details: { mode: "single", results: [], ...status.workflowReceiptPath ? { workflowReceiptPath: status.workflowReceiptPath } : {}, ...status.preflight ? { preflight: status.preflight } : {}, ...status.workflow?.preflightWarnings?.length ? { preflightWarnings: status.workflow.preflightWarnings } : {}, ...workflowChildren ? { workflowChildren } : {}, ...workflowTerminalProof ? { workflowTerminalProof } : {}, ...runFanoutBudget ? { runFanoutBudget } : {}, ...processTerminal ? { lifecycleStatus: { processTerminal } } : {} } };
     }
   }
   if (resultPath) {
@@ -669,10 +759,23 @@ Extensions denied: ${status.capabilityCeiling.denyExtensions ? "yes" : "no"} (so
       const lines = [`Run: ${runId}`, data.toolCallId ? `Tool call: ${data.toolCallId}` : undefined, `State: ${status}`, `Result: ${resultPath}`].filter((line) => Boolean(line));
       if (data.parallelHandoff?.path)
         lines.push(`Parallel handoff: ${data.parallelHandoff.path}`);
+      const receipt = data.workflowReceipt;
+      const receiptPath = receipt && typeof receipt === "object" && !Array.isArray(receipt) ? receipt.path : undefined;
+      const workflowReceiptPath = typeof receiptPath === "string" && receiptPath ? receiptPath : undefined;
+      if (workflowReceiptPath)
+        lines.push(`Workflow receipt: ${workflowReceiptPath}`);
       const children = Array.isArray(data.results) ? data.results : data.agent ? [{ agent: data.agent, sessionFile: data.sessionFile }] : [];
       lines.push(...formatTimeoutRecoveryLines(data.timeoutRecovery, "  "));
-      for (const child of children)
+      for (const [index, child] of children.entries()) {
+        const structuredOutput = child.structuredOutput;
+        const structuredOutputPreview = structuredOutput === undefined ? undefined : formatWorkflowJsonPreview(structuredOutput, 4000);
+        if (structuredOutputPreview !== undefined)
+          lines.push(`  Structured output${children.length > 1 ? ` (${index + 1})` : ""}: ${structuredOutputPreview}`);
+        const structuredOutputPath = child.structuredOutputPath;
+        if (typeof structuredOutputPath === "string" && structuredOutputPath.trim())
+          lines.push(`  Structured output path${children.length > 1 ? ` (${index + 1})` : ""}: ${structuredOutputPath}`);
         lines.push(...formatTimeoutRecoveryLines(child.timeoutRecovery, "  "));
+      }
       lines.push(formatResumeGuidance(runId, children, data.sessionFile, { stopped: status === "stopped" }));
       if (data.summary)
         lines.push("", data.summary);
@@ -680,7 +783,7 @@ Extensions denied: ${status.capabilityCeiling.denyExtensions ? "yes" : "no"} (so
       if (workflowChildren && workflowChildren.workflowRunId !== runId)
         throw new Error("workflowChildren.workflowRunId does not match the result run id.");
       return { content: [{ type: "text", text: lines.join(`
-`) }], details: { mode: "single", results: [], ...workflowChildren ? { workflowChildren } : {} } };
+`) }], details: { mode: "single", results: [], ...workflowReceiptPath ? { workflowReceiptPath } : {}, ...workflowChildren ? { workflowChildren } : {} } };
     } catch (error) {
       const message = error instanceof Error ? error.message : String(error);
       return {

package/extensions/dm-subagents/src/runs/background/runner-aliases.js

@@ -0,0 +1,129 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+export const JITI_ALIAS_ENV = "JITI_ALIAS";
+export const HOST_PEER_ALIASES = [
+  { specifier: "@duckmind/dm-coding-agent", pkg: "@duckmind/dm-coding-agent", subpath: "." },
+  { specifier: "@duckmind/dm-agent-core", pkg: "@duckmind/dm-agent-core", subpath: "." },
+  { specifier: "@duckmind/dm-agent-core/node", pkg: "@duckmind/dm-agent-core", subpath: "./node" },
+  { specifier: "@duckmind/dm-tui", pkg: "@duckmind/dm-tui", subpath: "." },
+  { specifier: "@duckmind/dm-ai", pkg: "@duckmind/dm-ai", subpath: "./compat" },
+  { specifier: "@duckmind/dm-ai/compat", pkg: "@duckmind/dm-ai", subpath: "./compat" },
+  { specifier: "@duckmind/dm-ai/oauth", pkg: "@duckmind/dm-ai", subpath: "./oauth" },
+  { specifier: "@duckmind/dm-ai/providers/all", pkg: "@duckmind/dm-ai", subpath: "./providers/all" },
+  { specifier: "typebox", pkg: "typebox", subpath: "." },
+  { specifier: "typebox/compile", pkg: "typebox", subpath: "./compile" },
+  { specifier: "typebox/value", pkg: "typebox", subpath: "./value" }
+];
+const CHORD_PEER_ALIASES = [
+  { specifier: "@earendil-works/chord", pkg: "@earendil-works/chord", subpath: "." },
+  { specifier: "@earendil-works/chord/context", pkg: "@earendil-works/chord", subpath: "./context" }
+];
+function readManifest(packageDir) {
+  try {
+    return JSON.parse(fs.readFileSync(path.join(packageDir, "package.json"), "utf-8"));
+  } catch {
+    return;
+  }
+}
+const BLOCKED_EXPORT = Symbol("blocked export");
+function exportTarget(entry) {
+  if (typeof entry === "string")
+    return entry;
+  if (entry === null)
+    return BLOCKED_EXPORT;
+  if (Array.isArray(entry)) {
+    let blocked = entry.length === 0;
+    for (const candidate of entry) {
+      const target = exportTarget(candidate);
+      if (typeof target === "string")
+        return target;
+      if (target === BLOCKED_EXPORT)
+        blocked = true;
+    }
+    return blocked ? BLOCKED_EXPORT : undefined;
+  }
+  if (entry && typeof entry === "object") {
+    const conditions = entry;
+    for (const [condition, value] of Object.entries(conditions)) {
+      if (condition === "default" || condition === "import" || condition === "node" || condition === "node-addons" || condition === "module-sync") {
+        const target = exportTarget(value);
+        if (target)
+          return target;
+      }
+    }
+  }
+  return;
+}
+export function resolvePackageSubpath(packageDir, subpath) {
+  const manifest = readManifest(packageDir);
+  if (!manifest)
+    return;
+  const exportsField = manifest.exports;
+  if (exportsField !== undefined && exportsField !== null) {
+    const map = typeof exportsField === "string" || Array.isArray(exportsField) || exportsField && typeof exportsField === "object" && !Object.keys(exportsField).some((key) => key.startsWith(".")) ? { ".": exportsField } : exportsField;
+    if (subpath in map) {
+      const exact = exportTarget(map[subpath]);
+      return typeof exact === "string" ? path.resolve(packageDir, exact) : undefined;
+    }
+    let best;
+    for (const [pattern, entry] of Object.entries(map)) {
+      const star = pattern.indexOf("*");
+      if (star === -1)
+        continue;
+      const prefix = pattern.slice(0, star);
+      const suffix = pattern.slice(star + 1);
+      if (!subpath.startsWith(prefix) || !subpath.endsWith(suffix) || subpath.length < prefix.length + suffix.length)
+        continue;
+      if (!best || prefix.length > best.prefix.length || prefix.length === best.prefix.length && suffix.length > best.suffix.length)
+        best = { entry, prefix, suffix };
+    }
+    if (!best)
+      return;
+    const target = exportTarget(best.entry);
+    if (typeof target !== "string")
+      return;
+    const wildcard = subpath.slice(best.prefix.length, subpath.length - best.suffix.length);
+    return path.resolve(packageDir, target.replaceAll("*", () => wildcard));
+  }
+  if (subpath !== ".")
+    return;
+  return path.resolve(packageDir, typeof manifest.main === "string" && manifest.main.trim() ? manifest.main : "index.js");
+}
+export function findHostPeerPackageDir(piPackageRoot, pkg) {
+  return findPeerPackageDir(piPackageRoot, pkg, readManifest(piPackageRoot)?.name);
+}
+function findPeerPackageDir(piPackageRoot, pkg, hostName) {
+  if (hostName === pkg)
+    return piPackageRoot;
+  const candidates = [path.join(piPackageRoot, "node_modules", pkg)];
+  let dir = piPackageRoot;
+  for (;; ) {
+    const parent = path.dirname(dir);
+    if (parent === dir)
+      break;
+    if (path.basename(parent) === "node_modules" || path.basename(path.dirname(parent)) === "node_modules") {
+      const modulesRoot = path.basename(parent) === "node_modules" ? parent : path.dirname(parent);
+      candidates.push(path.join(modulesRoot, pkg));
+    }
+    candidates.push(path.join(parent, "node_modules", pkg));
+    dir = parent;
+  }
+  return candidates.find((candidate) => readManifest(candidate)?.name === pkg);
+}
+export function resolveHostPeerAliases(piPackageRoot) {
+  const aliases = {};
+  const missing = [];
+  const hostManifest = readManifest(piPackageRoot);
+  const stableVersion = typeof hostManifest?.version === "string" ? /^0\.(\d+)\.\d+$/.exec(hostManifest.version) : null;
+  const isPreChord = stableVersion !== null && Number(stableVersion[1]) < 85;
+  const required = [...HOST_PEER_ALIASES, ...isPreChord ? [] : CHORD_PEER_ALIASES];
+  for (const { specifier, pkg, subpath } of required) {
+    const packageDir = findPeerPackageDir(piPackageRoot, pkg, hostManifest?.name);
+    const target = packageDir ? resolvePackageSubpath(packageDir, subpath) : undefined;
+    if (target && fs.existsSync(target))
+      aliases[specifier] = fs.realpathSync(target);
+    else
+      missing.push(specifier);
+  }
+  return { aliases, missing };
+}

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

@@ -0,0 +1,62 @@
+import * as path from "node:path";
+import { buildInProcessChildLaunch } from "../shared/child-launch.js";
+import { deriveForkPromptCacheKey } from "../shared/child-tool-plan.js";
+import { normalizeExtensionBindings } from "../shared/extension-bindings.js";
+import { formatAcceptancePrompt } from "../shared/acceptance.js";
+import { isAgentContract } from "../shared/agent-contract.js";
+export function buildRunnerChildLaunch(step, ctx, attempt) {
+  const acceptancePrompt = step.effectiveAcceptance ? formatAcceptancePrompt(step.effectiveAcceptance, { reportOptional: isAgentContract(step.agentContract), structuredOutput: Boolean(step.structuredOutput?.acceptanceReportPath) }) : "";
+  return buildInProcessChildLaunch({
+    machine: step.machine,
+    remoteSkillNames: step.skills,
+    remoteReads: step.remoteReads,
+    parentSessionId: step.parentSessionId,
+    forkCacheKey: step.context === "fork" ? deriveForkPromptCacheKey(step.parentSessionId) : undefined,
+    sessionEnabled: attempt.sessionEnabled,
+    sessionDir: attempt.sessionDir,
+    sessionFile: step.sessionFile,
+    model: attempt.model,
+    inheritProjectContext: step.inheritProjectContext,
+    inheritGlobalContext: step.inheritGlobalContext,
+    inheritSkills: step.inheritSkills,
+    requireReadTool: Boolean(step.skills?.length),
+    tools: step.tools,
+    excludeTools: step.excludeTools,
+    allowNestedSubagents: step.allowNestedSubagents,
+    descendantAllowedAgents: step.allowedAgents,
+    extensions: step.extensions,
+    subagentOnlyExtensions: step.subagentOnlyExtensions,
+    requiredExtensions: step.requiredExtensions,
+    fast: step.fast,
+    systemPrompt: acceptancePrompt ? `${step.systemPrompt ?? ""}
+${acceptancePrompt}` : step.systemPrompt ?? "",
+    systemPromptMode: step.systemPromptMode,
+    mcpDirectTools: step.mcpDirectTools,
+    extensionBindings: normalizeExtensionBindings(step.extensionBindings)?.value,
+    capabilityCeiling: step.capabilityCeiling ?? ctx.capabilityCeiling,
+    cwd: step.cwd ?? ctx.cwd,
+    intercomSessionName: ctx.childIntercomTarget,
+    sessionName: attempt.sessionName,
+    orchestratorIntercomTarget: ctx.orchestratorIntercomTarget,
+    runId: ctx.id,
+    childAgentName: step.agent,
+    childIndex: ctx.flatIndex,
+    nestedRoute: ctx.nestedRoute,
+    runFanoutBudget: ctx.runFanoutBudget ? {
+      ...ctx.runFanoutBudget,
+      ...step.runFanoutPath ? { parentPath: `${ctx.runFanoutBudget.parentPath ? `${ctx.runFanoutBudget.parentPath}/` : ""}${step.runFanoutPath}` } : {}
+    } : undefined,
+    structuredOutput: attempt.structuredOutput,
+    toolBudget: step.toolBudget,
+    permissionRules: step.permissionRules,
+    permissionAuditPath: step.permissionRules && ctx.artifactsDir ? path.join(ctx.artifactsDir, "permission-audit", `${ctx.id}-${ctx.flatIndex}.jsonl`) : undefined,
+    childWatchdog: attempt.childWatchdog,
+    ...attempt.childWatchdog ? { watchdogStatus: attempt.watchdogStatus } : {},
+    waitToolEnabled: step.waitToolEnabled,
+    waitToolDefaultTimeoutMs: step.waitToolDefaultTimeoutMs,
+    thinkingCeiling: step.thinkingCeiling,
+    maxSubagentDepth: step.maxSubagentDepth,
+    inherited: ctx.inheritedChildRuntime,
+    host: "runner"
+  });
+}

package/extensions/dm-subagents/src/runs/background/runner-child-sessions.js

@@ -0,0 +1,16 @@
+import * as path from "node:path";
+import { pathToFileURL } from "node:url";
+import { createPlacementChildSessionFactory } from "../shared/child-session.js";
+function isChildSessionFactory(value) {
+  return Boolean(value) && typeof value === "object" && typeof value.create === "function" && typeof value.dispose === "function";
+}
+export async function loadRunnerChildSessionFactory(config, options) {
+  if (!config.childSessionFactoryModule)
+    return createPlacementChildSessionFactory(options);
+  const loaded = await import(pathToFileURL(path.resolve(config.childSessionFactoryModule)).href);
+  const candidate = typeof loaded.default === "function" ? loaded.default() : loaded.default;
+  if (!isChildSessionFactory(candidate)) {
+    throw new Error(`Child session factory module '${config.childSessionFactoryModule}' must default-export a ChildSessionFactory or a function returning one.`);
+  }
+  return candidate;
+}

package/extensions/dm-subagents/src/runs/background/runner-http-dispatcher.js

@@ -0,0 +1,84 @@
+import { EventEmitter } from "node:events";
+import * as fs from "node:fs";
+import { createRequire } from "node:module";
+import * as path from "node:path";
+import { getConfigDirName } from "../../shared/utils.js";
+export const DEFAULT_HTTP_IDLE_TIMEOUT_MS = 300000;
+export function parseHttpIdleTimeoutMs(value) {
+  if (typeof value === "string") {
+    const trimmed = value.trim();
+    if (trimmed.toLowerCase() === "disabled")
+      return 0;
+    if (trimmed.length === 0)
+      return;
+    return parseHttpIdleTimeoutMs(Number(trimmed));
+  }
+  if (typeof value !== "number" || !Number.isFinite(value) || value < 0)
+    return;
+  return Math.floor(value);
+}
+function readSetting(file) {
+  let raw;
+  try {
+    raw = fs.readFileSync(file, "utf8");
+  } catch (error) {
+    if (error.code === "ENOENT")
+      return { present: false };
+    return { present: false, error: `cannot read ${file}: ${error instanceof Error ? error.message : String(error)}` };
+  }
+  try {
+    const parsed = JSON.parse(raw);
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed))
+      return { present: false };
+    if (!Object.hasOwn(parsed, "httpIdleTimeoutMs"))
+      return { present: false };
+    return { present: true, value: parsed.httpIdleTimeoutMs };
+  } catch (error) {
+    return { present: false, error: `cannot parse ${file}: ${error instanceof Error ? error.message : String(error)}` };
+  }
+}
+export function resolveHttpIdleTimeoutMs(options) {
+  const candidates = [
+    { source: "project", file: path.join(options.cwd, getConfigDirName(), "settings.json") },
+    { source: "global", file: path.join(options.agentDir, "settings.json") }
+  ];
+  const warnings = [];
+  for (const candidate of candidates) {
+    const read = readSetting(candidate.file);
+    if (read.error) {
+      warnings.push(read.error);
+      continue;
+    }
+    if (!read.present)
+      continue;
+    const timeoutMs = parseHttpIdleTimeoutMs(read.value);
+    if (timeoutMs === undefined) {
+      warnings.push(`invalid httpIdleTimeoutMs in ${candidate.file}: ${String(read.value)}`);
+      return { timeoutMs: DEFAULT_HTTP_IDLE_TIMEOUT_MS, source: "default", warning: warnings.join("; ") };
+    }
+    return { timeoutMs, source: candidate.source, ...warnings.length ? { warning: warnings.join("; ") } : {} };
+  }
+  return { timeoutMs: DEFAULT_HTTP_IDLE_TIMEOUT_MS, source: "default", ...warnings.length ? { warning: warnings.join("; ") } : {} };
+}
+export function runnerHttpDispatcherOptions(timeoutMs) {
+  return {
+    allowH2: false,
+    proxyTunnel: true,
+    headersTimeout: timeoutMs,
+    bodyTimeout: timeoutMs
+  };
+}
+export function installRunnerHttpDispatcher(options) {
+  try {
+    const undici = createRequire(import.meta.url)("undici");
+    const idle = resolveHttpIdleTimeoutMs(options);
+    if (idle.warning)
+      console.error(`[dm-subagents] httpIdleTimeoutMs: ${idle.warning}; using ${idle.timeoutMs}ms`);
+    const dispatcher = new undici.EnvHttpProxyAgent(runnerHttpDispatcherOptions(idle.timeoutMs));
+    EventEmitter.prototype.on.call(dispatcher, "error", () => {});
+    undici.setGlobalDispatcher(dispatcher);
+    undici.install();
+  } catch (error) {
+    console.error(`[dm-subagents] proxy-aware HTTP dispatcher not installed: ${error instanceof Error ? error.message : String(error)}`);
+  }
+}

package/extensions/dm-subagents/src/runs/background/runner-startup-failure.js

@@ -0,0 +1,43 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { writePrivateAtomicJson } from "../../shared/atomic-json.js";
+import { readProcessTerminalCandidate } from "./process-terminal-candidate.js";
+export function persistRunnerStartupFailure(input) {
+  const now = Date.now();
+  const statusPath = path.join(input.asyncDir, "status.json");
+  let status = {};
+  try {
+    status = JSON.parse(fs.readFileSync(statusPath, "utf-8"));
+  } catch (error) {
+    if (error.code !== "ENOENT")
+      throw error;
+  }
+  const existingProcessTerminal = status.processTerminal?.state === "observed" || status.processTerminal?.state === "unknown" ? status.processTerminal : undefined;
+  writePrivateAtomicJson(statusPath, {
+    ...status,
+    runId: input.runId,
+    ...input.sessionId ? { sessionId: input.sessionId } : {},
+    ...input.completionOwnerId ? { completionOwnerId: input.completionOwnerId } : {},
+    state: "failed",
+    lastUpdate: now,
+    error: input.message,
+    processTerminal: existingProcessTerminal ?? {
+      version: 1,
+      state: "not-started",
+      runId: input.runId,
+      runnerProcessInstanceId: input.runnerProcessInstanceId
+    }
+  });
+  const existingCandidate = readProcessTerminalCandidate(input.asyncDir);
+  const stepCount = Math.max(1, status.steps?.length ?? 0);
+  writePrivateAtomicJson(path.join(input.asyncDir, "process-terminal-candidate.json"), {
+    ...existingCandidate,
+    version: 1,
+    runId: input.runId,
+    runnerProcessInstanceId: input.runnerProcessInstanceId,
+    writers: {},
+    expectedWriters: Object.fromEntries(Array.from({ length: stepCount }, (_, index) => [String(index), 0])),
+    ...input.candidate?.sessionFile ? { sessionFile: input.candidate.sessionFile } : {},
+    ...input.candidate?.revivalLeaseToken ? { revivalLeaseToken: input.candidate.revivalLeaseToken } : {}
+  });
+}