@duckmind/dm-linux-x64 0.65.5 → 0.65.7

package/extensions/dm-subagents/src/workflows/workflow-checklist.js

@@ -0,0 +1,303 @@
+import { sanitizeDisplayText } from "../shared/display-text.js";
+import { workflowPreflightLaneForRuntimeKey as laneFor } from "./workflow-preflight.js";
+const MAX_TEXT = 160;
+const TERMINAL_STATES = new Set(["complete", "blocked", "failed", "paused", "stopped"]);
+function text(value, fallback) {
+  if (typeof value !== "string")
+    return fallback;
+  const clean = sanitizeDisplayText(value).replace(/\s+/g, " ").trim();
+  return clean ? clean.slice(0, MAX_TEXT) : fallback;
+}
+function keyText(value, fallback) {
+  return text(value, fallback) ?? fallback;
+}
+function normalizedStatus(value) {
+  return typeof value === "string" ? value.toLowerCase() : "queued";
+}
+function finite(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : undefined;
+}
+function count(value) {
+  const number = finite(value);
+  return number !== undefined && number >= 0 ? Math.round(number) : undefined;
+}
+function explicitBlocked(source) {
+  const acceptance = normalizedStatus(source.acceptance?.status);
+  const review = normalizedStatus(source.review?.status ?? source.acceptance?.reviewResult?.status);
+  return source.toolBudgetBlocked === true || source.turnBudgetExceeded === true || source.activityState === "needs_attention" || source.timedOut === true || source.watchdog?.phase === "stale" || source.stale === true || source.verdict === "inconclusive" || acceptance === "rejected" || acceptance === "blockers" || review === "blockers" || review === "review-required";
+}
+function checklistState(source) {
+  if (explicitBlocked(source))
+    return "blocked";
+  switch (normalizedStatus(source.status)) {
+    case "complete":
+    case "completed":
+    case "done":
+    case "pass":
+    case "accepted":
+      return "complete";
+    case "running":
+    case "started":
+    case "active":
+      return "running";
+    case "failed":
+    case "error":
+    case "fail":
+      return "failed";
+    case "blocked":
+    case "rejected":
+    case "partial":
+    case "needs_attention":
+      return "blocked";
+    case "paused":
+    case "detached":
+      return "paused";
+    case "stopped":
+    case "cancelled":
+    case "canceled":
+      return "stopped";
+    default:
+      return "queued";
+  }
+}
+function duration(step, now, state) {
+  const explicit = finite(step.durationMs);
+  const startedAt = finite(step.startedAt);
+  if (explicit !== undefined)
+    return Math.max(0, explicit);
+  if (startedAt === undefined)
+    return;
+  const end = state === "running" ? now : finite(step.endedAt);
+  return end === undefined ? undefined : Math.max(0, end - startedAt);
+}
+function stepKey(step) {
+  return step.key ?? step.workflowKey ?? step.runId;
+}
+function stepItem(step, index, phase, key = stepKey(step) ?? `step-${index + 1}`, label = step.label ?? step.description ?? stepKey(step) ?? step.agent ?? key, preflight) {
+  const state = checklistState(step);
+  return {
+    key: keyText(key, `step-${index + 1}`),
+    label: keyText(label, key),
+    phase,
+    state,
+    ...text(step.agent) ? { agent: text(step.agent) } : {},
+    ...step.context ? { context: step.context } : {},
+    ...finite(step.startedAt) !== undefined ? { startedAt: finite(step.startedAt) } : {},
+    ...duration(step, undefined, state) !== undefined ? { durationMs: duration(step, undefined, state) } : {},
+    ...text(step.currentTool) ? { currentTool: text(step.currentTool) } : {},
+    ...finite(step.currentToolStartedAt) !== undefined ? { currentToolStartedAt: finite(step.currentToolStartedAt) } : {},
+    ...text(step.currentPath) ? { currentPath: text(step.currentPath) } : {},
+    ...count(step.toolCount) !== undefined ? { toolCount: count(step.toolCount) } : {},
+    ...text(step.outputName) ? { outputName: text(step.outputName) } : {},
+    ...text(step.error) ? { error: text(step.error) } : {},
+    ...preflight ? { preflight } : {}
+  };
+}
+function hostItem(host, phase, key = host.id) {
+  const state = checklistState({ status: host.state, verdict: host.verdict, stale: host.freshness?.stale });
+  return {
+    key: keyText(key, "host-step"),
+    label: keyText(host.label, "host step"),
+    phase,
+    state,
+    kind: "host",
+    monitorKind: host.monitorKind,
+    ...text(host.provider) ? { provider: text(host.provider) } : {},
+    ...text(host.role) ? { role: text(host.role) } : {},
+    ...host.verdict ? { verdict: host.verdict } : {},
+    ...text(host.target) ? { target: text(host.target) } : {},
+    ...text(host.reasonCode) ? { reasonCode: text(host.reasonCode) } : {},
+    ...text(host.detail) ? { error: text(host.detail) } : {},
+    ...host.freshness?.stale !== undefined ? { stale: host.freshness.stale } : {},
+    ...text(host.reportPath) ? { reportPath: text(host.reportPath) } : {}
+  };
+}
+function graphNodes(graph) {
+  const out = [];
+  const visit = (node) => {
+    if (node.kind === "parallel-group" || node.kind === "dynamic-parallel-group") {
+      for (const child of node.children ?? [])
+        visit(child);
+      if (!node.children?.length)
+        out.push(node);
+    } else {
+      out.push(node);
+    }
+  };
+  for (const node of graph?.nodes ?? [])
+    visit(node);
+  return out;
+}
+function traceSources(trace) {
+  const latest = new Map;
+  for (const entry of trace ?? []) {
+    const state = normalizedStatus(entry.state);
+    if (entry.operation !== undefined && entry.operation !== "run" && entry.operation !== "host" || !entry.key || state === "delivered" || state === "missed")
+      continue;
+    const existing = latest.get(entry.key);
+    latest.set(entry.key, state === "reused" && existing ? { ...existing, ...entry, state: existing.state } : { ...existing, ...entry });
+  }
+  return [...latest.values()];
+}
+function traceItem(entry, index, preflight) {
+  const phase = keyText(preflight?.key ?? entry.generatedLaneKey ?? entry.phase, "Workflow");
+  const item = stepItem({ key: entry.key, label: entry.label, phase, agent: entry.agent, status: entry.state === "started" ? "running" : entry.state, durationMs: entry.durationMs, error: entry.error }, index, phase, entry.key, entry.label ?? entry.key, preflight);
+  if (entry.operation === "host")
+    item.kind = "host";
+  return item;
+}
+function phaseFor(phases, label) {
+  let phase = phases.get(label);
+  if (!phase) {
+    phase = { key: label, label, state: "queued", items: [], total: 0, done: 0, running: 0, queued: 0, blocked: 0, failed: 0, paused: 0, stopped: 0, parallel: false };
+    phases.set(label, phase);
+  }
+  return phase;
+}
+function add(phases, phase, item) {
+  phaseFor(phases, phase).items.push(item);
+}
+function mergeNodeStep(node, step, phase, trace, preflight) {
+  const state = checklistState(step);
+  const nodeState = checklistState({ status: node.status, acceptance: node.acceptanceStatus ? { status: node.acceptanceStatus } : undefined });
+  const status = TERMINAL_STATES.has(nodeState) && !TERMINAL_STATES.has(state) ? nodeState : trace && !TERMINAL_STATES.has(state) ? trace.state === "started" ? "running" : trace.state : normalizedStatus(step.status) === "pending" && normalizedStatus(node.status) !== "pending" ? node.status : step.status;
+  return stepItem({ ...step, status, key: node.id, label: step.label ?? node.label, phase: step.phase ?? phase, agent: step.agent ?? node.agent, outputName: step.outputName ?? node.outputName, error: step.error ?? trace?.error ?? node.error, acceptance: step.acceptance ?? (node.acceptanceStatus ? { status: node.acceptanceStatus } : undefined), durationMs: step.durationMs ?? trace?.durationMs }, node.flatIndex ?? 0, phase, node.id, step.label ?? node.label, preflight);
+}
+function priority(item) {
+  return item.state === "blocked" ? 0 : item.state === "failed" ? 1 : item.state === "running" ? 2 : item.state === "paused" ? 3 : item.state === "stopped" ? 4 : item.state === "queued" ? 5 : 6;
+}
+function applyNow(item, now) {
+  return item.state === "running" && item.startedAt !== undefined && now !== undefined ? { ...item, durationMs: Math.max(0, now - item.startedAt) } : item;
+}
+function finalize(phase) {
+  phase.total = phase.items.length;
+  phase.done = phase.items.filter((item) => item.state === "complete").length;
+  phase.running = phase.items.filter((item) => item.state === "running").length;
+  phase.queued = phase.items.filter((item) => item.state === "queued").length;
+  phase.blocked = phase.items.filter((item) => item.state === "blocked").length;
+  phase.failed = phase.items.filter((item) => item.state === "failed").length;
+  phase.paused = phase.items.filter((item) => item.state === "paused").length;
+  phase.stopped = phase.items.filter((item) => item.state === "stopped").length;
+  phase.parallel = phase.total > 1;
+  phase.state = phase.blocked ? "blocked" : phase.failed ? "failed" : phase.running ? "running" : phase.paused ? "paused" : phase.stopped ? "stopped" : phase.queued ? "queued" : "complete";
+}
+export function projectWorkflowChecklist(input) {
+  const phases = new Map;
+  const steps = input.steps ?? [];
+  const nodes = graphNodes(input.graph);
+  const trace = traceSources(input.trace);
+  const traceByKey = new Map(trace.map((entry) => [entry.key, entry]));
+  const phaseByNode = new Map;
+  for (const phase of input.graph?.phases ?? []) {
+    const title = keyText(phase.title, "Workflow");
+    phaseFor(phases, title);
+    for (const nodeId of phase.nodeIds)
+      if (!phaseByNode.has(nodeId))
+        phaseByNode.set(nodeId, title);
+  }
+  const stepsByKey = new Map;
+  for (const [index, step] of steps.entries()) {
+    const key = stepKey(step);
+    if (!key)
+      continue;
+    stepsByKey.set(key, [...stepsByKey.get(key) ?? [], { step, index }]);
+  }
+  const usedSteps = new Set;
+  const hostById = new Map((input.hostSteps ?? []).map((host) => [host.id, host]));
+  const graphKeys = new Set(nodes.map((node) => node.id));
+  const stepKeys = new Set([...stepsByKey.keys()]);
+  const hostKeys = new Set(hostById.keys());
+  for (const node of nodes) {
+    const host = node.hostStep ?? hostById.get(node.id);
+    const phase = keyText(phaseByNode.get(node.id) ?? node.phase ?? (host ? host.label : node.label), "Workflow");
+    if (host) {
+      add(phases, phase, hostItem(host, phase, node.id));
+      hostById.delete(node.id);
+      continue;
+    }
+    const matches = (stepsByKey.get(node.id) ?? []).filter(({ index }) => !usedSteps.has(index));
+    if (matches.length) {
+      for (const match of matches) {
+        usedSteps.add(match.index);
+        add(phases, phase, applyNow(mergeNodeStep(node, match.step, phase, traceByKey.get(stepKey(match.step) ?? node.id), laneFor(input.preflight, node.id, [phase])), input.now));
+      }
+      continue;
+    }
+    add(phases, phase, applyNow(mergeNodeStep(node, { key: node.id, label: node.label, phase, agent: node.agent, status: node.status, outputName: node.outputName, error: node.error, acceptance: node.acceptanceStatus ? { status: node.acceptanceStatus } : undefined }, phase, traceByKey.get(node.id), laneFor(input.preflight, node.id, [phase])), input.now));
+  }
+  for (const [index, step] of steps.entries()) {
+    if (usedSteps.has(index))
+      continue;
+    const key = keyText(stepKey(step), `step-${index + 1}`);
+    const traceEntry = traceByKey.get(key);
+    const lane = laneFor(input.preflight, key, [step.phase, traceEntry?.generatedLaneKey, traceEntry?.phase]);
+    const phase = keyText(lane?.key ?? step.phase ?? traceEntry?.generatedLaneKey ?? traceEntry?.phase, "Workflow");
+    add(phases, phase, applyNow(stepItem(step, index, phase, key, step.label ?? step.key ?? step.agent, lane), input.now));
+  }
+  for (const host of hostById.values())
+    add(phases, keyText(host.label, "Host"), hostItem(host, keyText(host.label, "Host")));
+  for (const entry of trace) {
+    if (graphKeys.has(entry.key) || stepKeys.has(entry.key) || hostKeys.has(entry.key))
+      continue;
+    const item = traceItem(entry, phases.size, laneFor(input.preflight, entry.key, [entry.generatedLaneKey, entry.phase]));
+    add(phases, item.phase, item);
+  }
+  const finalized = [...phases.values()].filter((phase) => phase.items.length > 0);
+  for (const phase of finalized) {
+    phase.items = phase.items.map((item) => applyNow(item, input.now));
+    finalize(phase);
+  }
+  const all = finalized.flatMap((phase) => phase.items);
+  const counts = (state) => all.filter((item) => item.state === state).length;
+  const bottleneck = [...all].sort((left, right) => priority(left) - priority(right))[0];
+  return { phases: finalized, total: all.length, done: counts("complete"), running: counts("running"), queued: counts("queued"), blocked: counts("blocked"), failed: counts("failed"), paused: counts("paused"), stopped: counts("stopped"), ...bottleneck && bottleneck.state !== "complete" ? { bottleneck } : {} };
+}
+function stateLabel(state) {
+  return state === "running" ? "active" : state;
+}
+export function formatWorkflowChecklistSummary(projection) {
+  if (!projection.total)
+    return "";
+  return [`${projection.done}/${projection.total} done`, projection.running ? `${projection.running} active` : undefined, projection.queued ? `${projection.queued} queued` : undefined, projection.blocked ? `${projection.blocked} blocked` : undefined, projection.failed ? `${projection.failed} failed` : undefined, projection.paused ? `${projection.paused} paused` : undefined, projection.stopped ? `${projection.stopped} stopped` : undefined].filter((value) => Boolean(value)).join(" · ");
+}
+export function formatWorkflowChecklistPhase(phase) {
+  const counts = [phase.total > 1 && phase.done ? `${phase.done} done` : undefined, phase.running ? `${phase.running} active` : undefined, phase.queued ? `${phase.queued} queued` : undefined, phase.blocked ? `${phase.blocked} blocked` : undefined, phase.failed ? `${phase.failed} failed` : undefined, phase.paused ? `${phase.paused} paused` : undefined, phase.stopped ? `${phase.stopped} stopped` : undefined].filter((value) => Boolean(value));
+  return counts.length ? `${phase.label} ${counts.join(" · ")}` : phase.label;
+}
+export function formatWorkflowChecklistBottleneck(item, options = {}) {
+  if (!item)
+    return;
+  const identity = [item.label, item.agent && item.agent !== item.label ? item.agent : undefined].filter((value) => Boolean(value)).join(" · ") || item.key;
+  const includeOutput = options.includeOutput ?? true;
+  const includeError = options.includeError ?? true;
+  const details = [item.context ? `(${item.context})` : undefined, item.currentTool ? `${item.currentTool}${item.durationMs !== undefined ? ` ${formatDurationText(item.durationMs)}` : ""}` : undefined, !item.currentTool && item.currentPath ? item.currentPath : undefined, !item.currentTool && item.durationMs !== undefined ? formatDurationText(item.durationMs) : undefined, item.toolCount !== undefined ? `${item.toolCount} tools` : undefined, includeOutput && item.outputName ? `out:${item.outputName}` : undefined, includeError && item.error ? `error:${item.error.replace(/\bOutput:/g, "output:")}` : undefined].filter((value) => Boolean(value));
+  return [identity, ...details].join(" · ");
+}
+function formatWorkflowChecklistItem(item) {
+  const identity = [item.label, item.agent && item.agent !== item.label ? item.agent : undefined].filter((value) => Boolean(value)).join(" · ") || item.key;
+  const details = [item.kind && item.monitorKind ? item.monitorKind : undefined, item.provider ? `provider:${item.provider}` : undefined, item.role ? `role:${item.role}` : undefined, item.target, item.currentTool, !item.currentTool && item.currentPath ? item.currentPath : undefined, item.durationMs !== undefined ? formatDurationText(item.durationMs) : undefined, item.toolCount !== undefined ? `${item.toolCount} tools` : undefined, item.outputName ? `out:${item.outputName}` : undefined, item.reportPath ? `out:${item.reportPath}` : undefined, item.stale ? "stale" : undefined, item.reasonCode ? `reason:${item.reasonCode}` : undefined, item.error ? `error:${item.error.replace(/\bOutput:/g, "output:")}` : undefined].filter((value) => Boolean(value));
+  return `${identity}${item.context ? ` (${item.context})` : ""}${item.state === "complete" ? "" : ` · ${stateLabel(item.state)}`}${details.length ? ` · ${details.join(" · ")}` : ""}`;
+}
+function formatDurationText(ms) {
+  const seconds = Math.max(0, Math.round(ms / 1000));
+  return seconds < 60 ? `${seconds}s` : `${Math.floor(seconds / 60)}m ${seconds % 60}s`;
+}
+export function formatWorkflowChecklistText(projection, indent = "", options = {}) {
+  if (!projection.total)
+    return [];
+  const lines = [`${indent}Workflow checklist: ${formatWorkflowChecklistSummary(projection)}`];
+  for (const phase of projection.phases) {
+    const phaseMarker = phase.state === "complete" ? "✓" : phase.state === "running" ? "⠼" : phase.state === "blocked" ? "!" : phase.state === "failed" ? "✗" : phase.state === "paused" || phase.state === "stopped" ? "■" : "◦";
+    lines.push(`${indent}  ${phaseMarker} ${formatWorkflowChecklistPhase(phase)}`);
+    if (options.includeItems === false)
+      continue;
+    for (const item of phase.items) {
+      const marker = item.state === "complete" ? "✓" : item.state === "running" ? "⠼" : item.state === "blocked" ? "!" : item.state === "failed" ? "✗" : item.state === "paused" || item.state === "stopped" ? "■" : "◦";
+      lines.push(`${indent}    ${marker} ${formatWorkflowChecklistItem(item)}`);
+    }
+  }
+  const bottleneck = formatWorkflowChecklistBottleneck(projection.bottleneck, { includeError: options.includeItems === false });
+  if (bottleneck)
+    lines.push(`${indent}  bottleneck · ${bottleneck}`);
+  return lines;
+}

package/extensions/dm-subagents/src/workflows/workflow-child-summary.js

@@ -1,6 +1,39 @@
 const KEY_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/;
 const TERMINAL_STATES = new Set(["completed", "failed", "paused", "stopped", "rejected", "detached"]);
 const MAX_REQUIRED_ID_BYTES = 4096;
+const ACTIVITY_COUNTERS = ["currentToolStartedAt", "lastActivityAt", "durationMs", "toolCount", "turnCount", "tokens", "inputTokens", "outputTokens"];
+export function workflowChildProgress(progress) {
+  return {
+    ...workflowChildActivity(progress),
+    agent: bounded(progress.agent, 256) ?? "",
+    ...bounded(progress.sessionName, 256) ? { sessionName: progress.sessionName } : {},
+    ...bounded(progress.model, 256) ? { model: progress.model } : {},
+    ...bounded(progress.thinking, 32) ? { thinking: progress.thinking } : {}
+  };
+}
+export function workflowChildActivity(progress) {
+  const activity = {};
+  if (bounded(progress.currentTool, 256))
+    activity.currentTool = progress.currentTool;
+  for (const field of ACTIVITY_COUNTERS) {
+    const value = progress[field];
+    if (typeof value === "number" && Number.isFinite(value) && value >= 0)
+      activity[field] = value;
+  }
+  return activity;
+}
+function parseActivity(value) {
+  if (value === undefined)
+    return;
+  if (!value || typeof value !== "object" || Array.isArray(value))
+    throw new Error("workflowChildren child activity is invalid.");
+  const input = value;
+  for (const [key, value] of Object.entries(input)) {
+    if (key === "currentTool" ? !bounded(value, 256) : !ACTIVITY_COUNTERS.includes(key) || typeof value !== "number" || !Number.isFinite(value) || value < 0)
+      throw new Error("workflowChildren child activity is invalid.");
+  }
+  return { ...input };
+}
 function bounded(value, maxBytes) {
   if (typeof value !== "string" || !value.trim() || Buffer.byteLength(value, "utf8") > maxBytes)
     return;
@@ -14,6 +47,7 @@ function requiredId(value, label) {
 }
 export function workflowChildSummary(input) {
   const rows = new Map;
+  const runningAsyncKeys = new Set(input.children?.filter((child) => child.state === "running").map((child) => child.key));
   for (const entry of input.trace ?? []) {
     if (entry.operation !== "run" || !KEY_PATTERN.test(entry.key))
       continue;
@@ -33,6 +67,8 @@ export function workflowChildSummary(input) {
     const key = step.workflowKey;
     if (!key || !KEY_PATTERN.test(key))
       continue;
+    if (step.async && step.runId && step.status === "running")
+      runningAsyncKeys.add(key);
     const state = step.status === "complete" || step.status === "completed" ? "completed" : step.status === "failed" ? "failed" : step.status === "paused" ? "paused" : step.status === "stopped" ? "stopped" : step.status === "rejected" ? "rejected" : step.status === "pending" ? "pending" : "running";
     const launchResolved = step.async !== undefined || step.sessionFile !== undefined || step.runId !== undefined || step.model !== undefined;
     rows.set(key, {
@@ -49,7 +85,7 @@ export function workflowChildSummary(input) {
     if (!KEY_PATTERN.test(child.key))
       continue;
     const result = Array.isArray(child.results) ? child.results.find((value) => value && typeof value === "object") : undefined;
-    const state = child.detached ? "detached" : child.stopped ? "stopped" : child.interrupted ? "paused" : child.ok ? "completed" : result?.acceptance && typeof result.acceptance === "object" && result.acceptance.status === "rejected" ? "rejected" : "failed";
+    const state = child.state === "running" ? "running" : child.detached ? "detached" : child.stopped ? "stopped" : child.interrupted ? "paused" : child.ok ? "completed" : result?.acceptance && typeof result.acceptance === "object" && result.acceptance.status === "rejected" ? "rejected" : "failed";
     rows.set(child.key, {
       childId: child.key,
       state,
@@ -62,10 +98,23 @@ export function workflowChildSummary(input) {
   }
   if (input.inventoryComplete) {
     for (const [key, row] of rows) {
-      if (!TERMINAL_STATES.has(row.state))
+      if (!TERMINAL_STATES.has(row.state) && !runningAsyncKeys.has(key))
         rows.set(key, { ...row, state: input.workflowState === "stopped" ? "stopped" : "failed" });
     }
   }
+  for (const [key, progress] of input.progress ?? []) {
+    const row = rows.get(key);
+    if (!row || row.state !== "running")
+      continue;
+    rows.set(key, {
+      ...row,
+      ...bounded(progress.agent, 256) ? { agent: progress.agent } : {},
+      ...bounded(progress.sessionName, 256) ? { sessionName: progress.sessionName } : {},
+      ...bounded(progress.model, 256) ? { model: progress.model } : {},
+      ...bounded(progress.thinking, 32) ? { thinking: progress.thinking } : {},
+      activity: workflowChildActivity(progress)
+    });
+  }
   return {
     version: 1,
     parentToolCallId: requiredId(input.parentToolCallId, "parentToolCallId"),
@@ -93,7 +142,7 @@ export function parseWorkflowChildSummary(value) {
     if (!row || typeof row !== "object" || Array.isArray(row))
       throw new Error("workflowChildren child row is invalid.");
     const child = row;
-    if (Object.keys(child).some((key) => !["childId", "runId", "agent", "sessionName", "model", "thinking", "state"].includes(key)))
+    if (Object.keys(child).some((key) => !["childId", "runId", "agent", "sessionName", "model", "thinking", "state", "activity"].includes(key)))
       throw new Error("workflowChildren child row has unsupported fields.");
     if (typeof child.childId !== "string" || !KEY_PATTERN.test(child.childId))
       throw new Error("workflowChildren childId is invalid.");
@@ -104,7 +153,10 @@ export function parseWorkflowChildSummary(value) {
       if (child[field] !== undefined && bounded(child[field], maxBytes) === undefined)
         throw new Error(`workflowChildren child ${field} is invalid.`);
     }
-    return { childId: child.childId, state, ...child.runId ? { runId: child.runId } : {}, ...child.agent ? { agent: child.agent } : {}, ...child.sessionName ? { sessionName: child.sessionName } : {}, ...child.model ? { model: child.model } : {}, ...child.thinking ? { thinking: child.thinking } : {} };
+    const activity = parseActivity(child.activity);
+    if (activity && state !== "running")
+      throw new Error("workflowChildren child activity requires running state.");
+    return { childId: child.childId, state, ...activity ? { activity } : {}, ...child.runId ? { runId: child.runId } : {}, ...child.agent ? { agent: child.agent } : {}, ...child.sessionName ? { sessionName: child.sessionName } : {}, ...child.model ? { model: child.model } : {}, ...child.thinking ? { thinking: child.thinking } : {} };
   });
   if (new Set(children.map((child) => child.childId)).size !== children.length)
     throw new Error("workflowChildren has duplicate childId values.");
@@ -112,5 +164,5 @@ export function parseWorkflowChildSummary(value) {
     throw new Error("workflowChildren.parentToolCallId is invalid.");
   if (typeof input.workflowRunId !== "string")
     throw new Error("workflowChildren.workflowRunId is invalid.");
-  return { version: 1, parentToolCallId: requiredId(input.parentToolCallId, "parentToolCallId"), workflowRunId: requiredId(input.workflowRunId, "workflowRunId"), inventoryComplete: input.inventoryComplete, workflowState, children };
+  return { version: 1, parentToolCallId: requiredId(input.parentToolCallId, "workflowChildren.parentToolCallId"), workflowRunId: requiredId(input.workflowRunId, "workflowChildren.workflowRunId"), inventoryComplete: input.inventoryComplete, workflowState, children };
 }

package/extensions/dm-subagents/src/workflows/workflow-preflight.js

@@ -128,8 +128,34 @@ function warningLimit(messages) {
 function declaredKeys(preflight) {
   return new Set(preflight.lanes.map((lane) => lane.key));
 }
+export function workflowKeyMatchesPreflightLane(key, laneKey, generatedLaneKey) {
+  return generatedLaneKey === laneKey || key === laneKey || key.startsWith(`${laneKey}.`);
+}
+export function workflowPreflightLaneForRuntimeKey(preflight, key, preferredKeys = []) {
+  const lanes = preflight?.lanes;
+  if (!lanes)
+    return;
+  const exact = lanes.find((lane) => lane.key === key);
+  if (exact)
+    return exact;
+  let closestRoot;
+  for (const lane of lanes) {
+    if (key.startsWith(`${lane.key}.`) && (!closestRoot || lane.key.length > closestRoot.key.length))
+      closestRoot = lane;
+  }
+  if (closestRoot)
+    return closestRoot;
+  for (const preferredKey of preferredKeys) {
+    if (!preferredKey)
+      continue;
+    const preferred = lanes.find((lane) => lane.key === preferredKey);
+    if (preferred)
+      return preferred;
+  }
+  return;
+}
 function declaredLaneCoversWorkflowKey(entry, laneKey) {
-  return entry.key === laneKey || entry.key.startsWith(`${laneKey}.`);
+  return workflowKeyMatchesPreflightLane(entry.key, laneKey, entry.generatedLaneKey);
 }
 function keyCoveredByDeclaredLane(entry, declared) {
   for (const laneKey of declared)

package/extensions/dm-subagents/src/workflows/workflow-receipt.js

@@ -8,6 +8,7 @@ export const WORKFLOW_RECEIPT_VERSION = 1;
 export const WORKFLOW_RECEIPT_FILE = "workflow-receipt.json";
 const MAX_WORKFLOW_RECEIPT_BYTES = 2 * 1024 * 1024;
 const KEY_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/;
+const RESOURCE_ID_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/;
 function assertSafeRunId(value, label) {
   const normalized = value.trim();
   if (!normalized || path.basename(normalized) !== normalized || normalized === "." || normalized === "..") {
@@ -25,6 +26,8 @@ export function workflowReceiptPath(asyncDirRoot, workflowRunId) {
 }
 export function buildWorkflowReceipt(input) {
   const workflowRunId = assertSafeRunId(input.workflowRunId, "workflowRunId");
+  if (input.argsDigest !== undefined && !/^[a-f0-9]{64}$/u.test(input.argsDigest))
+    throw new Error("workflow receipt argsDigest must be a lowercase SHA-256 digest.");
   if (input.workflowChildren?.workflowRunId !== undefined && input.workflowChildren.workflowRunId !== workflowRunId)
     throw new Error("workflowChildren workflowRunId does not match its receipt.");
   const entries = Object.create(null);
@@ -58,7 +61,8 @@ export function buildWorkflowReceipt(input) {
   const hostSteps = input.hostSteps?.map((hostStep, index) => parseHostStepNode(hostStep, `workflow receipt hostSteps[${index}]`));
   if (hostSteps)
     assertUniqueHostStepIds(hostSteps, "workflow receipt");
-  return { version: WORKFLOW_RECEIPT_VERSION, workflowRunId, state: input.state, createdAt: input.createdAt ?? Date.now(), entries, ...hostSteps?.length ? { hostSteps } : {}, ...input.workflowChildren ? { workflowChildren: input.workflowChildren } : {}, ...input.terminalOutcome ? { terminalOutcome: input.terminalOutcome } : {} };
+  const resource = parseWorkflowResource(input.resource, "workflow receipt");
+  return { version: WORKFLOW_RECEIPT_VERSION, workflowRunId, state: input.state, createdAt: input.createdAt ?? Date.now(), entries, ...input.argsDigest ? { argsDigest: input.argsDigest } : {}, ...resource ? { resource } : {}, ...hostSteps?.length ? { hostSteps } : {}, ...input.workflowChildren ? { workflowChildren: input.workflowChildren } : {}, ...input.terminalOutcome ? { terminalOutcome: input.terminalOutcome } : {} };
 }
 export function writeWorkflowReceipt(asyncDir, receipt) {
   const receiptPath = path.join(asyncDir, WORKFLOW_RECEIPT_FILE);
@@ -98,6 +102,27 @@ const EXTERNAL_CLI_CAPABILITIES = {
   forkContext: false,
   extensionBindings: false
 };
+function parseExternalCliMachine(value, label) {
+  if (!value || typeof value !== "object" || Array.isArray(value))
+    throw new Error(`${label}.machine must be an object.`);
+  const machine = value;
+  const unknownMachine = Object.keys(machine).filter((field) => !["provider", "id", "label", "target", "session", "cwd", "remoteGit"].includes(field));
+  if (unknownMachine.length > 0)
+    throw new Error(`${label}.machine has unsupported fields: ${unknownMachine.join(", ")}.`);
+  if (machine.provider !== "herdr" || typeof machine.id !== "string" || !machine.id.trim() || typeof machine.target !== "string" || !machine.target.trim() || typeof machine.cwd !== "string" || !machine.cwd.trim())
+    throw new Error(`${label}.machine is invalid.`);
+  for (const field of ["label", "session"])
+    if (machine[field] !== undefined && (typeof machine[field] !== "string" || !machine[field].trim()))
+      throw new Error(`${label}.machine.${field} is invalid.`);
+  if (machine.remoteGit === undefined)
+    return;
+  if (!machine.remoteGit || typeof machine.remoteGit !== "object" || Array.isArray(machine.remoteGit))
+    throw new Error(`${label}.machine.remoteGit must be an object.`);
+  const remoteGit = machine.remoteGit;
+  const unknownRemoteGit = Object.keys(remoteGit).filter((field) => !["head", "branch", "dirty"].includes(field));
+  if (unknownRemoteGit.length > 0 || remoteGit.head !== undefined && (typeof remoteGit.head !== "string" || !remoteGit.head.trim()) || remoteGit.branch !== undefined && (typeof remoteGit.branch !== "string" || !remoteGit.branch.trim()) || remoteGit.dirty !== undefined && typeof remoteGit.dirty !== "boolean")
+    throw new Error(`${label}.machine.remoteGit is invalid.`);
+}
 function parseExternalCliReceiptMetadata(value, key, source) {
   if (value === undefined)
     return;
@@ -105,7 +130,7 @@ function parseExternalCliReceiptMetadata(value, key, source) {
   if (!value || typeof value !== "object" || Array.isArray(value))
     throw new Error(`${label} must be an object.`);
   const metadata = value;
-  const unknownMetadata = Object.keys(metadata).filter((field) => !["adapter", "capabilities", "safety", "outputArtifacts", "handoff", "supervisor", "nonResumableReason"].includes(field));
+  const unknownMetadata = Object.keys(metadata).filter((field) => !["adapter", "capabilities", "machine", "safety", "outputArtifacts", "handoff", "supervisor", "nonResumableReason"].includes(field));
   if (unknownMetadata.length > 0)
     throw new Error(`${label} has unsupported fields: ${unknownMetadata.join(", ")}.`);
   const adapter = metadata.adapter;
@@ -128,6 +153,8 @@ function parseExternalCliReceiptMetadata(value, key, source) {
     if (capabilityRecord[capability] !== expected)
       throw new Error(`${label}.capabilities.${capability} is invalid.`);
   }
+  if (metadata.machine !== undefined)
+    parseExternalCliMachine(metadata.machine, label);
   const safety = metadata.safety;
   if (adapterRecord.id === "codex-exec") {
     if (!safety || typeof safety !== "object" || Array.isArray(safety))
@@ -295,6 +322,24 @@ function parseWorkflowResolution(value, source) {
     throw new Error(`Invalid workflow receipt '${source}': workflowResolution is invalid.`);
   return value;
 }
+function parseWorkflowResource(value, source) {
+  if (value === undefined)
+    return;
+  if (!value || typeof value !== "object" || Array.isArray(value))
+    throw new Error(`Invalid workflow receipt '${source}': resource must be an object.`);
+  const resource = value;
+  if (resource.kind !== "workflow" || typeof resource.name !== "string" || !KEY_PATTERN.test(resource.name) || !Number.isInteger(resource.version) || resource.version < 1 || resource.version > 1e6 || resource.invocation !== "named" || resource.expansion !== "resolved" || typeof resource.id !== "string" || !RESOURCE_ID_PATTERN.test(resource.id)) {
+    throw new Error(`Invalid workflow receipt '${source}': resource is invalid.`);
+  }
+  return {
+    kind: "workflow",
+    name: resource.name,
+    version: resource.version,
+    invocation: "named",
+    expansion: "resolved",
+    id: resource.id
+  };
+}
 function parseRecovery(value, workflowRunId, entries, source) {
   if (value === undefined)
     return;
@@ -359,9 +404,12 @@ export function readWorkflowReceipt(asyncDirRoot, workflowRunId) {
     assertUniqueHostStepIds(hostSteps, receiptPath);
   }
   const workflowResolution = parseWorkflowResolution(receipt.workflowResolution, receiptPath);
+  if (receipt.argsDigest !== undefined && (typeof receipt.argsDigest !== "string" || !/^[a-f0-9]{64}$/u.test(receipt.argsDigest)))
+    throw new Error(`Invalid workflow receipt '${receiptPath}': argsDigest is invalid.`);
+  const resource = parseWorkflowResource(receipt.resource, receiptPath);
   const terminalOutcome = parseTerminalOutcome(receipt.terminalOutcome, `Invalid workflow receipt '${receiptPath}': terminalOutcome`);
   const recovery = parseRecovery(receipt.recovery, workflowRunId, entries, receiptPath);
-  return { version: 1, workflowRunId, state: receipt.state, createdAt: receipt.createdAt, entries, ...hostSteps?.length ? { hostSteps } : {}, ...workflowChildren ? { workflowChildren } : {}, ...workflowResolution ? { workflowResolution } : {}, ...terminalOutcome ? { terminalOutcome } : {}, ...recovery ? { recovery } : {} };
+  return { version: 1, workflowRunId, state: receipt.state, createdAt: receipt.createdAt, entries, ...receipt.argsDigest ? { argsDigest: receipt.argsDigest } : {}, ...resource ? { resource } : {}, ...hostSteps?.length ? { hostSteps } : {}, ...workflowChildren ? { workflowChildren } : {}, ...workflowResolution ? { workflowResolution } : {}, ...terminalOutcome ? { terminalOutcome } : {}, ...recovery ? { recovery } : {} };
 }
 export function resolveWorkflowReceiptResumeEntry(input) {
   if (input.reference.latest !== true)