@duckmind/dm-windows-x64 0.61.4 → 0.61.9

package/extensions/dm-subagents/src/runs/shared/subagent-startup-retry.js

@@ -0,0 +1,50 @@
+import { formatProcessSignalError } from "./process-signal.js";
+export const SUBAGENT_STARTUP_RETRY_DELAYS_MS = [250, 750, 1500];
+export const MAX_SUBAGENT_STARTUP_FAILURE_DURATION_MS = 2000;
+const SIGKILL_PROCESS_SIGNAL_ERROR = formatProcessSignalError("SIGKILL");
+const EXTENSION_REGISTRATION_CONFLICT_PATTERN = /Failed to load extension\b[^\n]*:\s*(?:Tool|Flag)\s+"[^"]+"\s+conflicts with\b/i;
+export function formatSubagentExtensionConflictError(error, input) {
+  if (!error || !input.ambientExtensionsEnabled || !EXTENSION_REGISTRATION_CONFLICT_PATTERN.test(error))
+    return error;
+  const settings = JSON.stringify({
+    subagents: { agentOverrides: { [input.agent]: { extensions: [] } } }
+  });
+  return `${error}
+
+Subagent startup loaded conflicting ambient DM extensions. Retry this run after disabling ambient extension discovery for agent ${JSON.stringify(input.agent)} in project .dm/settings.json: ${settings}. Replace the empty array with only the required extension entry paths when this agent needs extension tools.`;
+}
+function hasUsage(usage) {
+  return usage.input !== 0 || usage.output !== 0 || usage.cacheRead !== 0 || usage.cacheWrite !== 0 || usage.cost !== 0 || usage.turns !== 0;
+}
+export function isRetryableSubagentStartupFailure(evidence) {
+  return evidence.exitCode !== undefined && evidence.exitCode !== null && evidence.exitCode !== 0 && (!evidence.error?.trim() || evidence.error === SIGKILL_PROCESS_SIGNAL_ERROR) && !evidence.finalOutput?.trim() && evidence.messageCount === 0 && evidence.toolCount === 0 && !hasUsage(evidence.usage) && evidence.durationMs >= 0 && evidence.durationMs <= MAX_SUBAGENT_STARTUP_FAILURE_DURATION_MS && evidence.protocolError === undefined && (evidence.processSignal === undefined || evidence.processSignal === null || evidence.processSignal === "SIGKILL") && evidence.observedMutationAttempt !== true && evidence.detached !== true && evidence.interrupted !== true && evidence.timedOut !== true && evidence.stopped !== true && evidence.turnBudgetExceeded !== true;
+}
+export function formatSubagentStartupRetryNote(input) {
+  return `[startup-retry] ${input.model} exited before model or tool activity (attempt ${input.attempt}/${input.maxAttempts}). Retrying the same model in ${input.delayMs}ms.`;
+}
+export function formatSubagentStartupRetryExhaustedError(input) {
+  return `Subagent failed to start after ${input.attempts} attempts on ${input.model}; no model, tool, output, usage, or diagnostic activity was observed. This may be a concurrent DM startup race. Retry the run or temporarily lower subagent concurrency.`;
+}
+export async function waitForSubagentStartupRetry(delayMs, signals) {
+  const activeSignals = signals.filter((signal) => Boolean(signal));
+  if (activeSignals.some((signal) => signal.aborted))
+    return false;
+  if (delayMs <= 0)
+    return true;
+  return await new Promise((resolve) => {
+    let settled = false;
+    const finish = (shouldRetry) => {
+      if (settled)
+        return;
+      settled = true;
+      clearTimeout(timer);
+      for (const signal of activeSignals)
+        signal.removeEventListener("abort", abort);
+      resolve(shouldRetry);
+    };
+    const abort = () => finish(false);
+    const timer = setTimeout(() => finish(true), delayMs);
+    for (const signal of activeSignals)
+      signal.addEventListener("abort", abort, { once: true });
+  });
+}

package/extensions/dm-subagents/src/runs/shared/task-intent.js

@@ -0,0 +1,130 @@
+const REVIEW_ONLY_PATTERNS = [
+  /\breview only\b/i,
+  /\bsuggest fixes only\b/i,
+  /\bonly return findings\b/i,
+  /\breturn findings only\b/i
+];
+const REVIEWER_REQUIRED_EDIT_PATTERNS = [
+  /\bmust\s+(?:edit|modify|change|fix|patch|apply|implement)\b/i,
+  /\brequired\s+to\s+(?:edit|modify|change|fix|patch|apply|implement)\b/i,
+  /(?:^|[.!?\n]\s*)implement\s+(?:the\s+)?(?:approved|requested|specified|file|code|source|fix(?:es)?|changes?)\b/i,
+  /\bregardless\s+of\s+findings\b/i,
+  /\balways\s+(?:edit|modify|change|fix|patch|apply|implement)\b/i,
+  /\bapply\s+(?:the\s+)?fix(?:es)?\s+directly\b/i,
+  /\bmake\s+(?:the\s+)?code\s+changes\b/i
+];
+const NO_EDIT_PROHIBITION_PATTERN = /\b(?:do not|don't|must not)\s+(?:edit|modify|write(?:\s+to)?|touch|change)\b((?:(?!\b(?:but|and|then)\b)[^.;,:!?\n–—-])*)/gi;
+const GENERIC_PROHIBITION_OBJECT = /^\s*(?:(?:any|all|the|these|those|your|our|existing|project|product|source|sources|config|configs|repo|repository)[\s/,-]*)*(?:files?|code|codebase|sources?|anything|repo(?:sitory)?)?\s*$/i;
+const SCOPED_NO_EDIT_CONSTRAINT_PATTERNS = [
+  /\bdo not edit files?\s+outside\b/i,
+  /\bdo not edit\s+outside\b/i,
+  /\bdo not edit\s+unrelated files?\b/i,
+  /\bdo not change\s+unrelated files?\b/i,
+  /\bdo not modify\s+unrelated files?\b/i
+];
+const NO_TOOL_INTENT_PATTERNS = [
+  /\bno tools? needed\b/i,
+  /\bno tools? required\b/i,
+  /\bwithout using tools\b/i,
+  /\bdo not use tools\b/i,
+  /\bdon't use tools\b/i
+];
+const READ_ONLY_DELIVERABLE_PATTERNS = [
+  /\b(?:draft|write|compose|prepare|produce)\s+(?:(?:a|an|the)\s+)?(?:github\s+)?(?:issue|bug report|issue draft|issue body|proposal|plan|report|summary|findings?|analysis|recommendations?)\b/i,
+  /\b(?:issue|bug report)\s+(?:draft|body|template)\b/i,
+  /\b(?:return|provide|produce)\s+(?:text|markdown|answer|findings?|recommendations?)\s+only\b/i
+];
+const RESEARCH_AGENT_PATTERNS = [
+  /\binvestigate\b/i,
+  /\bscout\b/i,
+  /\bresearch(?:er)?\b/i
+];
+const SEVERITY_COMPOUND_PATTERN = /\b(?:must|should|needs)[\-\u2010-\u2015](?:fix|edit|update|add|remove|replace|create|apply|make|do|implement|modify|delete|patch)\b/gi;
+function stripSeverityCompounds(task) {
+  return task.replace(SEVERITY_COMPOUND_PATTERN, " ");
+}
+
+export { stripSeverityCompounds };
+const FIX_OR_PATCH_IMPLEMENTATION_PATTERN = /\b(?:fix|patch)\s+(?:(?:it|this|that|them|each|any|all|these|those)\b|(?:(?:a|an|the|any|all)\s+)?(?:(?:failing|failed|broken|flaky|red|cold|start|current|existing|reported|approved|known|regression|unit|integration|e2e|source|typescript|type-?script|ts|type-?check|compiler)\s+)*(?:bug|defect|issues?|problems?|failures?|regressions?|tests?|errors?|items?|typos?|code|source|implementation|component|function|module|class|method|logic|file|files|readme|docs?|changelog|package\.json|config|manifest|extension|prompt|command|lint(?:ing)?|build|ci|type-?check|type\s+checking)\b)/i;
+const WORKER_IMPLEMENTATION_PATTERNS = [
+  /\b(?:implement|edit|modify|refactor|delete)\b/i,
+  FIX_OR_PATCH_IMPLEMENTATION_PATTERN,
+  /\b(?:update|add|remove|replace|create)\b(?!\s+(?:(?:a|an|the)\s+)?(?:report|summary|findings?)(?:\b|$))/i,
+  /\bapply\s+(?:the\s+)?(?:(?:suggested|proposed|recommended)\s+)?(?:changes?|fix(?:es)?|patch)\b/i,
+  /\bmake\s+(?:the\s+)?changes\b/i,
+  /\bdo those fixes\b/i
+];
+const GENERAL_IMPLEMENTATION_PATTERNS = [
+  /\b(?:implement|edit|modify|refactor)\b/i,
+  FIX_OR_PATCH_IMPLEMENTATION_PATTERN,
+  /\bapply\s+(?:the\s+)?(?:(?:suggested|proposed|recommended)\s+)?(?:changes?|fix(?:es)?|patch)\b/i,
+  /\bmake\s+(?:the\s+)?changes\b/i,
+  /\bdo those fixes\b/i,
+  /\b(?:update|add|remove|replace|delete|create)\s+(?:the\s+)?(?:file|files|code|source|implementation|test|tests|component|function|module|class|method|logic|import|imports|readme|docs?|changelog|package\.json|config|manifest|extension|prompt|command)\b/i
+];
+function stripFrameworkInstructions(task) {
+  return task.split(`
+`).filter((line) => !/^\s*\[(?:Write to|Read from):/i.test(line)).filter((line) => !/^\s*(?:Create and maintain progress at:|Update progress at:|\*\*Output:\*\*|Write your findings to(?: exactly this path)?:|Return the complete artifact in your final response\.|The runtime will persist it to exactly this path:|Do not call contact_supervisor merely because no write-capable tool is available\.|This path is authoritative for this run\.|Ignore any other output filename or output path mentioned elsewhere)/i.test(line)).join(`
+`);
+}
+function stripPatterns(task, patterns) {
+  let stripped = task;
+  for (const pattern of patterns) {
+    const flags = pattern.flags.includes("g") ? pattern.flags : `${pattern.flags}g`;
+    stripped = stripped.replace(new RegExp(pattern.source, flags), " ");
+  }
+  return stripped;
+}
+function analyzeNoEditProhibitions(taskText) {
+  let present = REVIEW_ONLY_PATTERNS.some((pattern) => pattern.test(taskText)) || NO_TOOL_INTENT_PATTERNS.some((pattern) => pattern.test(taskText));
+  let blanket = present;
+  let strippedText = stripPatterns(taskText, [...REVIEW_ONLY_PATTERNS, ...NO_TOOL_INTENT_PATTERNS]);
+  strippedText = strippedText.replace(new RegExp(NO_EDIT_PROHIBITION_PATTERN.source, NO_EDIT_PROHIBITION_PATTERN.flags), (_match, object) => {
+    present = true;
+    if (GENERIC_PROHIBITION_OBJECT.test(object))
+      blanket = true;
+    return " ";
+  });
+  return { present, blanket, strippedText };
+}
+function taskHasReadOnlyDeliverable(taskText) {
+  return READ_ONLY_DELIVERABLE_PATTERNS.some((pattern) => pattern.test(taskText));
+}
+function isReviewerStyleAgent(agent) {
+  return /\b(?:advisor|reviewer|oracle)\b/i.test(agent);
+}
+function hasImplementationIntent(agent, taskText) {
+  if (isReviewerStyleAgent(agent))
+    return REVIEWER_REQUIRED_EDIT_PATTERNS.some((pattern) => pattern.test(taskText));
+  if (agent === "worker")
+    return WORKER_IMPLEMENTATION_PATTERNS.some((pattern) => pattern.test(taskText));
+  return GENERAL_IMPLEMENTATION_PATTERNS.some((pattern) => pattern.test(taskText));
+}
+export function classifyTaskMutationIntent(agent, task) {
+  const taskText = stripSeverityCompounds(stripFrameworkInstructions(task));
+  const taskTextWithoutScopedConstraints = stripPatterns(taskText, SCOPED_NO_EDIT_CONSTRAINT_PATTERNS);
+  const prohibitions = analyzeNoEditProhibitions(taskTextWithoutScopedConstraints);
+  if (prohibitions.present) {
+    if (prohibitions.blanket)
+      return { kind: "read-only" };
+    return hasImplementationIntent(agent, prohibitions.strippedText) ? { kind: "implementation" } : { kind: "read-only" };
+  }
+  if (RESEARCH_AGENT_PATTERNS.some((pattern) => pattern.test(agent)))
+    return { kind: "read-only" };
+  if (hasImplementationIntent(agent, taskText))
+    return { kind: "implementation" };
+  if (isReviewerStyleAgent(agent))
+    return { kind: "read-only" };
+  return taskHasReadOnlyDeliverable(taskTextWithoutScopedConstraints) ? { kind: "read-only" } : { kind: "unknown" };
+}
+export function expectsImplementationMutation(agent, task) {
+  return classifyTaskMutationIntent(agent, task).kind === "implementation";
+}
+const MAY_MUTATE_VERB_PATTERN = /\b(?:fix|implement|update|write|edit|modify|migrate|delete|remove|refactor|commit)\b/i;
+export function taskMayMutate(task) {
+  const taskText = stripPatterns(stripSeverityCompounds(stripFrameworkInstructions(task)), SCOPED_NO_EDIT_CONSTRAINT_PATTERNS);
+  const prohibitions = analyzeNoEditProhibitions(taskText);
+  if (prohibitions.blanket)
+    return false;
+  return MAY_MUTATE_VERB_PATTERN.test(stripPatterns(prohibitions.strippedText, READ_ONLY_DELIVERABLE_PATTERNS));
+}

package/extensions/dm-subagents/src/runs/shared/tool-availability.js

@@ -0,0 +1,59 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+export const REQUIRED_CHILD_TOOLS_ENV = "DM_SUBAGENT_REQUIRED_TOOLS";
+export const MCP_DIRECT_CHILD_TOOLS_ENV = "DM_SUBAGENT_MCP_DIRECT_TOOLS";
+export const CHILD_TOOL_DIAGNOSTIC_PATH_ENV = "DM_SUBAGENT_TOOL_DIAGNOSTIC_PATH";
+export function writeChildToolDiagnostic(filePath, required, available, agent, mcpDirectTools) {
+  const availableNames = new Set(available);
+  const missing = required.filter((name) => !availableNames.has(name));
+  if (missing.length === 0) {
+    fs.rmSync(filePath, { force: true });
+    return;
+  }
+  const missingMcpDirectTools = mcpDirectTools?.length ? missing.filter((name) => mcpDirectTools.includes(name)) : [];
+  const diagnostic = {
+    agent,
+    required,
+    available,
+    missing,
+    ...missingMcpDirectTools.length > 0 ? { missingMcpDirectTools } : {}
+  };
+  fs.mkdirSync(path.dirname(filePath), { recursive: true });
+  fs.writeFileSync(filePath, JSON.stringify(diagnostic), { mode: 384 });
+  return diagnostic;
+}
+export function readChildToolDiagnostic(filePath) {
+  if (!filePath || !fs.existsSync(filePath))
+    return;
+  const parsed = JSON.parse(fs.readFileSync(filePath, "utf-8"));
+  const stringArray = (value) => Array.isArray(value) && value.every((entry) => typeof entry === "string" && entry.length > 0);
+  if (!stringArray(parsed.required) || !stringArray(parsed.available) || !stringArray(parsed.missing) || parsed.agent !== undefined && typeof parsed.agent !== "string" || parsed.missingMcpDirectTools !== undefined && !stringArray(parsed.missingMcpDirectTools)) {
+    throw new Error(`Malformed child tool diagnostic at '${filePath}'.`);
+  }
+  return {
+    ...parsed.agent ? { agent: parsed.agent } : {},
+    required: parsed.required,
+    available: parsed.available,
+    missing: parsed.missing,
+    ...parsed.missingMcpDirectTools ? { missingMcpDirectTools: parsed.missingMcpDirectTools } : {}
+  };
+}
+export function formatChildToolDiagnostic(diagnostic) {
+  const subject = diagnostic.agent ? `Agent '${diagnostic.agent}'` : "Subagent";
+  return [
+    `${subject} requested unavailable child tools: ${diagnostic.missing.join(", ")}.`,
+    "The `tools` field is a strict allowlist; it does not load extension code.",
+    ...diagnostic.missingMcpDirectTools?.length ? [`Resolved MCP direct tools missing from the child registry: ${diagnostic.missingMcpDirectTools.join(", ")}. This indicates a host/dm-mcp-adapter registration problem, not a tool-call failure.`] : [],
+    "For extension tools, add the provider path to `subagentOnlyExtensions` (child-only), `extensions`, or as a path-like entry in `tools`, while keeping each registered tool name in `tools`.",
+    "For MCP tools, verify the MCP adapter configuration and selected tool names. For builtin tools, verify the name against the installed DM version."
+  ].join(`
+`);
+}
+export function readChildToolDiagnosticError(filePath) {
+  try {
+    const diagnostic = readChildToolDiagnostic(filePath);
+    return diagnostic ? formatChildToolDiagnostic(diagnostic) : undefined;
+  } catch (error) {
+    return `Failed to read child tool availability diagnostic: ${error instanceof Error ? error.message : String(error)}`;
+  }
+}

package/extensions/dm-subagents/src/runs/shared/tool-budget.js

@@ -1,5 +1,6 @@
 export const DEFAULT_TOOL_BUDGET_BLOCK = ["read", "grep", "find", "ls"];
 export const TOOL_BUDGET_ENV = "DM_SUBAGENT_TOOL_BUDGET";
+export const TOOL_BUDGET_ZERO_AUTH_ENV = "DM_SUBAGENT_TOOL_BUDGET_ZERO_AUTH";
 export function normalizeToolBudgetBlock(block) {
   if (block === "*")
     return "*";
@@ -7,14 +8,15 @@ export function normalizeToolBudgetBlock(block) {
     return [...DEFAULT_TOOL_BUDGET_BLOCK];
   return [...new Set(block.map((tool) => tool.trim()).filter(Boolean))];
 }
-export function validateToolBudgetConfig(raw, label = "toolBudget") {
+export function validateToolBudgetConfig(raw, label = "toolBudget", options = {}) {
   if (raw === undefined)
     return {};
   if (!raw || typeof raw !== "object" || Array.isArray(raw))
     return { error: `${label} must be an object with hard and optional soft/block.` };
   const value = raw;
-  if (typeof value.hard !== "number" || !Number.isInteger(value.hard) || value.hard < 1) {
-    return { error: `${label}.hard must be an integer >= 1.` };
+  const minimumHard = options.minimumHard ?? 1;
+  if (typeof value.hard !== "number" || !Number.isInteger(value.hard) || value.hard < minimumHard) {
+    return { error: `${label}.hard must be an integer >= ${minimumHard}.` };
   }
   if (value.soft !== undefined && (typeof value.soft !== "number" || !Number.isInteger(value.soft) || value.soft < 1)) {
     return { error: `${label}.soft must be an integer >= 1 when provided.` };
@@ -62,11 +64,11 @@ export function toolBudgetBlockedMessage(budget, toolName, toolCount) {
 export function encodeToolBudgetEnv(budget) {
   return budget ? JSON.stringify(budget) : undefined;
 }
-export function decodeToolBudgetEnv(value) {
+export function decodeToolBudgetEnv(value, options = {}) {
   if (!value?.trim())
     return;
   const parsed = JSON.parse(value);
-  const normalized = validateToolBudgetConfig(parsed, TOOL_BUDGET_ENV);
+  const normalized = validateToolBudgetConfig(parsed, TOOL_BUDGET_ENV, options.allowZero ? { minimumHard: 0 } : undefined);
   if (normalized.error)
     throw new Error(normalized.error);
   return normalized.budget;

package/extensions/dm-subagents/src/runs/shared/tool-timeout.js

@@ -0,0 +1,64 @@
+export const TOOL_TIMEOUT_ENV = "DM_SUBAGENT_TOOL_TIMEOUT_MS";
+const MAX_TIMER_DELAY_MS = 2147483647;
+export const DEFAULT_FAST_TOOL_TIMEOUT_MS = 300000;
+export const DEFAULT_FAST_TOOL_TIMEOUT_TOOLS = new Set([
+  "read",
+  "grep",
+  "find",
+  "ls",
+  "edit",
+  "write",
+  "structured_output"
+]);
+export const TOOL_TIMEOUT_EXEMPT_TOOLS = new Set(["contact_supervisor", "intercom", "bg_wait", "subagent_wait"]);
+export const TOOL_TIMEOUT_ALLOWLIST = TOOL_TIMEOUT_EXEMPT_TOOLS;
+export function isToolTimeoutExempt(toolName) {
+  return toolName !== undefined && TOOL_TIMEOUT_EXEMPT_TOOLS.has(toolName);
+}
+export function defaultToolTimeoutMs(toolName) {
+  return toolName !== undefined && DEFAULT_FAST_TOOL_TIMEOUT_TOOLS.has(toolName) ? DEFAULT_FAST_TOOL_TIMEOUT_MS : undefined;
+}
+export function effectiveToolTimeoutMs(toolName, configuredToolTimeoutMs) {
+  if (isToolTimeoutExempt(toolName))
+    return;
+  return configuredToolTimeoutMs ?? defaultToolTimeoutMs(toolName);
+}
+export function formatToolTimeoutMessage(toolName, timeoutMs) {
+  return `Tool '${toolName}' exceeded its timeout of ${timeoutMs}ms.`;
+}
+export function toolTimeoutCallKey(event, fallbackId) {
+  return typeof event.toolCallId === "string" && event.toolCallId.length > 0 ? `id:${event.toolCallId}` : `anon:${String(event.toolName ?? "tool")}:${fallbackId}`;
+}
+export function resolveToolTimeoutMs(input) {
+  const candidates = [
+    { label: "toolTimeoutMs", value: input.callValue },
+    { label: "agent.toolTimeoutMs", value: input.agentValue },
+    { label: "config.toolTimeoutMs", value: input.configValue }
+  ];
+  let winner;
+  for (const candidate of candidates) {
+    if (candidate.value === undefined)
+      continue;
+    winner = candidate;
+    break;
+  }
+  if (winner === undefined && input.envValue !== undefined && input.envValue.trim() !== "") {
+    winner = { label: TOOL_TIMEOUT_ENV, value: input.envValue };
+  }
+  if (winner === undefined)
+    return {};
+  let raw = winner.value;
+  let parsed;
+  if (winner.label === TOOL_TIMEOUT_ENV && typeof raw === "string") {
+    parsed = Number(raw);
+    if (raw.trim() !== "" && !Number.isNaN(parsed))
+      raw = parsed;
+  }
+  if (typeof raw !== "number" || !Number.isInteger(raw) || raw <= 0 || raw > MAX_TIMER_DELAY_MS) {
+    return { error: `${winner.label} must be a positive integer no larger than ${MAX_TIMER_DELAY_MS}.` };
+  }
+  return { toolTimeoutMs: raw };
+}
+export function toolTimeoutFromEnv(env = process.env) {
+  return env[TOOL_TIMEOUT_ENV];
+}

package/extensions/dm-subagents/src/runs/shared/usage-budget.js

@@ -0,0 +1,74 @@
+function validateLimit(value, label) {
+  if (!value || typeof value !== "object" || Array.isArray(value))
+    return { error: `${label} must be an object.` };
+  const raw = value;
+  const unknown = Object.keys(raw).find((key) => key !== "soft" && key !== "hard");
+  if (unknown)
+    return { error: `${label}.${unknown} is not supported.` };
+  if (typeof raw.hard !== "number" || !Number.isFinite(raw.hard) || raw.hard <= 0)
+    return { error: `${label}.hard must be a positive number.` };
+  if (raw.soft !== undefined && (typeof raw.soft !== "number" || !Number.isFinite(raw.soft) || raw.soft <= 0))
+    return { error: `${label}.soft must be a positive number.` };
+  if (typeof raw.soft === "number" && raw.soft > raw.hard)
+    return { error: `${label}.soft must be less than or equal to ${label}.hard.` };
+  return { limit: { ...typeof raw.soft === "number" ? { soft: raw.soft } : {}, hard: raw.hard } };
+}
+export function validateUsageBudgetConfig(value, label = "usageBudget") {
+  if (value === undefined)
+    return {};
+  if (!value || typeof value !== "object" || Array.isArray(value))
+    return { error: `${label} must be an object.` };
+  const raw = value;
+  const unknown = Object.keys(raw).find((key) => key !== "tokens" && key !== "costUsd");
+  if (unknown)
+    return { error: `${label}.${unknown} is not supported.` };
+  const budget = {};
+  if (raw.tokens !== undefined) {
+    const tokens = validateLimit(raw.tokens, `${label}.tokens`);
+    if (tokens.error)
+      return { error: tokens.error };
+    budget.tokens = tokens.limit;
+  }
+  if (raw.costUsd !== undefined) {
+    const costUsd = validateLimit(raw.costUsd, `${label}.costUsd`);
+    if (costUsd.error)
+      return { error: costUsd.error };
+    budget.costUsd = costUsd.limit;
+  }
+  if (!budget.tokens && !budget.costUsd)
+    return { error: `${label} must include tokens or costUsd.` };
+  return { budget };
+}
+function metricState(limit, used) {
+  if (!limit)
+    return;
+  return {
+    ...limit,
+    used,
+    outcome: used >= limit.hard ? "hard-exceeded" : limit.soft !== undefined && used >= limit.soft ? "soft-exceeded" : "within-budget"
+  };
+}
+export function usageBudgetState(config, totals) {
+  if (!config)
+    return;
+  const inputTokens = totals?.inputTokens ?? 0;
+  const outputTokens = totals?.outputTokens ?? 0;
+  const tokens = metricState(config.tokens, inputTokens + outputTokens);
+  const costUsd = metricState(config.costUsd, totals?.costUsd ?? 0);
+  const reason = tokens?.outcome === "hard-exceeded" ? "tokens" : costUsd?.outcome === "hard-exceeded" ? "costUsd" : undefined;
+  return {
+    version: 1,
+    source: "reported",
+    ...tokens ? { tokens } : {},
+    ...costUsd ? { costUsd } : {},
+    exhausted: reason !== undefined,
+    ...reason ? { reason } : {}
+  };
+}
+export function usageBudgetExceededMessage(state) {
+  if (state.reason === "tokens" && state.tokens)
+    return `Usage budget exhausted: reported tokens ${state.tokens.used} reached hard limit ${state.tokens.hard}.`;
+  if (state.reason === "costUsd" && state.costUsd)
+    return `Usage budget exhausted: reported cost $${state.costUsd.used.toFixed(6)} reached hard limit $${state.costUsd.hard.toFixed(6)}.`;
+  return "Usage budget exhausted.";
+}

package/extensions/dm-subagents/src/runs/shared/workflow-graph.js

@@ -1,4 +1,22 @@
 import { isDynamicParallelStep, isParallelStep } from "../../shared/settings.js";
+export function workflowGraphStageNodes(graph) {
+  const nodes = graph?.nodes;
+  if (!nodes?.length)
+    return [];
+  const stages = [];
+  const visit = (node) => {
+    if (node.kind === "parallel-group" || node.kind === "dynamic-parallel-group") {
+      for (const child of node.children ?? [])
+        visit(child);
+      return;
+    }
+    if (node.kind !== "host-step")
+      stages.push(node);
+  };
+  for (const node of nodes)
+    visit(node);
+  return stages;
+}
 function normalizeStatus(status) {
   switch (status) {
     case "complete":
@@ -12,6 +30,8 @@ function normalizeStatus(status) {
       return "paused";
     case "detached":
       return "detached";
+    case "rejected":
+      return "rejected";
     case "pending":
       return "pending";
     default:
@@ -46,6 +66,8 @@ function seqLabel(step, stepIndex) {
 function summarizeParallelStatuses(statuses) {
   if (statuses.some((status) => status === "running"))
     return "running";
+  if (statuses.some((status) => status === "rejected"))
+    return "rejected";
   if (statuses.some((status) => status === "failed"))
     return "failed";
   if (statuses.some((status) => status === "paused"))