@duckmind/dm-linux-x64 0.65.4 → 0.65.6

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

@@ -1,6 +1,7 @@
 import { sanitizeDisplayText, truncateDisplayText } from "../../shared/display-text.js";
 import { formatModelThinking } from "../../shared/formatters.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";
 export const ASYNC_STATUS_SNAPSHOT_KIND = "dm-subagents.async-status-snapshot";
 export const ASYNC_STATUS_SNAPSHOT_VERSION = 1;
@@ -103,16 +104,24 @@ function appendBoundedChildren(children, source, ctx) {
   children.push(...source.slice(0, remaining));
   ctx.omitted.children += Math.max(0, source.length - remaining);
 }
+function stepIdentity(step, index, ctx) {
+  return {
+    id: publicText("workflowKey" in step && step.workflowKey ? step.workflowKey : ("runId" in step) && step.runId ? step.runId : `step:${index}`, `step:${index}`, ctx.caps.maxStringLength),
+    label: publicText("label" in step && step.label ? step.label : step.agent, "step", ctx.caps.maxStringLength)
+  };
+}
 function projectStep(step, index, depth, ctx) {
   const state = normalizeState(step.status);
   const startedAt = publicTime(step.startedAt);
-  const endedAt = publicTime(step.endedAt);
+  const durationMs = "durationMs" in step ? publicTime(step.durationMs) : undefined;
+  const endedAt = publicTime(step.endedAt) ?? (terminalState(state) && startedAt !== undefined && durationMs !== undefined ? publicTime(startedAt + durationMs) : undefined);
   const updatedAt = endedAt ?? publicTime(step.lastActivityAt) ?? startedAt;
   const activity = activityFor(step, ctx);
+  const { id, label } = stepIdentity(step, index, ctx);
   const node = {
-    id: publicText("workflowKey" in step && step.workflowKey ? step.workflowKey : ("runId" in step) && step.runId ? step.runId : `step:${index}`, `step:${index}`, ctx.caps.maxStringLength),
+    id,
     kind: "step",
-    label: publicText("label" in step && step.label ? step.label : step.agent, "step", ctx.caps.maxStringLength),
+    label,
     state,
     ...startedAt !== undefined ? { startedAt } : {},
     ...updatedAt !== undefined ? { updatedAt } : {},
@@ -130,15 +139,6 @@ function projectStep(step, index, depth, ctx) {
   }
   return node;
 }
-function projectWorkflowGraphNode(node, index, depth, ctx) {
-  const step = {
-    agent: node.agent ?? node.label,
-    status: workflowGraphStepStatus(node.status),
-    workflowKey: node.id,
-    label: node.label
-  };
-  return projectStep(step, node.flatIndex ?? index, depth, ctx);
-}
 function projectNestedRun(child, index, depth, ctx) {
   const state = normalizeState(child.state);
   const startedAt = publicTime(child.startedAt);
@@ -204,7 +204,84 @@ function projectHostStep(hostStep, ctx) {
     hostStep: hostMetadata
   };
 }
-function projectRun(job, ctx) {
+function asyncJobOrder(left, right) {
+  const leftRank = left.status === "running" ? 0 : left.status === "queued" ? 1 : 2;
+  const rightRank = right.status === "running" ? 0 : right.status === "queued" ? 1 : 2;
+  const leftTime = left.updatedAt ?? left.startedAt ?? 0;
+  const rightTime = right.updatedAt ?? right.startedAt ?? 0;
+  return leftRank - rightRank || rightTime - leftTime || left.asyncId.localeCompare(right.asyncId);
+}
+function hasCyclicWorkflowParent(job, parents) {
+  const seen = new Set([job.asyncId]);
+  let parentId = job.parentWorkflowRunId;
+  while (parentId) {
+    if (seen.has(parentId))
+      return true;
+    seen.add(parentId);
+    parentId = parents.get(parentId)?.parentWorkflowRunId;
+  }
+  return false;
+}
+function groupMaterializedChildren(jobs) {
+  const parents = new Map(jobs.filter((job) => job.mode === "workflow").map((job) => [job.asyncId, job]));
+  const childrenByParent = new Map;
+  const liveRoots = new Set;
+  const roots = [];
+  for (const job of jobs) {
+    const parent = job.parentWorkflowRunId ? parents.get(job.parentWorkflowRunId) : undefined;
+    const keepLiveRoot = (job.status === "running" || job.status === "queued") && parent?.status !== "running";
+    if (parent && !hasCyclicWorkflowParent(job, parents)) {
+      const siblings = childrenByParent.get(parent.asyncId) ?? [];
+      siblings.push(job);
+      childrenByParent.set(parent.asyncId, siblings);
+      if (keepLiveRoot) {
+        liveRoots.add(job);
+        roots.push(job);
+      }
+    } else {
+      roots.push(job);
+    }
+  }
+  for (const children of childrenByParent.values())
+    children.sort(asyncJobOrder);
+  return { roots, childrenByParent, liveRoots };
+}
+function assignMaterializedChildren(steps, children) {
+  const assigned = new Map;
+  const claimed = new Set;
+  for (const step of steps) {
+    if (!step.runId)
+      continue;
+    const child = children.find((candidate) => !claimed.has(candidate) && candidate.asyncId === step.runId);
+    if (child) {
+      assigned.set(step, child);
+      claimed.add(child);
+    }
+  }
+  for (const step of steps) {
+    if (assigned.has(step) || !step.workflowKey)
+      continue;
+    const child = children.find((candidate) => !claimed.has(candidate) && candidate.workflowKey === step.workflowKey);
+    if (child) {
+      assigned.set(step, child);
+      claimed.add(child);
+    }
+  }
+  return assigned;
+}
+function projectMaterializedStep(step, index, child, depth, ctx, childrenByParent, liveRoots) {
+  const { id, label } = stepIdentity(step, index, ctx);
+  const selfStep = child.mode === undefined || child.mode === "single" ? child.steps?.[0] : undefined;
+  const live = projectRun(child, ctx, depth, childrenByParent, liveRoots, selfStep !== undefined);
+  const laneActivity = activityFor(step, ctx);
+  const selfActivity = selfStep ? activityFor(selfStep, ctx) : undefined;
+  const activity = laneActivity || selfActivity || live.activity ? { ...laneActivity, ...selfActivity, ...live.activity } : undefined;
+  const node = { ...live, id, kind: "step", label };
+  if (activity)
+    node.activity = activity;
+  return node;
+}
+function projectRun(job, ctx, depth, childrenByParent, liveRoots, omitSteps = false) {
   const state = normalizeState(job.status);
   const startedAt = publicTime(job.startedAt);
   const updatedAt = publicTime(job.updatedAt) ?? startedAt;
@@ -219,14 +296,34 @@ function projectRun(job, ctx) {
     ...terminalState(state) && updatedAt !== undefined ? { endedAt: updatedAt } : {},
     ...activity ? { activity } : {}
   };
-  if (ctx.caps.maxDepth > 0) {
-    const stepChildren = job.steps?.map((step, index) => projectStep(step, step.index ?? index, 1, ctx)) ?? [];
-    const loadedKeys = new Set(job.steps?.flatMap((step) => step.workflowKey ? [step.workflowKey] : []) ?? []);
-    const graphStages = job.mode === "workflow" ? workflowGraphStageNodes(job.workflowGraph) : [];
-    const graphChildren = graphStages.filter((graphNode) => !loadedKeys.has(graphNode.id)).map((graphNode, index) => projectWorkflowGraphNode(graphNode, index, 1, ctx));
-    const nestedChildren = job.nestedChildren?.map((child, index) => projectNestedRun(child, index, 1, ctx)) ?? [];
+  const steps = omitSteps ? [] : job.steps ?? [];
+  const materialized = childrenByParent.get(job.asyncId) ?? [];
+  const nestedSummaries = (job.nestedChildren ?? []).filter((child) => !materialized.some((live) => live.asyncId === child.id));
+  const loadedKeys = new Set(steps.flatMap((step) => step.workflowKey ? [step.workflowKey] : []));
+  const graphStages = job.mode === "workflow" ? workflowGraphStageNodes(job.workflowGraph).filter((graphNode) => !loadedKeys.has(graphNode.id)) : [];
+  const graphSteps = graphStages.map((node, index) => ({
+    step: { agent: node.agent ?? node.label, status: workflowGraphStepStatus(node.status), workflowKey: node.id, label: node.label },
+    index: node.flatIndex ?? index
+  }));
+  const lanes = [...steps, ...graphSteps.map(({ step }) => step)];
+  const assigned = assignMaterializedChildren(lanes, materialized);
+  const claimed = new Set(assigned.values());
+  if (depth < ctx.caps.maxDepth) {
+    const childDepth = depth + 1;
+    const projectLane = (step, index) => {
+      const child = assigned.get(step);
+      if (!child)
+        return projectStep(step, index, childDepth, ctx);
+      if (liveRoots.has(child))
+        return;
+      return projectMaterializedStep(step, index, child, childDepth, ctx, childrenByParent, liveRoots);
+    };
+    const stepChildren = steps.map((step, index) => projectLane(step, step.index ?? index)).filter((child) => child !== undefined);
+    const graphChildren = graphSteps.map(({ step, index }) => projectLane(step, index)).filter((child) => child !== undefined);
+    const nestedChildren = nestedSummaries.map((child, index) => projectNestedRun(child, index, childDepth, ctx));
+    const unclaimedChildren = materialized.filter((child) => !claimed.has(child) && !liveRoots.has(child)).map((child) => projectRun(child, ctx, childDepth, childrenByParent, liveRoots));
     const hostStepChildren = validHostStepList(job.hostSteps).map((hostStep) => projectHostStep(hostStep, ctx));
-    const ordinaryChildren = [...stepChildren, ...graphChildren, ...nestedChildren];
+    const ordinaryChildren = [...stepChildren, ...graphChildren, ...nestedChildren, ...unclaimedChildren];
     const retainedHostSteps = hostStepChildren.slice(0, ctx.caps.maxChildrenPerNode);
     const retainedOrdinaryChildren = ordinaryChildren.slice(0, ctx.caps.maxChildrenPerNode - retainedHostSteps.length);
     const bounded = [];
@@ -235,10 +332,9 @@ function projectRun(job, ctx) {
     if (bounded.length)
       node.children = bounded;
   } else {
-    const loadedKeys = new Set(job.steps?.flatMap((step) => step.workflowKey ? [step.workflowKey] : []) ?? []);
-    const graphStages = job.mode === "workflow" ? workflowGraphStageNodes(job.workflowGraph) : [];
-    const graphCount = graphStages.filter((graphNode) => !loadedKeys.has(graphNode.id)).length;
-    ctx.omitted.children += (job.steps?.length ?? 0) + graphCount + (job.nestedChildren?.length ?? 0) + validHostStepList(job.hostSteps).length;
+    const rootAssignments = [...assigned.values()].filter((child) => liveRoots.has(child)).length;
+    const unclaimedChildren = materialized.filter((child) => !claimed.has(child) && !liveRoots.has(child)).length;
+    ctx.omitted.children += lanes.length - rootAssignments + nestedSummaries.length + unclaimedChildren + validHostStepList(job.hostSteps).length;
   }
   return node;
 }
@@ -353,7 +449,7 @@ export function projectAsyncWorkflowRows(steps, hostStepsOrPreflight, preflightO
   const graph = isWorkflowGraph(hostStepsOrPreflight) ? hostStepsOrPreflight : undefined;
   const hostSteps = isWorkflowPreflight(hostStepsOrPreflight) || graph ? undefined : hostStepsOrPreflight;
   const loaded = steps ?? [];
-  const declared = new Map;
+  const preflightForKey = (key, groupKeys = []) => workflowPreflightLaneForRuntimeKey(preflight, key, groupKeys);
   if (graph) {
     const loadedIndexesByKey = new Map;
     for (const [index, step] of loaded.entries()) {
@@ -365,8 +461,6 @@ export function projectAsyncWorkflowRows(steps, hostStepsOrPreflight, preflightO
     }
     const consumed = new Set;
     const childRows = [];
-    for (const lane of preflight?.lanes ?? [])
-      declared.set(lane.key, lane);
     const graphStages = workflowGraphStageNodes(graph);
     const graphKeys = new Set(graphStages.map((node) => node.id));
     const graphPhaseByNodeId = new Map;
@@ -376,64 +470,28 @@ export function projectAsyncWorkflowRows(steps, hostStepsOrPreflight, preflightO
           graphPhaseByNodeId.set(nodeId, phase.title);
       }
     }
-    const graphLaneKeys = new Set(graphPhaseByNodeId.values());
-    const preflightForNode = (node) => {
-      const phaseTitle = graphPhaseByNodeId.get(node.id);
-      return declared.get(node.id) ?? (node.phase ? declared.get(node.phase) : undefined) ?? (phaseTitle ? declared.get(phaseTitle) : undefined);
-    };
     for (const node of graphStages) {
+      const lane = preflightForKey(node.id, [node.phase, graphPhaseByNodeId.get(node.id)]);
       const indexes = (loadedIndexesByKey.get(node.id) ?? []).filter((index) => !consumed.has(index));
-      if (indexes.length > 0) {
-        for (const index of indexes) {
-          consumed.add(index);
-          childRows.push(projectLoadedWorkflowRow(loaded[index], index, preflightForNode(node)));
-        }
-      } else {
-        childRows.push(projectWorkflowGraphRow(node, preflightForNode(node)));
-      }
-    }
-    for (const lane of preflight?.lanes ?? []) {
-      if (graphKeys.has(lane.key) || graphLaneKeys.has(lane.key))
-        continue;
-      const indexes = (loadedIndexesByKey.get(lane.key) ?? []).filter((index) => !consumed.has(index));
       if (indexes.length > 0) {
         for (const index of indexes) {
           consumed.add(index);
           childRows.push(projectLoadedWorkflowRow(loaded[index], index, lane));
         }
       } else {
-        childRows.push({ name: lane.key, state: "planned", preflight: lane });
+        childRows.push(projectWorkflowGraphRow(node, lane));
       }
     }
     for (const [index, step] of loaded.entries()) {
       if (!consumed.has(index))
-        childRows.push(projectLoadedWorkflowRow(step, index, step.workflowKey ? declared.get(step.workflowKey) : undefined));
+        childRows.push(projectLoadedWorkflowRow(step, index, step.workflowKey ? preflightForKey(step.workflowKey, [step.phase]) : undefined));
     }
     return [...childRows, ...validHostStepList(graph).map(hostStepRow)];
   }
-  const loadedIndexByKey = new Map;
-  for (const [index, step] of loaded.entries()) {
-    if (step.workflowKey !== undefined && !loadedIndexByKey.has(step.workflowKey))
-      loadedIndexByKey.set(step.workflowKey, index);
-  }
-  const consumed = new Set;
-  const childRows = [];
-  for (const lane of preflight?.lanes ?? []) {
-    declared.set(lane.key, lane);
-    const index = loadedIndexByKey.get(lane.key);
-    if (index === undefined) {
-      childRows.push({ name: lane.key, state: "planned", preflight: lane });
-      continue;
-    }
-    consumed.add(index);
-    childRows.push(projectLoadedWorkflowRow(loaded[index], index, lane));
-  }
-  for (const [index, step] of loaded.entries()) {
-    if (consumed.has(index))
-      continue;
-    childRows.push(projectLoadedWorkflowRow(step, index, step.workflowKey ? declared.get(step.workflowKey) : undefined));
-  }
-  return [...childRows, ...validHostStepList(hostSteps).map(hostStepRow)];
+  return [
+    ...loaded.map((step, index) => projectLoadedWorkflowRow(step, index, step.workflowKey ? preflightForKey(step.workflowKey, [step.phase]) : undefined)),
+    ...validHostStepList(hostSteps).map(hostStepRow)
+  ];
 }
 function projectLoadedWorkflowRow(step, index, preflight) {
   const modelThinking = formatModelThinking(step.model, step.thinking) || undefined;
@@ -445,6 +503,8 @@ function projectLoadedWorkflowRow(step, index, preflight) {
     ...modelThinking ? { modelThinking } : {},
     ...activity ? { activity } : {},
     ...step.startedAt !== undefined ? { startedAt: step.startedAt } : {},
+    ...step.endedAt !== undefined ? { endedAt: step.endedAt } : {},
+    ...step.durationMs !== undefined ? { durationMs: step.durationMs } : {},
     ...step.tokens?.total !== undefined ? { tokens: step.tokens.total } : {},
     ...step.tokens?.window !== undefined ? { window: step.tokens.window } : {},
     ...preflight ? { preflight } : {}
@@ -453,11 +513,8 @@ function projectLoadedWorkflowRow(step, index, preflight) {
 export function projectAsyncStatusSnapshot(jobs, options = {}) {
   const caps = resolveCaps(options);
   const ctx = { caps, omitted: { runs: 0, children: 0, byteLimitExceeded: false } };
-  const sorted = [...jobs].sort((left, right) => {
-    const leftUpdated = left.updatedAt ?? left.startedAt ?? 0;
-    const rightUpdated = right.updatedAt ?? right.startedAt ?? 0;
-    return rightUpdated - leftUpdated || left.asyncId.localeCompare(right.asyncId);
-  });
+  const { roots, childrenByParent, liveRoots } = groupMaterializedChildren([...jobs]);
+  const sorted = roots.sort(asyncJobOrder);
   ctx.omitted.runs += Math.max(0, sorted.length - caps.maxRuns);
   const snapshot = {
     kind: ASYNC_STATUS_SNAPSHOT_KIND,
@@ -465,7 +522,7 @@ export function projectAsyncStatusSnapshot(jobs, options = {}) {
     generatedAt: options.generatedAt ?? Date.now(),
     caps,
     omitted: ctx.omitted,
-    runs: sorted.slice(0, caps.maxRuns).map((job) => projectRun(job, ctx))
+    runs: sorted.slice(0, caps.maxRuns).map((job) => projectRun(job, ctx, 0, childrenByParent, liveRoots))
   };
   enforceByteLimit(snapshot);
   return snapshot;

package/extensions/dm-subagents/src/runs/shared/capability-ceiling.js

@@ -1,7 +1,6 @@
 import { Buffer } from "node:buffer";
 export const SUBAGENT_CAPABILITY_CEILING_VERSION = 1;
 export const SUBAGENT_CAPABILITY_CEILING_REGISTRY_KEY = "dm-subagents.capability-ceiling.v1";
-export const SUBAGENT_CAPABILITY_CEILING_ENV = "DM_SUBAGENT_CAPABILITY_CEILING_V1";
 function registry() {
   const key = Symbol.for(SUBAGENT_CAPABILITY_CEILING_REGISTRY_KEY);
   const store = globalThis;
@@ -18,6 +17,9 @@ function validateText(value, field) {
   }
   return value.trim();
 }
+export function normalizeCapabilityCeilingAllowedAgents(values) {
+  return normalizeCeiling({ allowedAgents: values }).allowedAgents;
+}
 function normalizeCeiling(ceiling) {
   if (!ceiling || typeof ceiling !== "object" || Array.isArray(ceiling))
     throw new Error("Invalid capability ceiling; expected an object.");
@@ -134,7 +136,7 @@ export function resolveSubagentCapabilityCeiling(sessionId, inherited) {
   return intersectSubagentCapabilityCeilings(inherited, ...active);
 }
 export function resolveCurrentSubagentCapabilityCeiling(sessionId) {
-  return resolveSubagentCapabilityCeiling(sessionId, decodeSubagentCapabilityCeiling(process.env[SUBAGENT_CAPABILITY_CEILING_ENV]));
+  return resolveSubagentCapabilityCeiling(sessionId, undefined);
 }
 export function isAgentAllowedByCapabilityCeiling(agentName, ceiling) {
   return ceiling?.allowedAgents === undefined || ceiling.allowedAgents.includes(agentName);

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

@@ -0,0 +1,166 @@
+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 { projectRuntimeAcknowledgedExtensions } from "./runtime-acknowledged-extensions.js";
+const promptProofs = new WeakMap;
+function ownedProof(hooks) {
+  const proof = hooks[0] && promptProofs.get(hooks[0].factory);
+  return proof?.factories?.length === hooks.length && proof.factories.every((factory, index) => hooks[index]?.factory === factory) ? proof : undefined;
+}
+export function withChildSessionErrorReporting(session, transcriptWriter) {
+  const launch = { ...session, onExtensionError: (error) => {
+    transcriptWriter?.writeStderrLine(`Extension error (${error.extensionPath}, ${error.event}): ${error.error instanceof Error ? error.error.message : String(error.error)}`);
+  } };
+  const proof = ownedProof(launch.hooks);
+  if (proof?.capture && proof.config === launch.runtime)
+    proof.reporting = { launch, callback: launch.onExtensionError };
+  return launch;
+}
+export function isReadonlyChildSessionReporting(launch) {
+  const proof = ownedProof(launch.hooks);
+  const descriptor = Object.getOwnPropertyDescriptor(launch, "onExtensionError");
+  if (descriptor && (!descriptor.enumerable || !("value" in descriptor)))
+    return false;
+  return proof?.reporting ? proof.reporting.launch === launch && proof.reporting.callback === descriptor?.value : !descriptor && !("onExtensionError" in launch);
+}
+function dataKeys(value) {
+  if (!value || typeof value !== "object" || Object.getPrototypeOf(value) !== Object.prototype)
+    return;
+  const keys = Reflect.ownKeys(value);
+  for (const key of keys) {
+    const descriptor = Object.getOwnPropertyDescriptor(value, key);
+    if (typeof key !== "string" || !descriptor.enumerable || !("value" in descriptor))
+      return;
+  }
+  return keys;
+}
+function readonlyConfig(config, capture) {
+  const strings = ["runId", "agent", "sessionName", "forkCacheKey", "parentSessionId", "orchestratorSessionId"];
+  const numbers = ["childIndex", "depth", "maxDepth"];
+  const booleans = ["inheritProjectContext", "inheritGlobalContext", "inheritSkills"];
+  const keys = dataKeys(config);
+  if (!keys)
+    return;
+  if (capture && (config.toolDiagnostic !== capture.toolDiagnostic || config.runtimeAcknowledgements !== capture.runtimeAcknowledgements))
+    return;
+  const waitKeys = dataKeys(config.waitTool);
+  if (!waitKeys || waitKeys.some((key) => key !== "enabled"))
+    return;
+  if (config.fast !== false || config.fanoutChild !== false || config.waitTool.enabled !== false)
+    return;
+  for (const key of keys) {
+    const value = Object.getOwnPropertyDescriptor(config, key).value;
+    if (["fast", "fanoutChild", "waitTool"].includes(key))
+      continue;
+    if (capture && (key === "toolDiagnostic" || key === "runtimeAcknowledgements"))
+      continue;
+    if (capture && key === "requiredTools" && Array.isArray(value) && Object.getPrototypeOf(value) === Array.prototype) {
+      const descriptors = Object.getOwnPropertyDescriptors(value);
+      if (Reflect.ownKeys(descriptors).length !== value.length + 1)
+        return;
+      for (let i = 0;i < value.length; i++) {
+        const descriptor = descriptors[String(i)];
+        if (!descriptor?.enumerable || !("value" in descriptor) || !["read", "ls"].includes(descriptor.value))
+          return;
+      }
+      continue;
+    }
+    if (strings.includes(key) && (value === undefined || typeof value === "string"))
+      continue;
+    if (numbers.includes(key) && (value === undefined || typeof value === "number" && Number.isInteger(value) && value >= 0))
+      continue;
+    if (booleans.includes(key) && (value === undefined || typeof value === "boolean"))
+      continue;
+    return;
+  }
+  return JSON.stringify(config);
+}
+function noBackgroundProviders() {
+  try {
+    return listBackgroundWorkProviders().length === 0;
+  } catch {
+    return false;
+  }
+}
+export function isReadonlyChildHookProfile(hooks, config) {
+  const proof = ownedProof(hooks);
+  if (!proof)
+    return false;
+  const valid = proof.config === config && readonlyConfig(config, proof.capture) === proof.snapshot && noBackgroundProviders();
+  if (!valid)
+    proof.observation?.deny();
+  return valid && (proof.observation?.check() ?? true);
+}
+export function observeReadonlyChildHookDrain(hooks, enabled, sessionFile) {
+  const proof = ownedProof(hooks);
+  if (!proof)
+    return;
+  if (enabled) {
+    proof.observation?.deny();
+    proof.observation = undefined;
+  }
+  proof.observeNext = enabled ? new ReadonlyDrainObservation(sessionFile, () => readonlyConfig(proof.config, proof.capture) === proof.snapshot && noBackgroundProviders()) : undefined;
+}
+export function captureReadonlyChildDrain(hooks) {
+  const proof = ownedProof(hooks);
+  const observation = proof?.observation;
+  return () => !!observation && proof?.observation === observation && observation.settled();
+}
+export function createChildHooks(config) {
+  return childHooks(config);
+}
+export function createCapturedChildHooks(config) {
+  let diagnostic;
+  let acknowledgedIds;
+  let finalDrainHeld = false;
+  const capture = {
+    toolDiagnostic: (value) => {
+      diagnostic = value;
+    },
+    runtimeAcknowledgements: (ids) => {
+      acknowledgedIds = ids;
+    }
+  };
+  Object.assign(config, capture);
+  const hooks = childHooks(config, capture, (held) => {
+    finalDrainHeld = held;
+  });
+  return {
+    hooks,
+    toolDiagnostic: () => diagnostic,
+    runtimeAcknowledgedExtensions: () => acknowledgedIds ? projectRuntimeAcknowledgedExtensions(acknowledgedIds) : undefined,
+    finalDrainHeld: () => finalDrainHeld
+  };
+}
+function childHooks(config, capture, holdFinalDrain) {
+  const snapshot = readonlyConfig(config, capture);
+  const proof = snapshot === undefined ? undefined : { config, snapshot, capture };
+  const runtime = Object.create(config);
+  const ownedState = Object.getOwnPropertyDescriptor(config, "runtimeState");
+  if (!ownedState || !("value" in ownedState) || ownedState.value == null) {
+    Object.defineProperty(runtime, "runtimeState", { configurable: true, enumerable: true, writable: true, value: createChildSafeState() });
+  }
+  if (holdFinalDrain) {
+    Object.defineProperty(runtime, "holdFinalDrain", { configurable: true, enumerable: true, writable: true, value: holdFinalDrain });
+  }
+  const hooks = [
+    { name: "dm-subagents:prompt-runtime", factory: function promptRuntime(dm) {
+      if (!proof?.observeNext)
+        return registerSubagentPromptRuntime(dm, runtime);
+      proof.observation = proof.observeNext;
+      proof.observeNext = undefined;
+      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) });
+  return hooks;
+}

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

@@ -1,8 +1,8 @@
 export function asyncStatusChildIdentity(step, index) {
-  return step.workflowKey ?? step.runId ?? `step:${index}`;
+  return asyncStatusChildIdentityCandidates(step, index)[0];
 }
 export function asyncStatusChildIdentityCandidates(step, index) {
-  return [...new Set([step.workflowKey, step.runId, `step:${index}`].filter((value) => typeof value === "string" && value.length > 0))];
+  return [...new Set([step.childId, step.workflowKey, step.runId, `step:${index}`].filter((value) => typeof value === "string" && value.length > 0))];
 }
 export function resolveAsyncStatusChild(status, childId, options = {}) {
   const matches = [];
@@ -30,3 +30,11 @@ export function resolveAsyncStatusChild(status, childId, options = {}) {
 export function isStoppableAsyncStatusStep(step) {
   return step.status === "pending" || step.status === "running";
 }
+export function stopStoppableAsyncStatusChildren(status, stopChild, message) {
+  if (!stopChild)
+    return;
+  for (const [index, step] of (status.steps ?? []).entries()) {
+    if (isStoppableAsyncStatusStep(step))
+      stopChild(asyncStatusChildIdentity(step, index), message);
+  }
+}

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

@@ -8,6 +8,22 @@ export function normalizeOutputOverride(output) {
     return;
   return typeof output === "string" && output.length > 0 ? output : undefined;
 }
+export const resolveEffectiveOutputSchema = (agentConfig, override) => override === false ? undefined : override !== undefined ? override : agentConfig.outputSchema;
+export function projectChainOutputSchemas(chain, agents, projectStep, projectGroup) {
+  const project = (step) => {
+    const agent = agents.find((candidate) => candidate.name === step.agent);
+    if (!agent && !projectStep)
+      return step;
+    const outputSchema = agent && resolveEffectiveOutputSchema(agent, step.outputSchema);
+    return projectStep ? projectStep(step, outputSchema) : { ...step, outputSchema };
+  };
+  return chain.map((step) => {
+    if (!("parallel" in step))
+      return project(step);
+    const parallel = Array.isArray(step.parallel) ? step.parallel.map(project) : project(step.parallel);
+    return projectGroup ? projectGroup(step, parallel) : { ...step, parallel };
+  });
+}
 export function resolveStepBehavior(agentConfig, stepOverrides, chainSkills) {
   const stepOutput = normalizeOutputOverride(stepOverrides.output);
   const output = stepOutput !== undefined ? stepOutput : normalizeOutputOverride(agentConfig.output) ?? false;
@@ -30,7 +46,8 @@ export function resolveStepBehavior(agentConfig, stepOverrides, chainSkills) {
   const outputMode = stepOverrides.outputMode ?? agentConfig.outputMode ?? "inline";
   const model = stepOverrides.model ?? agentConfig.model;
   const fast = stepOverrides.fast ?? agentConfig.fast;
-  return { output, outputMode, reads, progress, skills, model, fast };
+  const outputSchema = resolveEffectiveOutputSchema(agentConfig, stepOverrides.outputSchema);
+  return { output, outputMode, reads, progress, skills, model, fast, ...outputSchema !== undefined ? { outputSchema } : {} };
 }
 export function resolveTaskTextForFileUpdatePolicy(task, originalTask) {
   if (!task)
@@ -47,7 +64,7 @@ export function suppressProgressForReadOnlyTask(behavior, task, originalTask) {
   return behavior.progress && taskDisallowsFileUpdates(policyTask) ? { ...behavior, progress: false } : behavior;
 }
 export function planChildLaunch(input) {
-  const stepCwd = resolveChildCwd(input.runnerCwd, input.stepCwdInput);
+  const stepCwd = input.machineCwd ?? resolveChildCwd(input.runnerCwd, input.stepCwdInput);
   const instructionCwd = input.behaviorCwd ?? stepCwd;
   const readExistenceCwd = input.behaviorCwd ? stepCwd : instructionCwd;
   let behavior = suppressProgressForReadOnlyTask(input.resolvedBehavior ?? resolveStepBehavior(input.agentConfig, input.stepOverrides, input.chainSkills), input.task, input.originalTask);