@duckmind/dm-windows-x64 0.61.4 → 0.61.9

package/extensions/dm-subagents/src/runs/shared/agent-contract.js

@@ -0,0 +1,35 @@
+export function isAgentContractV1(contract) {
+  return contract?.version === 1;
+}
+export function buildExecutionProjection(result) {
+  if (result.detached) {
+    return { status: "detached", success: false, exitCode: result.exitCode, detached: true, ...result.error ? { error: result.error } : {} };
+  }
+  if (result.stopped) {
+    return { status: "stopped", success: false, exitCode: result.exitCode, stopped: true, ...result.error ? { error: result.error } : {} };
+  }
+  if (result.interrupted) {
+    return { status: "paused", success: false, exitCode: result.exitCode, interrupted: true, ...result.error ? { error: result.error } : {} };
+  }
+  const success = result.exitCode === 0 && !result.error && !result.timedOut;
+  return {
+    status: success ? "completed" : "failed",
+    success,
+    exitCode: result.exitCode,
+    ...result.error ? { error: result.error } : {},
+    ...result.timedOut ? { timedOut: true } : {}
+  };
+}
+export function buildReviewProjection(result) {
+  const review = result.acceptance?.reviewResult;
+  if (!review)
+    return { status: "not-requested" };
+  return { status: review.status, findings: review.findings };
+}
+export function attachContractProjections(result) {
+  result.execution = buildExecutionProjection(result);
+  result.review = buildReviewProjection(result);
+  if (!result.effects)
+    result.effects = {};
+  return result;
+}

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

@@ -0,0 +1,472 @@
+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 { workflowGraphStageNodes } from "./workflow-graph.js";
+export const ASYNC_STATUS_SNAPSHOT_KIND = "dm-subagents.async-status-snapshot";
+export const ASYNC_STATUS_SNAPSHOT_VERSION = 1;
+const DEFAULT_MAX_RUNS = 20;
+const DEFAULT_MAX_CHILDREN_PER_NODE = 8;
+const DEFAULT_MAX_DEPTH = 3;
+const DEFAULT_MAX_STRING_LENGTH = 160;
+const DEFAULT_MAX_SERIALIZED_BYTES = 32 * 1024;
+const ASYNC_STATUS_SNAPSHOT_STATES = {
+  queued: true,
+  running: true,
+  complete: true,
+  failed: true,
+  partial: true,
+  paused: true,
+  stopped: true,
+  rejected: true
+};
+function isAsyncStatusSnapshotState(value) {
+  return Object.hasOwn(ASYNC_STATUS_SNAPSHOT_STATES, value);
+}
+function validHostStepList(source) {
+  if (source && "nodes" in source)
+    return validHostStepNodes(source);
+  const hostSteps = [];
+  for (const [index, value] of (source ?? []).slice(0, HOST_STEP_MAX_COUNT).entries()) {
+    try {
+      hostSteps.push(parseHostStepNode(value, `hostSteps[${index}]`));
+    } catch {}
+  }
+  return hostSteps;
+}
+function resolveCaps(options) {
+  return {
+    maxRuns: Math.max(0, Math.floor(options.maxRuns ?? DEFAULT_MAX_RUNS)),
+    maxChildrenPerNode: Math.max(0, Math.floor(options.maxChildrenPerNode ?? DEFAULT_MAX_CHILDREN_PER_NODE)),
+    maxDepth: Math.max(0, Math.floor(options.maxDepth ?? DEFAULT_MAX_DEPTH)),
+    maxStringLength: Math.max(0, Math.floor(options.maxStringLength ?? DEFAULT_MAX_STRING_LENGTH)),
+    maxSerializedBytes: Math.max(256, Math.floor(options.maxSerializedBytes ?? DEFAULT_MAX_SERIALIZED_BYTES))
+  };
+}
+function publicText(value, fallback, maxLength) {
+  if (typeof value !== "string")
+    return fallback;
+  const normalized = sanitizeDisplayText(value.slice(0, Math.max(0, maxLength * 4)));
+  return truncateDisplayText(normalized || fallback, maxLength);
+}
+function publicOptionalText(value, maxLength) {
+  if (typeof value !== "string")
+    return;
+  const normalized = sanitizeDisplayText(value.slice(0, Math.max(0, maxLength * 4)));
+  return normalized ? truncateDisplayText(normalized, maxLength) : undefined;
+}
+function publicTime(value) {
+  return typeof value === "number" && Number.isSafeInteger(value) && value >= 0 ? value : undefined;
+}
+function publicCount(value) {
+  return typeof value === "number" && Number.isSafeInteger(value) && value >= 0 ? value : undefined;
+}
+function normalizeState(value) {
+  if (value === "completed")
+    return "complete";
+  if (value === "pending")
+    return "queued";
+  if (isAsyncStatusSnapshotState(value))
+    return value;
+  return "partial";
+}
+function terminalState(state) {
+  return state === "complete" || state === "failed" || state === "partial" || state === "paused" || state === "stopped" || state === "rejected";
+}
+function kindForMode(mode) {
+  return mode === "workflow" ? "workflow" : "subagent";
+}
+function labelForAgents(agents, fallback, maxLength) {
+  if (!agents?.length)
+    return publicText(fallback, fallback, maxLength);
+  const visible = agents.slice(0, 3).map((agent) => publicText(agent, "agent", maxLength)).join(", ");
+  const suffix = agents.length > 3 ? `, +${agents.length - 3} more` : "";
+  return truncateDisplayText(`${visible}${suffix}`, maxLength);
+}
+function activityFor(source, ctx) {
+  const currentTool = publicOptionalText(source.currentTool, ctx.caps.maxStringLength);
+  const lastActivityAt = publicTime(source.lastActivityAt);
+  const currentToolStartedAt = publicTime(source.currentToolStartedAt);
+  const turnCount = publicCount(source.turnCount);
+  const toolCount = publicCount(source.toolCount);
+  const activity = {
+    ...typeof source.activityState === "string" ? { state: publicText(source.activityState, "unknown", ctx.caps.maxStringLength) } : {},
+    ...currentTool ? { currentTool } : {},
+    ...lastActivityAt !== undefined ? { lastActivityAt } : {},
+    ...currentToolStartedAt !== undefined ? { currentToolStartedAt } : {},
+    ...turnCount !== undefined ? { turnCount } : {},
+    ...toolCount !== undefined ? { toolCount } : {}
+  };
+  return Object.keys(activity).length ? activity : undefined;
+}
+function appendBoundedChildren(children, source, ctx) {
+  const remaining = Math.max(0, ctx.caps.maxChildrenPerNode - children.length);
+  children.push(...source.slice(0, remaining));
+  ctx.omitted.children += Math.max(0, source.length - remaining);
+}
+function projectStep(step, index, depth, ctx) {
+  const state = normalizeState(step.status);
+  const startedAt = publicTime(step.startedAt);
+  const endedAt = publicTime(step.endedAt);
+  const updatedAt = endedAt ?? publicTime(step.lastActivityAt) ?? startedAt;
+  const activity = activityFor(step, 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),
+    kind: "step",
+    label: publicText("label" in step && step.label ? step.label : step.agent, "step", ctx.caps.maxStringLength),
+    state,
+    ...startedAt !== undefined ? { startedAt } : {},
+    ...updatedAt !== undefined ? { updatedAt } : {},
+    ...terminalState(state) && endedAt !== undefined ? { endedAt } : {},
+    ...activity ? { activity } : {}
+  };
+  if (depth < ctx.caps.maxDepth && step.children?.length) {
+    const nested = step.children.map((child, childIndex) => projectNestedRun(child, childIndex, depth + 1, ctx));
+    const bounded = [];
+    appendBoundedChildren(bounded, nested, ctx);
+    if (bounded.length)
+      node.children = bounded;
+  } else if (step.children?.length) {
+    ctx.omitted.children += step.children.length;
+  }
+  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);
+  const endedAt = publicTime(child.endedAt);
+  const updatedAt = publicTime(child.lastUpdate) ?? endedAt ?? publicTime(child.lastActivityAt) ?? startedAt;
+  const activity = activityFor(child, ctx);
+  const node = {
+    id: publicText(child.id, `nested:${index}`, ctx.caps.maxStringLength),
+    kind: kindForMode(child.mode),
+    label: child.agent ? publicText(child.agent, "subagent", ctx.caps.maxStringLength) : labelForAgents(child.agents, child.mode ?? "subagent", ctx.caps.maxStringLength),
+    state,
+    ...startedAt !== undefined ? { startedAt } : {},
+    ...updatedAt !== undefined ? { updatedAt } : {},
+    ...terminalState(state) && endedAt !== undefined ? { endedAt } : {},
+    ...activity ? { activity } : {}
+  };
+  if (depth < ctx.caps.maxDepth) {
+    const nestedSteps = child.steps?.map((step, stepIndex) => projectStep(step, stepIndex, depth + 1, ctx)) ?? [];
+    const nestedChildren = child.children?.map((nested, childIndex) => projectNestedRun(nested, childIndex, depth + 1, ctx)) ?? [];
+    const bounded = [];
+    appendBoundedChildren(bounded, [...nestedSteps, ...nestedChildren], ctx);
+    if (bounded.length)
+      node.children = bounded;
+  } else {
+    ctx.omitted.children += (child.steps?.length ?? 0) + (child.children?.length ?? 0);
+  }
+  return node;
+}
+function hostStepSnapshotState(state, verdict) {
+  if (state === "pending")
+    return "queued";
+  if (state === "running")
+    return "running";
+  if (state === "cancelled")
+    return "stopped";
+  if (state === "error" || verdict === "fail")
+    return "failed";
+  return verdict === undefined || verdict === "inconclusive" ? "partial" : "complete";
+}
+function projectHostStep(hostStep, ctx) {
+  const state = hostStepSnapshotState(hostStep.state, hostStep.verdict);
+  const detail = publicOptionalText(hostStep.detail, ctx.caps.maxStringLength);
+  const report = publicOptionalText(hostStepReportName(hostStep.reportPath), ctx.caps.maxStringLength);
+  const hostMetadata = {
+    kind: hostStep.monitorKind,
+    state: hostStep.state,
+    ...hostStep.provider ? { provider: publicText(hostStep.provider, "provider", ctx.caps.maxStringLength) } : {},
+    ...hostStep.role ? { role: publicText(hostStep.role, "role", ctx.caps.maxStringLength) } : {},
+    ...hostStep.verdict ? { verdict: hostStep.verdict } : {},
+    ...hostStep.reasonCode ? { reasonCode: publicText(hostStep.reasonCode, "reason", ctx.caps.maxStringLength) } : {},
+    ...detail ? { detail } : {},
+    ...hostStep.target ? { target: publicText(hostStep.target, "target", ctx.caps.maxStringLength) } : {},
+    ...hostStep.freshness?.stale !== undefined ? { stale: hostStep.freshness.stale } : {},
+    ...report ? { report } : {}
+  };
+  return {
+    id: publicText(hostStep.id, "host-step", ctx.caps.maxStringLength),
+    kind: "host-step",
+    label: publicText(hostStep.label, "host step", ctx.caps.maxStringLength),
+    state,
+    updatedAt: hostStep.updatedAt,
+    ...terminalState(state) ? { endedAt: hostStep.updatedAt } : {},
+    hostStep: hostMetadata
+  };
+}
+function projectRun(job, ctx) {
+  const state = normalizeState(job.status);
+  const startedAt = publicTime(job.startedAt);
+  const updatedAt = publicTime(job.updatedAt) ?? startedAt;
+  const activity = activityFor(job, ctx);
+  const node = {
+    id: publicText(job.asyncId, "async", ctx.caps.maxStringLength),
+    kind: kindForMode(job.mode),
+    label: labelForAgents(job.agents, job.mode ?? "subagent", ctx.caps.maxStringLength),
+    state,
+    ...startedAt !== undefined ? { startedAt } : {},
+    ...updatedAt !== undefined ? { updatedAt } : {},
+    ...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 hostStepChildren = validHostStepList(job.hostSteps).map((hostStep) => projectHostStep(hostStep, ctx));
+    const ordinaryChildren = [...stepChildren, ...graphChildren, ...nestedChildren];
+    const retainedHostSteps = hostStepChildren.slice(0, ctx.caps.maxChildrenPerNode);
+    const retainedOrdinaryChildren = ordinaryChildren.slice(0, ctx.caps.maxChildrenPerNode - retainedHostSteps.length);
+    const bounded = [];
+    bounded.push(...retainedOrdinaryChildren, ...retainedHostSteps);
+    ctx.omitted.children += ordinaryChildren.length - retainedOrdinaryChildren.length + hostStepChildren.length - retainedHostSteps.length;
+    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;
+  }
+  return node;
+}
+function snapshotBytes(snapshot) {
+  return Buffer.byteLength(JSON.stringify(snapshot), "utf8");
+}
+function enforceByteLimit(snapshot) {
+  if (snapshotBytes(snapshot) <= snapshot.caps.maxSerializedBytes)
+    return;
+  snapshot.omitted.byteLimitExceeded = true;
+  const runs = snapshot.runs;
+  const initialOmittedRuns = snapshot.omitted.runs;
+  let lower = 0;
+  let upper = Math.max(0, runs.length - 1);
+  while (lower < upper) {
+    const retained = Math.ceil((lower + upper) / 2);
+    snapshot.runs = runs.slice(0, retained);
+    snapshot.omitted.runs = initialOmittedRuns + runs.length - retained;
+    if (snapshotBytes(snapshot) <= snapshot.caps.maxSerializedBytes)
+      lower = retained;
+    else
+      upper = retained - 1;
+  }
+  snapshot.runs = runs.slice(0, lower);
+  snapshot.omitted.runs = initialOmittedRuns + runs.length - lower;
+}
+function workflowStepActivity(step) {
+  if (step.currentTool)
+    return `tool ${step.currentTool}`;
+  if (step.currentPath)
+    return step.currentPath.split(/[\\/]/).at(-1);
+  if (step.activityState === "needs_attention")
+    return "needs attention";
+  if (step.activityState === "active_long_running")
+    return "long-running";
+  if (step.turnCount !== undefined)
+    return `${step.turnCount} turns`;
+  if (step.toolCount !== undefined)
+    return `${step.toolCount} tools`;
+  return;
+}
+function workflowStepName(step, index) {
+  const key = step.workflowKey ?? `step ${index + 1}`;
+  const label = step.label && step.label !== key ? ` · ${step.label}` : "";
+  const phase = step.phase ? `${step.phase}: ` : "";
+  return `${phase}${key}${label} (${step.agent})`;
+}
+function hostStepRow(hostStep) {
+  const freshness = hostStep.freshness ? {
+    expectedRef: publicText(hostStep.freshness.expectedRef, "ref", HOST_STEP_MAX_REF_CHARS),
+    ...hostStep.freshness.observedRef ? { observedRef: publicText(hostStep.freshness.observedRef, "ref", HOST_STEP_MAX_REF_CHARS) } : {},
+    ...hostStep.freshness.stale !== undefined ? { stale: hostStep.freshness.stale } : {}
+  } : undefined;
+  return {
+    name: publicText(hostStep.label, "host step", HOST_STEP_MAX_LABEL_CHARS),
+    kind: hostStep.monitorKind,
+    state: hostStep.state,
+    ...hostStep.role ? { role: publicText(hostStep.role, "role", HOST_STEP_MAX_ROLE_CHARS) } : {},
+    ...hostStep.provider ? { provider: publicText(hostStep.provider, "provider", HOST_STEP_MAX_PROVIDER_CHARS) } : {},
+    ...hostStep.verdict ? { verdict: hostStep.verdict } : {},
+    ...hostStep.reasonCode ? { reasonCode: publicText(hostStep.reasonCode, "reason", HOST_STEP_MAX_REASON_CHARS) } : {},
+    ...hostStep.detail ? { detail: publicText(hostStep.detail, "detail", HOST_STEP_MAX_DETAIL_CHARS) } : {},
+    ...hostStep.target ? { target: publicText(hostStep.target, "target", HOST_STEP_MAX_TARGET_CHARS) } : {},
+    ...freshness ? { freshness } : {},
+    ...hostStep.reportPath ? { reportPath: hostStepReportName(hostStep.reportPath) } : {}
+  };
+}
+function isWorkflowPreflight(value) {
+  return value !== undefined && !Array.isArray(value) && "lanes" in value;
+}
+function isWorkflowGraph(value) {
+  return value !== undefined && !Array.isArray(value) && "nodes" in value;
+}
+function workflowGraphRowState(status) {
+  switch (status) {
+    case "pending":
+      return "planned";
+    case "completed":
+      return "complete";
+    case "detached":
+      return "paused";
+    default:
+      return status;
+  }
+}
+function workflowGraphStepStatus(status) {
+  switch (status) {
+    case "completed":
+      return "complete";
+    case "detached":
+      return "paused";
+    default:
+      return status;
+  }
+}
+function workflowGraphRowName(node) {
+  const key = publicText(node.id, "stage", HOST_STEP_MAX_LABEL_CHARS);
+  const label = publicOptionalText(node.label, HOST_STEP_MAX_LABEL_CHARS);
+  const phase = publicOptionalText(node.phase, HOST_STEP_MAX_LABEL_CHARS);
+  const agent = publicOptionalText(node.agent, HOST_STEP_MAX_LABEL_CHARS);
+  return `${phase ? `${phase}: ` : ""}${key}${label && label !== node.id ? ` · ${label}` : ""}${agent ? ` (${agent})` : ""}`;
+}
+function projectWorkflowGraphRow(node, preflight) {
+  return {
+    name: workflowGraphRowName(node),
+    state: workflowGraphRowState(node.status),
+    ...preflight ? { preflight } : {}
+  };
+}
+export function projectAsyncWorkflowRows(steps, hostStepsOrPreflight, preflightOverride) {
+  const preflight = preflightOverride ?? (isWorkflowPreflight(hostStepsOrPreflight) ? hostStepsOrPreflight : undefined);
+  const graph = isWorkflowGraph(hostStepsOrPreflight) ? hostStepsOrPreflight : undefined;
+  const hostSteps = isWorkflowPreflight(hostStepsOrPreflight) || graph ? undefined : hostStepsOrPreflight;
+  const loaded = steps ?? [];
+  const declared = new Map;
+  if (graph) {
+    const loadedIndexesByKey = new Map;
+    for (const [index, step] of loaded.entries()) {
+      if (!step.workflowKey)
+        continue;
+      const indexes = loadedIndexesByKey.get(step.workflowKey) ?? [];
+      indexes.push(index);
+      loadedIndexesByKey.set(step.workflowKey, indexes);
+    }
+    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;
+    for (const phase of graph.phases) {
+      for (const nodeId of phase.nodeIds) {
+        if (graphKeys.has(nodeId) && !graphPhaseByNodeId.has(nodeId))
+          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 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 });
+      }
+    }
+    for (const [index, step] of loaded.entries()) {
+      if (!consumed.has(index))
+        childRows.push(projectLoadedWorkflowRow(step, index, step.workflowKey ? declared.get(step.workflowKey) : 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)];
+}
+function projectLoadedWorkflowRow(step, index, preflight) {
+  const modelThinking = formatModelThinking(step.model, step.thinking) || undefined;
+  const activity = workflowStepActivity(step);
+  return {
+    name: workflowStepName(step, index),
+    state: step.status,
+    ...step.context ? { context: step.context } : {},
+    ...modelThinking ? { modelThinking } : {},
+    ...activity ? { activity } : {},
+    ...step.startedAt !== undefined ? { startedAt: step.startedAt } : {},
+    ...step.tokens?.total !== undefined ? { tokens: step.tokens.total } : {},
+    ...step.tokens?.window !== undefined ? { window: step.tokens.window } : {},
+    ...preflight ? { 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);
+  });
+  ctx.omitted.runs += Math.max(0, sorted.length - caps.maxRuns);
+  const snapshot = {
+    kind: ASYNC_STATUS_SNAPSHOT_KIND,
+    version: ASYNC_STATUS_SNAPSHOT_VERSION,
+    generatedAt: options.generatedAt ?? Date.now(),
+    caps,
+    omitted: ctx.omitted,
+    runs: sorted.slice(0, caps.maxRuns).map((job) => projectRun(job, ctx))
+  };
+  enforceByteLimit(snapshot);
+  return snapshot;
+}

package/extensions/dm-subagents/src/runs/shared/background-process-options.js

@@ -0,0 +1,6 @@
+export function backgroundProcessOptions(platform = process.platform) {
+  return {
+    detached: platform !== "win32",
+    windowsHide: true
+  };
+}