@duckmind/dm-linux-x64 0.65.5 → 0.65.6

package/extensions/dm-subagents/src/runs/shared/host-step-status.js

@@ -143,6 +143,8 @@ export function assertWorkflowGraphHostSteps(graph, source = "status", expectedR
     return;
   if (expectedRunId !== undefined && graph.runId !== expectedRunId)
     throw new Error(`Invalid host step '${source}': workflowGraph.runId does not match the status run id.`);
+  if (!Array.isArray(graph.nodes))
+    throw new Error(`Invalid host step '${source}.workflowGraph': nodes must be an array.`);
   const hostStepCount = graph.nodes.filter((node) => node.kind === "host-step").length;
   if (hostStepCount > HOST_STEP_MAX_COUNT)
     throw new Error(`Invalid host step '${source}': workflowGraph contains more than ${HOST_STEP_MAX_COUNT} host steps.`);

package/extensions/dm-subagents/src/runs/shared/lane-metadata.js

@@ -6,6 +6,7 @@ export const WORKFLOW_LANE_OUTPUT_PATH_MAX_BYTES = 256;
 export const WORKFLOW_LANE_OUTPUT_PATHS_MAX = 10;
 export const WORKTREE_STATUS_PATH_MAX_BYTES = 4096;
 export const WORKTREE_STATUS_BRANCH_MAX_BYTES = 256;
+export const WORKTREE_STATUS_NAMING_LABEL_MAX_BYTES = 256;
 const WORKFLOW_LANE_KEY_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/;
 const WORKFLOW_LANE_MODES = new Set(["mutation", "review", "scout", "gate"]);
 function byteLength(value) {
@@ -74,14 +75,33 @@ export function assertWorkflowLaneKey(lane, workflowKey, label = "lane") {
   if (lane.key !== workflowKey)
     throw new Error(`${label}.key '${lane.key}' does not match workflow key '${workflowKey}'.`);
 }
+function normalizeWorktreeNaming(value, label) {
+  assertPlainObject(value, label);
+  assertKnownFields(value, ["requestedBranch", "branchPrefix", "label", "sanitizedPathComponent", "collision", "collisionSuffix"], label);
+  const collision = value.collision;
+  if (collision !== undefined && collision !== "branch" && collision !== "path" && collision !== "both")
+    throw new Error(`${label}.collision is invalid.`);
+  return {
+    requestedBranch: boundedNonEmptyString(value.requestedBranch, `${label}.requestedBranch`, WORKTREE_STATUS_BRANCH_MAX_BYTES),
+    branchPrefix: boundedNonEmptyString(value.branchPrefix, `${label}.branchPrefix`, WORKTREE_STATUS_BRANCH_MAX_BYTES),
+    label: boundedNonEmptyString(value.label, `${label}.label`, WORKTREE_STATUS_NAMING_LABEL_MAX_BYTES),
+    sanitizedPathComponent: boundedNonEmptyString(value.sanitizedPathComponent, `${label}.sanitizedPathComponent`, WORKTREE_STATUS_NAMING_LABEL_MAX_BYTES),
+    ...collision !== undefined ? { collision } : {},
+    ...value.collisionSuffix !== undefined ? { collisionSuffix: boundedNonEmptyString(value.collisionSuffix, `${label}.collisionSuffix`, WORKTREE_STATUS_NAMING_LABEL_MAX_BYTES) } : {}
+  };
+}
 export function normalizeWorktreeStatusReference(value, label = "worktree status reference") {
   if (value === undefined)
     return;
   assertPlainObject(value, label);
-  assertKnownFields(value, ["worktreePath", "branch"], label);
+  assertKnownFields(value, ["worktreePath", "branch", "provider", "naming"], label);
+  if (value.provider !== undefined && value.provider !== "native" && value.provider !== "worktrunk")
+    throw new Error(`${label}.provider is invalid.`);
   return {
     worktreePath: boundedNonEmptyString(value.worktreePath, `${label}.worktreePath`, WORKTREE_STATUS_PATH_MAX_BYTES),
-    branch: boundedNonEmptyString(value.branch, `${label}.branch`, WORKTREE_STATUS_BRANCH_MAX_BYTES)
+    branch: boundedNonEmptyString(value.branch, `${label}.branch`, WORKTREE_STATUS_BRANCH_MAX_BYTES),
+    ...value.provider !== undefined ? { provider: value.provider } : {},
+    ...value.naming !== undefined ? { naming: normalizeWorktreeNaming(value.naming, `${label}.naming`) } : {}
   };
 }
 export function validateAsyncStatusLaneMetadata(status, label = "async status") {
@@ -99,6 +119,6 @@ export function validateAsyncStatusLaneMetadata(status, label = "async status")
     if (hasPath !== hasBranch)
       throw new Error(`${label}.steps[${index}] must include both worktreePath and branch.`);
     if (hasPath)
-      normalizeWorktreeStatusReference({ worktreePath: step.worktreePath, branch: step.branch }, `${label}.steps[${index}]`);
+      normalizeWorktreeStatusReference({ worktreePath: step.worktreePath, branch: step.branch, ...step.provider ? { provider: step.provider } : {}, ...step.naming ? { naming: step.naming } : {} }, `${label}.steps[${index}]`);
   }
 }

package/extensions/dm-subagents/src/runs/shared/mcp-direct-tool-allowlist.js

@@ -38,9 +38,10 @@ export function resolveMcpDirectToolResolution(mcpDirectTools, cwd = process.cwd
   const runtimeServers = resolveRuntimeMcpServers(config, runtimeSelectionServers, runtimeSnapshotHost);
   const resolvedConfig = Object.keys(runtimeServers).length > 0 ? mergeConfigs(config, { mcpServers: runtimeServers }) : config;
   validateSelectedServerDefinitions(resolvedConfig, selectors);
+  const runtime = Object.keys(runtimeServers).length > 0 ? { mcpConfig: resolvedConfig, runtimeServerNames: Object.keys(runtimeServers) } : {};
   const cache = loadMetadataCache();
   if (!cache)
-    return { selections: [], unresolvedSelectors: selectors };
+    return { selections: [], unresolvedSelectors: selectors, ...runtime };
   const validMetadata = {};
   for (const [serverName, definition] of Object.entries(resolvedConfig.mcpServers)) {
     const serverCache = cache.servers[serverName];
@@ -56,7 +57,7 @@ export function resolveMcpDirectToolResolution(mcpDirectTools, cwd = process.cwd
   return {
     selections: grant.selections,
     unresolvedSelectors: grant.unresolvedSelectors,
-    ...Object.keys(runtimeServers).length > 0 ? { mcpConfig: resolvedConfig, runtimeServerNames: Object.keys(runtimeServers) } : {}
+    ...runtime
   };
 }
 export function resolveMcpDirectToolSelections(mcpDirectTools, cwd = process.cwd(), runtimeSnapshotHost) {
@@ -208,7 +209,7 @@ function parseServerEntries(value) {
 function parseSettings(value) {
   if (!isRecord(value))
     return;
-  const toolPrefix = value.toolPrefix === "server" || value.toolPrefix === "short" || value.toolPrefix === "none" ? value.toolPrefix : undefined;
+  const toolPrefix = value.toolPrefix === "server" || value.toolPrefix === "short" || value.toolPrefix === "none" || value.toolPrefix === "mcp" ? value.toolPrefix : undefined;
   const directTools = typeof value.directTools === "boolean" ? value.directTools : undefined;
   const settings = {
     ...toolPrefix ? { toolPrefix } : {},

package/extensions/dm-subagents/src/runs/shared/mcp-direct-tool-grant.js

@@ -28,7 +28,6 @@ export function planMcpDirectToolGrant(input) {
   const { servers: selectedServers, tools: selectedTools } = parseMcpDirectToolSelectors(selectors);
   const selections = [];
   const seenNames = new Set;
-  const prefix = normalizeMcpToolPrefix(input.toolPrefix);
   for (const [serverName, server] of Object.entries(input.servers)) {
     const metadata = input.metadata[serverName];
     if (!metadata)
@@ -36,6 +35,7 @@ export function planMcpDirectToolGrant(input) {
     const toolFilter = selectedServers.has(serverName) ? true : selectedTools.get(serverName);
     if (!toolFilter)
       continue;
+    const prefix = normalizeMcpToolPrefix(server.toolPrefix ?? input.toolPrefix);
     for (const tool of Array.isArray(metadata.tools) ? metadata.tools : []) {
       if (typeof tool?.name !== "string" || !tool.name)
         continue;
@@ -70,7 +70,7 @@ export function planMcpDirectToolGrant(input) {
   return { selections, unresolvedSelectors };
 }
 export function normalizeMcpToolPrefix(value) {
-  return value === "none" || value === "short" || value === "server" ? value : "server";
+  return value === "none" || value === "short" || value === "mcp" || value === "server" ? value : "server";
 }
 export function formatUnresolvedMcpDirectToolSelectors(selectors) {
   return `Unresolved MCP direct-tool selectors: ${selectors.join(", ")}. Direct MCP tools require a matching configured server and fresh metadata cache; runtime-registered servers require a host/dm-mcp-adapter handoff before child launch.`;
@@ -79,12 +79,21 @@ function getServerPrefix(serverName, mode) {
   if (mode === "none")
     return "";
   if (mode === "short")
-    return serverName.replace(/-?mcp$/i, "") || "mcp";
-  return serverName;
+    return sanitizeServerPrefix(serverName.replace(/-?mcp$/i, "")) || "mcp";
+  if (mode === "mcp")
+    return `mcp__${sanitizeServerPrefix(serverName)}`;
+  return sanitizeServerPrefix(serverName);
+}
+function sanitizeServerPrefix(serverName) {
+  return Array.from(serverName, (char) => /^[A-Za-z0-9_-]$/.test(char) ? char : `_${char.codePointAt(0).toString(16)}_`).join("");
 }
 function formatToolName(toolName, serverName, prefix) {
   const serverPrefix = getServerPrefix(serverName, prefix);
-  return serverPrefix ? `${serverPrefix}_${toolName}` : toolName;
+  const sanitized = toolName.replace(/\./g, "_");
+  if (serverPrefix && sanitized.startsWith(`${serverPrefix}_`) && sanitized.length > serverPrefix.length + 1) {
+    return sanitized;
+  }
+  return serverPrefix ? `${serverPrefix}_${sanitized}` : sanitized;
 }
 function isToolAllowed(toolName, serverName, prefix, includeTools, excludeTools) {
   const candidates = toolNameCandidates(toolName, serverName, prefix);
@@ -97,6 +106,7 @@ function toolNameCandidates(toolName, serverName, prefix) {
     formatToolName(toolName, serverName, prefix),
     formatToolName(toolName, serverName, "server"),
     formatToolName(toolName, serverName, "short"),
+    formatToolName(toolName, serverName, "mcp"),
     formatToolName(toolName, serverName, "none")
   ]);
 }

package/extensions/dm-subagents/src/runs/shared/model-resolution-diagnostic.js

@@ -0,0 +1,43 @@
+const MODEL_RESOLUTION_FAILURE_PATTERNS = [
+  /^Model .+ not found\b/i,
+  /^Unknown provider "/i
+];
+export function isChildModelResolutionFailure(error) {
+  const text = typeof error === "string" ? error.trim() : "";
+  return MODEL_RESOLUTION_FAILURE_PATTERNS.some((pattern) => pattern.test(text));
+}
+function capabilityCeilingDeniesExtensions(diagnostic) {
+  return diagnostic.capabilityCeiling?.denyExtensions === true;
+}
+function denyExtensionsClause(diagnostic) {
+  const sources = diagnostic.capabilityCeiling?.sources ?? [];
+  return `Capability ceiling from ${sources.length > 0 ? sources.join(", ") : "an unnamed source"} denies extensions`;
+}
+export function formatChildModelResolutionDiagnostic(diagnostic) {
+  const subject = diagnostic.agent ? `Agent '${diagnostic.agent}'` : "Subagent";
+  const model = diagnostic.model ? `'${diagnostic.model}'` : "this model";
+  if (capabilityCeilingDeniesExtensions(diagnostic)) {
+    return (diagnostic.host === "parent" ? [
+      `${subject} ran as a foreground child, which never loads the parent's ambient extensions.`,
+      `${denyExtensionsClause(diagnostic)}, so if ${model} is served by a provider extension, that extension cannot load for this child: \`async: true\` does not help either, and listed \`subagentOnlyExtensions\` or \`extensions\` entries are suppressed.`,
+      "Relax the capability ceiling to allow extensions, or use a model that the parent's model registry already resolves."
+    ] : [
+      `${subject} ran as a background child without the ambient extensions.`,
+      `${denyExtensionsClause(diagnostic)}, so if ${model} is served by a provider extension, that extension cannot load for this child: listed \`subagentOnlyExtensions\` or \`extensions\` entries are suppressed, and leaving \`extensions\` unset does not enable ambient loading.`,
+      "Relax the capability ceiling to allow extensions, or use a model that the child's model registry already resolves."
+    ]).join(`
+`);
+  }
+  if (diagnostic.host === "parent") {
+    return [
+      `${subject} ran as a foreground child, which never loads the parent's ambient extensions but inherits the providers they registered.`,
+      `If ${model} is served by a provider extension, check the parent's \`/model\` list and the child extension diagnostics, or load the extension for this child with \`subagentOnlyExtensions\` or \`extensions\` in the agent frontmatter.`
+    ].join(`
+`);
+  }
+  return [
+    `${subject} ran as a background child without the ambient extensions.`,
+    `If ${model} is served by a provider extension, that extension is not loaded for this child: list it in \`subagentOnlyExtensions\` or \`extensions\` in the agent frontmatter, or leave \`extensions\` unset so the child loads the ambient extensions.`
+  ].join(`
+`);
+}

package/extensions/dm-subagents/src/runs/shared/{model-fallback.js → model-resolution.js}

@@ -1,14 +1,13 @@
-import { splitKnownThinkingSuffix } from "../../shared/model-info.js";
-import { filterFallbackCandidates, findModelExclusion, parseModelKey, recordModelFailure } from "./model-exclusions.js";
+import { splitKnownThinkingSuffix as splitThinkingSuffix } from "../../shared/model-info.js";
 import { checkModelScope } from "./model-scope.js";
-import { redactSecretValues } from "./permissions.js";
-export function splitThinkingSuffix(model) {
-  return splitKnownThinkingSuffix(model);
-}
-export function formatSubagentModelVerificationError(expectedModel, observedModel, availableModels) {
+
+export { splitThinkingSuffix };
+export function formatSubagentModelVerificationError(expectedModel, observedModel, availableModels, modelResponseAliases) {
   if (!availableModels || availableModels.length === 0)
     return;
   const expectedBase = splitThinkingSuffix(expectedModel).baseModel;
+  if (modelResponseAliases && Object.hasOwn(modelResponseAliases, expectedBase) && modelResponseAliases[expectedBase]?.includes(observedModel))
+    return;
   const observedBase = splitThinkingSuffix(observedModel).baseModel;
   if (expectedBase === observedBase)
     return;
@@ -21,7 +20,7 @@ export function formatSubagentModelVerificationError(expectedModel, observedMode
     if (expectedIdLeaf === observedBase || expectedFullIdLeaf === observedBase)
       return;
   }
-  return `model_verification_failed: child reported a different model than the launch candidate. Expected '${expectedModel}' but observed '${observedModel}'.`;
+  return `model_verification_failed: native DM child reported a different model than the launch candidate. Expected '${expectedModel}' but observed '${observedModel}'. If you have independently verified this response ID identifies the requested model, declare the exact mapping in modelResponseAliases in ~/.dm/agent/extensions/subagent/config.json (see docs/configuration.md#modelresponsealiases). Use the resolved provider/model ID without its thinking suffix as the key. This leaves the outgoing request unchanged. Configuration changes affect new independent native runs; resumed native runs retain their launch-time declaration. External CLI adapters do not use this setting.`;
 }
 export const INHERIT_MODEL = "inherit";
 export function normalizeParentModel(model) {
@@ -193,29 +192,28 @@ function enforceModelScopes(model, scope, source, onWarn) {
   for (const violation of violations)
     (onWarn ?? defaultScopeWarn)(violation);
 }
-function throwForExplicitModelExclusion(model) {
-  const exclusion = findModelExclusion(model);
-  if (!exclusion)
-    return;
-  const reason = redactSecretValues((exclusion.reason ?? "runtime-failure").replace(/[\u0000-\u001f\u007f]+/g, " ")).slice(0, 240);
-  const expiry = Number.isFinite(exclusion.expiresAt) ? `; expires: ${new Date(exclusion.expiresAt).toISOString()}` : "";
-  throw new Error(`Requested subagent model '${model}' is excluded and cannot be replaced by a fallback (reason: ${reason}${expiry}).`);
-}
 export function resolveSubagentModelOverride(requestedModel, parentModel, availableModels, preferredProvider, options) {
   const trimmed = typeof requestedModel === "string" ? requestedModel.trim() : "";
   const explicit = trimmed && trimmed !== INHERIT_MODEL ? trimmed : undefined;
   if (!parentModel)
     throwForUnresolvedEnforcedInheritScope(options?.scope, explicit === undefined || options?.source === "inherited");
   let resolved;
+  let resolvedFromRegistry = explicit === undefined;
   if (explicit === undefined) {
     resolved = parentModel ? `${parentModel.provider}/${parentModel.id}` : undefined;
   } else {
-    resolved = resolveRequiredSubagentModelCandidate(explicit, availableModels, preferredProvider);
-  }
-  if (resolved && explicit !== undefined && options?.source === "explicit") {
-    throwForExplicitModelExclusion(resolved);
+    const candidate = resolveSubagentModelCandidate(explicit, availableModels, preferredProvider);
+    if (options?.source === "explicit") {
+      resolved = candidate ?? resolveRequiredSubagentModelCandidate(explicit, availableModels, preferredProvider);
+      resolvedFromRegistry = true;
+    } else if (candidate) {
+      resolved = candidate;
+      resolvedFromRegistry = true;
+    } else {
+      resolved = explicit;
+    }
   }
-  if (resolved && options?.scope) {
+  if (resolved && options?.scope && resolvedFromRegistry) {
     const source = explicit === undefined ? "inherited" : options.source ?? "inherited";
     enforceModelScopes(resolved, options.scope, source, options.onWarn);
   }
@@ -228,115 +226,37 @@ export function resolveEffectiveSubagentModel(explicitModel, agentModel, parentM
     return resolved;
   return resolveSubagentModelOverride(agentModel, parentModel, availableModels, preferredProvider, { ...options, source: options?.source ?? "inherited" });
 }
+export function resolveModelOrigin(input) {
+  if (input.storedOrigin)
+    return input.storedOrigin;
+  if (input.fromParent)
+    return "inherited";
+  if (inheritsParentModel(input.explicitModel, input.agentModel, input.parentModel))
+    return "inherited";
+  const trimmed = typeof input.explicitModel === "string" ? input.explicitModel.trim() : "";
+  return trimmed && trimmed !== INHERIT_MODEL ? "explicit" : "configured";
+}
 export function inheritsParentModel(explicitModel, agentModel, parentModel) {
   const requestedModel = explicitModel ?? agentModel;
   const trimmed = typeof requestedModel === "string" ? requestedModel.trim() : "";
   return Boolean(parentModel && (!trimmed || trimmed === INHERIT_MODEL));
 }
-export function buildModelCandidates(primaryModel, fallbackModels, availableModels, preferredProvider, options) {
-  if (!primaryModel)
+export function resolveModelSelection(model, availableModels, preferredProvider, options) {
+  if (!model)
     throwForUnresolvedEnforcedInheritScope(options?.scope, true);
-  const seen = new Set;
-  const candidates = [];
-  const rawCandidates = [primaryModel, ...fallbackModels ?? []];
-  for (let index = 0;index < rawCandidates.length; index++) {
-    const raw = rawCandidates[index];
-    if (!raw)
-      continue;
-    const model = raw.trim();
-    const normalized = index === 0 ? options?.primaryModelFromParent ? model : resolveRequiredSubagentModelCandidate(model, availableModels, preferredProvider) : resolveSubagentModelCandidate(model, availableModels, preferredProvider);
-    if (!normalized) {
-      console.warn(`[dm-subagents] Skipping fallback model '${model}' because it is unavailable in this environment.`);
-      continue;
-    }
-    if (seen.has(normalized))
-      continue;
-    const scopes = configuredScopes(options?.scope);
-    if (index > 0 || scopes.some((scope) => scope.enforce === true && scope.strict === true)) {
-      enforceModelScopes(normalized, scopes, "inherited", options?.onWarn);
-    }
-    seen.add(normalized);
-    candidates.push(normalized);
+  const origin = options?.origin ?? (options?.primaryModelFromParent ? "inherited" : "configured");
+  const requestedModel = origin === "inherited" ? undefined : model;
+  const scopes = configuredScopes(options?.scope);
+  if (origin === "explicit" && model) {
+    const normalized = resolveRequiredSubagentModelCandidate(model.trim(), availableModels, preferredProvider);
+    enforceModelScopes(normalized, scopes, "explicit", options?.onWarn);
+    model = normalized;
   }
-  return filterFallbackCandidates(candidates, {
-    onExcluded(candidate, exclusion) {
-      const reason = redactSecretValues((exclusion.reason ?? "runtime-failure").replace(/[\u0000-\u001f\u007f]+/g, " ")).slice(0, 240);
-      console.warn(`[dm-subagents] Skipping model '${candidate}' due to a cached exclusion (reason: ${reason}; expires: ${new Date(exclusion.expiresAt).toISOString()}).`);
-    }
-  });
-}
-const RETRYABLE_MODEL_FAILURE_PATTERNS = [
-  /rate\s*limit/i,
-  /usage\s*limit/i,
-  /too many requests/i,
-  /\b429\b/,
-  /quota/i,
-  /billing/i,
-  /credit/i,
-  /auth(?:entication)?/i,
-  /unauthori[sz]ed/i,
-  /forbidden/i,
-  /api key/i,
-  /token expired/i,
-  /invalid key/i,
-  /provider.*unavailable/i,
-  /model.*unavailable/i,
-  /model.*disabled/i,
-  /model.*not found/i,
-  /unknown model/i,
-  /overloaded/i,
-  /service unavailable/i,
-  /temporar(?:ily)? unavailable/i,
-  /connection\s+(?:error|reset|closed|aborted)/i,
-  /connection refused/i,
-  /fetch failed/i,
-  /network error/i,
-  /socket hang up/i,
-  /stream ended without finish_reason/i,
-  /upstream/i,
-  /timed? out/i,
-  /timeout/i,
-  /\b500\b/,
-  /\b502\b/,
-  /\b503\b/,
-  /\b504\b/,
-  /internal server error/i,
-  /cold.?start/i,
-  /empty response/i,
-  /no output/i,
-  /model.*(?:load|fail|error)/i
-];
-const TOOL_FAILURE_PREFIX = /^[\w.:@/-]+ failed (?:(?:\(exit \d+\):)|(?:with exit code \d+))(?:\s|$)/i;
-export function isRetryableModelFailure(error) {
-  if (!error)
-    return false;
-  if (TOOL_FAILURE_PREFIX.test(error.trim()))
-    return false;
-  return RETRYABLE_MODEL_FAILURE_PATTERNS.some((pattern) => pattern.test(error));
-}
-function messageError(message) {
-  if (!message || typeof message !== "object")
-    return;
-  const value = message.errorMessage;
-  return typeof value === "string" ? value : undefined;
-}
-export function isRetryableModelFailureAttempt(input) {
-  if (!isRetryableModelFailure(input.error))
-    return false;
-  if ((input.toolCount ?? 0) > 0)
-    return false;
-  if (input.error === "Subagent produced no output (possible model cold-start or empty response)." || /^Subagent produced no output after terminal assistant stopReason "[^"]+"\.$/.test(input.error ?? ""))
-    return true;
-  if ((input.toolCount ?? 0) === 0 && (input.messages?.length ?? 0) === 0)
-    return true;
-  const error = input.error?.trim();
-  return Boolean(error && input.messages?.some((message) => messageError(message)?.trim() === error));
-}
-export function recordRetryableModelFailure(model, error) {
-  if (!model || !isRetryableModelFailure(error))
-    return;
-  const { provider, modelId } = parseModelKey(model);
-  recordModelFailure({ modelId, reason: error, ...provider ? { provider } : {} });
+  const resolved = model && (origin === "inherited" || origin === "explicit" || options?.primaryModelFromParent) ? model.trim() : model ? resolveRequiredSubagentModelCandidate(model.trim(), availableModels, preferredProvider) : undefined;
+  if (resolved && scopes.some((scope) => scope.enforce === true && scope.strict === true)) {
+    enforceModelScopes(resolved, scopes, "inherited", options?.onWarn);
+  }
+  return { ...resolved ? { model: resolved } : {}, ...requestedModel ? { requestedModel } : {} };
 }
 const CONTEXT_OVERFLOW_PATTERNS = [
   /context(?: length| window| limit)? (?:exceed|overflow|too long)/i,
@@ -354,11 +274,7 @@ const CONTEXT_OVERFLOW_PATTERNS = [
 export function isContextOverflow(error) {
   if (!error)
     return false;
-  if (TOOL_FAILURE_PREFIX.test(error.trim()))
+  if (/^[\w.:@/-]+ failed (?:(?:\(exit \d+\):)|(?:with exit code \d+))(?:\s|$)/i.test(error.trim()))
     return false;
   return CONTEXT_OVERFLOW_PATTERNS.some((pattern) => pattern.test(error));
 }
-export function formatModelAttemptNote(attempt, nextModel) {
-  const failure = attempt.error?.trim() || `exit ${attempt.exitCode ?? 1}`;
-  return nextModel ? `[fallback] ${attempt.model} failed: ${failure}. Retrying with ${nextModel}.` : `[fallback] ${attempt.model} failed: ${failure}.`;
-}

package/extensions/dm-subagents/src/runs/shared/nested-events.js

@@ -5,17 +5,7 @@ import {
   DIRS,
   TEMP_ROOT_DIR
 } from "../../shared/types.js";
-import { isSafeNestedPathId, parseNestedPathEnv, sanitizeNestedPath } from "./nested-path.js";
-import {
-  SUBAGENT_PARENT_CAPABILITY_TOKEN_ENV,
-  SUBAGENT_PARENT_CHILD_INDEX_ENV,
-  SUBAGENT_PARENT_CONTROL_INBOX_ENV,
-  SUBAGENT_PARENT_DEPTH_ENV,
-  SUBAGENT_PARENT_EVENT_SINK_ENV,
-  SUBAGENT_PARENT_PATH_ENV,
-  SUBAGENT_PARENT_ROOT_RUN_ID_ENV,
-  SUBAGENT_PARENT_RUN_ID_ENV
-} from "./dm-args.js";
+import { isSafeNestedPathId, sanitizeNestedPath } from "./nested-path.js";
 import { writeAtomicJson } from "../../shared/atomic-json.js";
 import { sanitizeProcessTerminal } from "../background/process-terminal.js";
 import { THINKING_LEVELS } from "../../shared/model-info.js";
@@ -78,14 +68,8 @@ export function createNestedRoute(rootRunId) {
   writeAtomicJson(path.join(routeRoot, ROUTE_FILE), { rootRunId, capabilityToken, createdAt });
   return { rootRunId, eventSink, controlInbox, capabilityToken };
 }
-export function resolveNestedRouteFromEnv(env = process.env) {
-  const rootRunId = env[SUBAGENT_PARENT_ROOT_RUN_ID_ENV];
-  const eventSink = env[SUBAGENT_PARENT_EVENT_SINK_ENV];
-  const controlInbox = env[SUBAGENT_PARENT_CONTROL_INBOX_ENV];
-  const capabilityToken = env[SUBAGENT_PARENT_CAPABILITY_TOKEN_ENV];
-  if (!rootRunId || !eventSink || !controlInbox || !capabilityToken)
-    return;
-  const route = { rootRunId, eventSink, controlInbox, capabilityToken };
+export function resolveNestedRoute(route) {
+  const { rootRunId, capabilityToken } = route;
   validateRouteShape(route);
   const routeFile = path.join(commonRouteRoot(route), ROUTE_FILE);
   const metadata = JSON.parse(fs.readFileSync(routeFile, "utf-8"));
@@ -94,24 +78,28 @@ export function resolveNestedRouteFromEnv(env = process.env) {
   }
   return route;
 }
-export function resolveInheritedNestedRouteFromEnv(env = process.env) {
+export function resolveInheritedNestedRoute(route) {
   try {
-    return resolveNestedRouteFromEnv(env);
+    return resolveNestedRoute(route);
   } catch (error) {
     console.error("Ignoring invalid nested subagent event route:", error);
     return;
   }
 }
-export function resolveNestedParentAddressFromEnv(env = process.env) {
-  const parentRunId = env[SUBAGENT_PARENT_RUN_ID_ENV];
-  if (!isSafeNestedId(parentRunId))
+export function inheritedNestedRouteOf(runtime) {
+  return runtime?.nestedRoute ? resolveInheritedNestedRoute(runtime.nestedRoute) : undefined;
+}
+export function inheritedNestedParentAddressOf(runtime) {
+  const parent = runtime?.nestedParent;
+  if (!parent || !isSafeNestedId(parent.parentRunId))
     return;
-  const rawIndex = env[SUBAGENT_PARENT_CHILD_INDEX_ENV];
-  const parentStepIndex = rawIndex && /^\d+$/.test(rawIndex) ? Number(rawIndex) : undefined;
-  const depth = Math.min(Math.max(1, clampNumber(Number(env[SUBAGENT_PARENT_DEPTH_ENV])) ?? 1), MAX_DEPTH);
-  const parsedPath = parseNestedPathEnv(env[SUBAGENT_PARENT_PATH_ENV]);
-  const nestedPath = parsedPath.length ? parsedPath : [{ runId: parentRunId, ...parentStepIndex !== undefined ? { stepIndex: parentStepIndex } : {} }];
-  return { parentRunId, ...parentStepIndex !== undefined ? { parentStepIndex } : {}, depth, path: nestedPath };
+  const depth = Math.min(Math.max(1, clampNumber(parent.depth) ?? 1), MAX_DEPTH);
+  return {
+    parentRunId: parent.parentRunId,
+    ...parent.parentChildIndex !== undefined ? { parentStepIndex: parent.parentChildIndex } : {},
+    depth,
+    path: parent.path.length ? parent.path : [{ runId: parent.parentRunId, ...parent.parentChildIndex !== undefined ? { stepIndex: parent.parentChildIndex } : {} }]
+  };
 }
 export function resolveNestedAsyncDir(rootRunId, run) {
   if (!run.asyncDir)
@@ -162,10 +150,12 @@ function sanitizeLaunchResolvedExtensions(value) {
     disableAmbientExtensions: raw.disableAmbientExtensions,
     runtime: stringList(raw.runtime),
     configured: stringList(raw.configured),
+    required: Array.isArray(raw.required) ? raw.required.filter((item) => typeof item === "string" && /^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/.test(item)).slice(0, 32) : [],
     effective: stringList(raw.effective),
     omitted: {
       runtime: omittedCount("runtime"),
       configured: omittedCount("configured"),
+      required: omittedCount("required"),
       effective: omittedCount("effective")
     }
   };
@@ -218,7 +208,7 @@ function sanitizeTurnBudget(value) {
   };
 }
 function sanitizeState(value, fallback) {
-  return value === "queued" || value === "running" || value === "complete" || value === "failed" || value === "partial" || value === "paused" || value === "stopped" ? value : fallback;
+  return value === "queued" || value === "running" || value === "complete" || value === "failed" || value === "partial" || value === "paused" || value === "stopped" || value === "rejected" ? value : fallback;
 }
 function sanitizeStep(input, depth) {
   if (!input || typeof input !== "object")
@@ -227,7 +217,7 @@ function sanitizeStep(input, depth) {
   const agent = stringValue(raw.agent, 128);
   if (!agent)
     return;
-  const status = raw.status === "pending" || raw.status === "running" || raw.status === "complete" || raw.status === "completed" || raw.status === "failed" || raw.status === "paused" || raw.status === "stopped" ? raw.status : "pending";
+  const status = raw.status === "pending" || raw.status === "running" || raw.status === "complete" || raw.status === "completed" || raw.status === "failed" || raw.status === "partial" || raw.status === "paused" || raw.status === "stopped" || raw.status === "rejected" ? raw.status : "pending";
   const model = stringValue(raw.model);
   const thinking = THINKING_LEVELS.find((level) => level === raw.thinking);
   return {
@@ -370,7 +360,7 @@ export function parseNestedEventRecords(content, route) {
 `) ? undefined : -1).map((line) => line.trim() ? parseRecord(line, route) : undefined).filter((event) => Boolean(event));
 }
 function terminal(state) {
-  return state === "complete" || state === "failed" || state === "partial" || state === "paused" || state === "stopped";
+  return state === "complete" || state === "failed" || state === "partial" || state === "paused" || state === "rejected" || state === "stopped";
 }
 function mergeBoundedChildren(existing, incoming) {
   if (incoming === undefined)
@@ -535,6 +525,14 @@ export function findNestedRun(children, id) {
   }
   return;
 }
+export function retainNestedLookupRoute(state, route, sessionId) {
+  if (!route || !sessionId || sessionId !== state.currentSessionId)
+    return;
+  if (state.retainedNestedLookupRoutes?.sessionId !== sessionId) {
+    state.retainedNestedLookupRoutes = { sessionId, routes: new Map };
+  }
+  state.retainedNestedLookupRoutes.routes.set(route.rootRunId, route);
+}
 function collectNestedRuns(children, output = []) {
   for (const child of children ?? []) {
     output.push(child);
@@ -872,14 +870,6 @@ export function findNestedControlResult(route, requestId, targetRunId, ignoredFi
 export function readNestedControlResults(route) {
   return listNestedEventFiles(route).sort().flatMap((entry) => readControlResultsFromFile(route, path.join(route.eventSink, entry)));
 }
-export function nestedRouteEnv(route) {
-  return {
-    [SUBAGENT_PARENT_EVENT_SINK_ENV]: route.eventSink,
-    [SUBAGENT_PARENT_CONTROL_INBOX_ENV]: route.controlInbox,
-    [SUBAGENT_PARENT_ROOT_RUN_ID_ENV]: route.rootRunId,
-    [SUBAGENT_PARENT_CAPABILITY_TOKEN_ENV]: route.capabilityToken
-  };
-}
 export function attachRootChildrenToSteps(rootRunId, steps, children) {
   if (!steps?.length)
     return;
@@ -996,18 +986,18 @@ export function nestedSummaryFromAsyncStatus(status, asyncDir, fallback) {
     })).slice(0, MAX_STEPS) } : {}
   };
 }
-export function nestedArtifactEnv(rootRunId, parentRunId) {
-  return {
-    DM_SUBAGENT_NESTED_ROOT_RUN_ID: rootRunId,
-    DM_SUBAGENT_NESTED_PARENT_RUN_ID: parentRunId
-  };
-}
 export function isTopLevelAsyncDir(asyncDir) {
   const resolved = path.resolve(asyncDir);
   return containedPath(DIRS.async, resolved) && !containedPath(path.join(TEMP_ROOT_DIR, "nested-subagent-runs"), resolved);
 }
-export function nestedResultsPath(rootRunId, id) {
+export function nestedRunScope(rootRunId) {
   assertSafeId("rootRunId", rootRunId);
+  return {
+    asyncDirRoot: path.join(TEMP_ROOT_DIR, "nested-subagent-runs", rootRunId),
+    resultsDir: path.join(DIRS.results, "nested", rootRunId)
+  };
+}
+export function nestedResultsPath(rootRunId, id) {
   assertSafeId("id", id);
-  return path.join(DIRS.results, "nested", rootRunId, `${id}.json`);
+  return path.join(nestedRunScope(rootRunId).resultsDir, `${id}.json`);
 }

package/extensions/dm-subagents/src/runs/shared/nested-path.js

@@ -26,16 +26,3 @@ export function sanitizeNestedPath(value) {
     };
   }).filter((part) => Boolean(part)).slice(0, MAX_NESTED_PATH_ENTRIES);
 }
-export function parseNestedPathEnv(value) {
-  if (!value)
-    return [];
-  try {
-    return sanitizeNestedPath(JSON.parse(value));
-  } catch {
-    return [];
-  }
-}
-export function encodeNestedPathEnv(value) {
-  const sanitized = sanitizeNestedPath(value);
-  return sanitized.length ? JSON.stringify(sanitized) : "";
-}