@duckmind/dm-darwin-x64 0.66.5 → 0.66.7

package/extensions/dm-subagents/src/api/preflight.js

@@ -2,10 +2,11 @@ import * as fs from "node:fs";
 import * as path from "node:path";
 import { fileURLToPath } from "node:url";
 import { discoverAgentSnapshot, findBlockingAgentDiagnostic, formatUnknownAgentError, resolveAgentName, unknownAgentDiagnosticContext } from "../agents/agents.js";
-import { resolveExecutionAgentScope } from "../agents/agent-scope.js";
+import { projectScopeRequiresTrustMessage, resolveExecutionAgentScope } from "../agents/agent-scope.js";
 import { normalizeSkillInput, resolveSkillsWithFallback } from "../agents/skills.js";
 import { inheritsParentModel, resolveEffectiveSubagentModel, resolveModelOrigin, resolveModelSelection } from "../runs/shared/model-resolution.js";
 import { resolveModelScopesForAgent } from "../runs/shared/model-scope.js";
+import { assertClaudeCodeModelScope, isClaudeCodeAdapterId, resolveClaudeCodeOverride } from "../runs/shared/claude-code-adapter.js";
 import { applyThinkingSuffix, resolvePiLaunchToolPlan } from "../runs/shared/child-tool-plan.js";
 import { buildEffectiveSystemPrompt } from "../runs/shared/effective-system-prompt.js";
 import { normalizeSingleOutputOverride, resolveSingleOutputPath } from "../runs/shared/single-output.js";
@@ -25,9 +26,16 @@ import { processTerminalCandidatePath, processTerminalPath } from "../runs/backg
 import { resultFilePath } from "../runs/background/result-files.js";
 import { nestedResultsPath } from "../runs/shared/nested-events.js";
 import { normalizeExtensionBindings } from "../runs/shared/extension-bindings.js";
-import { resolveRequiredChildExtensions } from "../shared/required-child-extensions.js";
+import { assertRequiredChildExtensionsAdmitted, resolveRequiredChildExtensions } from "../shared/required-child-extensions.js";
 export const SUBAGENT_LAUNCH_CONTRACT_VERSION = 3;
 const PREFLIGHT_ORCHESTRATOR_TARGET = "preflight";
+function claudeCodeFailureCode(message) {
+  if (message.includes("subagent model scope"))
+    return "model_scope";
+  if (message.startsWith("Thinking level '"))
+    return "thinking_ceiling";
+  return "unsupported_mode";
+}
 function packageVersion() {
   const packagePath = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..", "..", "package.json");
   const parsed = JSON.parse(fs.readFileSync(packagePath, "utf-8"));
@@ -110,8 +118,12 @@ export async function resolveSubagentLaunchContract(input) {
     return { ok: false, code: "invalid_intercom_bridge", message: "orchestratorTarget must be a non-empty string when provided.", diagnostics };
   }
   const scope = resolveExecutionAgentScope(input.agentScope);
+  if (input.projectTrusted === false && scope === "project") {
+    const message = projectScopeRequiresTrustMessage(effectiveCwd);
+    return { ok: false, code: "restricted_agent", message, diagnostics: [...diagnostics, { code: "restricted_agent", severity: "error", message }] };
+  }
   const parentProvider = input.preferredProvider ?? input.parentModel?.provider;
-  const discovery = discoverAgentSnapshot(effectiveCwd, scope, parentProvider, { includeChains: false });
+  const discovery = discoverAgentSnapshot(effectiveCwd, scope, parentProvider, { includeChains: false, projectTrusted: input.projectTrusted });
   const discovered = discovery.effective;
   const resolvedAgent = resolveAgentName(input.agent, discovered.agents);
   const ambiguousCandidates = resolvedAgent.error ? discovered.agents.filter((agent) => resolveAgentName(input.agent, [agent]).agent) : resolvedAgent.agent;
@@ -172,12 +184,18 @@ export async function resolveSubagentLaunchContract(input) {
   if (resolvedSkills.missing.length > 0)
     diagnostics.push({ code: "missing_skill", severity: "error", message: `Missing skills: ${resolvedSkills.missing.join(", ")}` });
   const externalRunner = agent.runner?.type === "external-cli" || agent.runner?.type === "external-job";
+  try {
+    assertRequiredChildExtensionsAdmitted([resolveRequiredChildExtensions(input.parentSessionId)], { agent: agent.name, runnerType: agent.runner?.type });
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return { ok: false, code: "unsupported_mode", message, diagnostics };
+  }
   if (externalRunner && behavior.outputSchema) {
     return { ok: false, code: "unsupported_mode", message: `Agent '${agent.name}' uses runner.type='${agent.runner?.type}' and does not support: structured output.`, diagnostics };
   }
   const availableModels = normalizeAvailableModels(input.availableModels);
   const preferredProvider = agent.modelProvider ?? input.preferredProvider ?? input.parentModel?.provider;
-  const modelScopes = resolveModelScopesForAgent(discovered.modelScope, agent.name, input.parentModel);
+  const modelScopes = resolveModelScopesForAgent(discovered.modelScope, agent.name, input.parentModel, input.scopedModelIds);
   const modelOrigin = resolveModelOrigin({ explicitModel: input.model, agentModel: agent.model, parentModel: input.parentModel });
   const primaryModel = externalRunner ? undefined : resolveEffectiveSubagentModel(input.model, agent.model, input.parentModel, availableModels, preferredProvider, {
     scope: modelScopes,
@@ -199,6 +217,24 @@ export async function resolveSubagentLaunchContract(input) {
       return { ok: false, code: "thinking_ceiling", message, diagnostics };
     }
   }
+  if (agent.runner?.type === "external-cli" && isClaudeCodeAdapterId(agent.runner.adapter)) {
+    try {
+      const override = resolveClaudeCodeOverride({
+        model: typeof input.model === "string" ? input.model : undefined,
+        agent,
+        thinking: typeof effectiveThinkingConfig === "string" ? effectiveThinkingConfig : undefined,
+        thinkingCeiling: intersectThinkingCeilings(discovered.maxThinking, input.thinkingCeiling, input.inheritedThinkingCeiling),
+        agentName: agent.name,
+        runId
+      });
+      assertClaudeCodeModelScope({ scopes: modelScopes, model: override?.model, agent: agent.name, runId });
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      const code = claudeCodeFailureCode(message);
+      diagnostics.push({ code, severity: "error", message });
+      return { ok: false, code, message, diagnostics };
+    }
+  }
   let toolPlan;
   const permissionRules = resolvePermissionRules(loadConfig().permissions, agent.permissions);
   const fast = input.fast ?? agent.fast;
@@ -219,7 +255,8 @@ export async function resolveSubagentLaunchContract(input) {
       model,
       capabilityCeiling: effectiveCapabilityCeiling,
       agentName: agent.name,
-      permissionRules
+      permissionRules,
+      runtimeSnapshotHost: input.runtimeSnapshotHost
     });
   } catch (error) {
     const message = error instanceof Error ? error.message : String(error);
@@ -249,7 +286,7 @@ export async function resolveSubagentLaunchContract(input) {
     model,
     ...fast !== undefined ? { fast } : {},
     ...effectiveThinking ? { thinking: effectiveThinking } : {},
-    systemPrompt: buildEffectiveSystemPrompt({ agent, resolvedSkills: resolvedSkills.resolved, cwd: effectiveCwd, ...outputPath ? { outputPath } : {} }),
+    systemPrompt: buildEffectiveSystemPrompt({ agent, resolvedSkills: resolvedSkills.resolved, cwd: effectiveCwd }),
     skills: requestedSkills,
     toolPlan,
     ...outputPath ? { outputPath } : {},

package/extensions/dm-subagents/src/extension/config.js

@@ -2,7 +2,7 @@ import * as fs from "node:fs";
 import * as os from "node:os";
 import * as path from "node:path";
 import { Key } from "@duckmind/dm-tui";
-import { FLEET_KEYBINDING_ACTIONS } from "../shared/types.js";
+import { FLEET_KEYBINDING_ACTIONS, RUNNER_LAUNCHER_NAME_PATTERN, RUNNER_LAUNCHER_NAME_RULE } from "../shared/types.js";
 import { validateMissionStoreConfig } from "../missions/store.js";
 import { validateAuthorityPolicy } from "../policy/authority.js";
 import { getAgentDir } from "../shared/utils.js";
@@ -10,6 +10,8 @@ import { validatePermissionConfig } from "../runs/shared/permissions.js";
 import { MAX_ABANDONED_SLOT_RELEASE_AFTER_MS, MIN_ABANDONED_SLOT_RELEASE_AFTER_MS } from "../runs/background/active-async-capacity.js";
 import { normalizeWorktreeBranchPrefix } from "../runs/shared/worktree.js";
 import { validateModelResponseAliases } from "../shared/model-response-aliases.js";
+import { validateDisabledFeatures } from "../shared/disabled-features.js";
+const FAIL_CLOSED_CONFIG_KEYS = ["worktreeProvider", "worktreeBranchPrefix", "modelResponseAliases", "modelExclusions", "checkpointBeforeDeadlineMs", "disabledFeatures", "scheduledRuns", "toolActivation", "authorityPolicy", "permissions", "toolBudget", "runnerLaunchers"];
 const ARTIFACT_DIR_PREFERENCES = new Set(["project", "session", "temp"]);
 const FLEET_KEYBINDING_ACTION_SET = new Set(FLEET_KEYBINDING_ACTIONS);
 const KEY_MODIFIERS = new Set(["ctrl", "shift", "alt", "super"]);
@@ -56,6 +58,9 @@ function validateScheduledRunsConfig(value) {
     return;
   if (!value || typeof value !== "object" || Array.isArray(value))
     throw new Error("config.scheduledRuns must be a JSON object");
+  const enabled = value.enabled;
+  if (enabled !== undefined && typeof enabled !== "boolean")
+    throw new Error("config.scheduledRuns.enabled must be a boolean");
   const storeRoot = value.storeRoot;
   if (storeRoot === undefined)
     return;
@@ -99,6 +104,20 @@ function validateCapacityConfig(value) {
     throw new Error(`config.capacity.abandonedSlotReleaseAfterMs must be false or an integer from ${MIN_ABANDONED_SLOT_RELEASE_AFTER_MS} to ${MAX_ABANDONED_SLOT_RELEASE_AFTER_MS}`);
   }
 }
+function validateRunnerLaunchersConfig(value) {
+  if (value === undefined)
+    return;
+  if (!value || typeof value !== "object" || Array.isArray(value))
+    throw new Error("config.runnerLaunchers must be a JSON object mapping launcher names to argv arrays");
+  for (const [name, argv] of Object.entries(value)) {
+    const label = `config.runnerLaunchers[${JSON.stringify(name)}]`;
+    if (!RUNNER_LAUNCHER_NAME_PATTERN.test(name))
+      throw new Error(`${label} has an invalid name; launcher names ${RUNNER_LAUNCHER_NAME_RULE}`);
+    if (!Array.isArray(argv) || argv.length === 0 || argv.some((arg) => typeof arg !== "string" || !arg.trim() || arg.includes("\x00"))) {
+      throw new Error(`${label} must be a non-empty argv array of non-blank strings without NUL characters`);
+    }
+  }
+}
 function validateOrcaProgressTabsConfig(value) {
   if (value === undefined)
     return;
@@ -157,10 +176,23 @@ function validateConfig(config) {
   if (config.resultScanLogging !== undefined && config.resultScanLogging !== "all" && config.resultScanLogging !== "activity" && config.resultScanLogging !== "off") {
     throw new Error('config.resultScanLogging must be "all", "activity", or "off"');
   }
+  if (config.asyncWidgetCollapsed !== undefined && typeof config.asyncWidgetCollapsed !== "boolean") {
+    throw new Error("config.asyncWidgetCollapsed must be a boolean");
+  }
+  if (config.asyncWidgetLayout !== undefined && config.asyncWidgetLayout !== "adaptive" && config.asyncWidgetLayout !== "rows") {
+    throw new Error('config.asyncWidgetLayout must be "adaptive" or "rows"');
+  }
+  if (config.programStatus !== undefined && typeof config.programStatus !== "boolean") {
+    throw new Error("config.programStatus must be a boolean");
+  }
+  if (config.toolActivation !== undefined && config.toolActivation !== "auto" && config.toolActivation !== "dynamic" && config.toolActivation !== "eager") {
+    throw new Error('config.toolActivation must be "auto", "dynamic", or "eager"');
+  }
   validateMissionStoreConfig(config.missions);
   validateAuthorityPolicy(config.authorityPolicy);
   validatePermissionConfig(config.permissions);
   validateScheduledRunsConfig(config.scheduledRuns);
+  validateDisabledFeatures(config.disabledFeatures);
   validateFleetKeybindingsConfig(config.fleetKeybindings);
   validateArtifactConfig(config.artifactConfig);
   validateCapacityConfig(config.capacity);
@@ -169,6 +201,7 @@ function validateConfig(config) {
   validateModelResponseAliases(config.modelResponseAliases);
   validateMainWindowRendererConfig(config.mainWindowRenderer);
   validateOrcaProgressTabsConfig(config.orcaProgressTabs);
+  validateRunnerLaunchersConfig(config.runnerLaunchers);
 }
 export function getConfigPath() {
   return path.join(getAgentDir(), "extensions", "subagent", "config.json");
@@ -207,7 +240,7 @@ export function loadConfig() {
       throw error;
     try {
       const raw = JSON.parse(fs.readFileSync(configPath, "utf-8"));
-      if (raw && typeof raw === "object" && !Array.isArray(raw) && (Object.hasOwn(raw, "worktreeProvider") || Object.hasOwn(raw, "worktreeBranchPrefix") || Object.hasOwn(raw, "modelResponseAliases") || Object.hasOwn(raw, "modelExclusions") || Object.hasOwn(raw, "checkpointBeforeDeadlineMs")))
+      if (raw && typeof raw === "object" && !Array.isArray(raw) && FAIL_CLOSED_CONFIG_KEYS.some((key) => Object.hasOwn(raw, key)))
         throw error;
     } catch (readError) {
       if (readError === error)

package/extensions/dm-subagents/src/extension/control-notices.js

@@ -1,13 +1,7 @@
 import { controlNotificationKey, formatControlNoticeMessage } from "../runs/shared/subagent-control.js";
 export const SUBAGENT_CONTROL_MESSAGE_TYPE = "subagent_control_notice";
-export function controlNoticeTarget(details) {
-  return details.childIntercomTarget;
-}
-export function formatSubagentControlNotice(details, content) {
-  return details.noticeText ?? content ?? formatControlNoticeMessage(details.event, controlNoticeTarget(details));
-}
 function deliverControlNotice(input) {
-  const childIntercomTarget = controlNoticeTarget(input.details);
+  const childIntercomTarget = input.details.childIntercomTarget;
   const key = controlNotificationKey(input.details.event, childIntercomTarget);
   if (input.visibleControlNotices.has(key))
     return;
@@ -23,6 +17,8 @@ function deliverControlNotice(input) {
 export function handleSubagentControlNotice(input) {
   if (!input.details?.event || input.details.event.type === "active_long_running")
     return;
+  if (input.details.noticeDeferred)
+    return;
   if (input.details.source === "foreground") {
     return;
   }

package/extensions/dm-subagents/src/extension/declaration-pinning.js

@@ -0,0 +1,127 @@
+import { declarationsEqual, getCurrentSystemMessage, toToolDeclaration } from "../shared/dm-declarations.js";
+const pinsByApi = new WeakMap;
+const GUIDELINES_PLACEHOLDER = "\x00dm-subagents guidelines";
+function pinnedDefinition(tool, pin) {
+  const { constrainedSampling, promptSnippet, promptGuidelines, ...rest } = tool;
+  const declaration = pin && !declarationsEqual(pin.declaration, tool) ? pin.declaration : undefined;
+  const definition = { ...rest, description: declaration?.description ?? rest.description, parameters: declaration?.parameters ?? rest.parameters };
+  const sampling = declaration ? declaration.constrainedSampling : constrainedSampling;
+  if (sampling !== undefined)
+    definition.constrainedSampling = sampling;
+  const snippet = pin?.snippet ? pin.snippet.text : promptSnippet;
+  if (snippet !== undefined)
+    definition.promptSnippet = snippet;
+  const guidelines = pin?.guidelines ?? promptGuidelines;
+  if (guidelines !== undefined)
+    definition.promptGuidelines = guidelines;
+  return definition;
+}
+function register(dm, pins, name) {
+  const definition = pinnedDefinition(pins.current.get(name), pins.declared.get(name));
+  const key = JSON.stringify([toToolDeclaration(definition), definition.promptSnippet, definition.promptGuidelines]);
+  if (pins.registered.get(name) === key)
+    return;
+  pins.registered.set(name, key);
+  dm.registerTool(definition);
+}
+function sectionLines(text, name) {
+  const lines = text?.split(`
+`) ?? [];
+  const start = lines.indexOf(`<${name}>`);
+  const end = lines.indexOf(`</${name}>`, start + 1);
+  return start >= 0 && end > start ? lines.slice(start + 1, end) : undefined;
+}
+function ruleLines(activeTools, guidelines) {
+  const lines = [];
+  const add = (rule) => {
+    const line = `- ${rule.trim()}`;
+    if (line !== "- " && !lines.includes(line))
+      lines.push(line);
+  };
+  const active = (name) => activeTools.includes(name);
+  if ((active("bash") || active("powershell")) && !active("grep") && !active("find") && !active("ls")) {
+    if (active("bash") && active("powershell"))
+      add("Use bash or PowerShell for file operations like listing, searching, and finding files");
+    else if (active("powershell"))
+      add("Use PowerShell for file operations like listing, searching, and finding files");
+    else
+      add("Use bash for file operations like ls, rg, find");
+  }
+  for (const name of activeTools)
+    for (const rule of guidelines.get(name) ?? [])
+      add(rule);
+  add("Be concise in your responses");
+  add("Show file paths clearly when working with files");
+  return lines;
+}
+const sameLines = (left, right) => left.length === right.length && left.every((line, index) => line === right[index]);
+function recordedGuidelines(dm, ctx, recorded, names) {
+  const recovered = new Map;
+  const activeTools = dm.getActiveTools();
+  const guidelines = new Map(dm.getAllTools().map((tool) => [tool.name, tool.promptGuidelines ?? []]));
+  const current = sectionLines(ctx.getSystemPrompt(), "rules");
+  if (!current || !sameLines(ruleLines(activeTools, guidelines), current))
+    return recovered;
+  const rebuild = (name, candidate) => ruleLines(activeTools, new Map(guidelines).set(name, candidate));
+  for (const name of names) {
+    const start = rebuild(name, [GUIDELINES_PLACEHOLDER]).indexOf(`- ${GUIDELINES_PLACEHOLDER}`);
+    if (start < 0)
+      continue;
+    const candidate = recorded.slice(start, start + recorded.length - rebuild(name, []).length).map((line) => line.slice(2));
+    if (!sameLines(rebuild(name, candidate), recorded))
+      continue;
+    guidelines.set(name, candidate);
+    recovered.set(name, candidate);
+  }
+  return recovered;
+}
+function recordedSystemMessage(ctx) {
+  const sessionManager = ctx?.sessionManager;
+  if (typeof sessionManager?.buildSessionContext !== "function")
+    return;
+  return getCurrentSystemMessage(sessionManager.buildSessionContext().messages);
+}
+function declaredPins(dm, pins, ctx, system) {
+  if (!ctx || !system)
+    return new Map;
+  const declarations = system.toolsAdded ?? [];
+  const snippets = sectionLines(system.sections?.tools ?? undefined, "tools");
+  const rules = sectionLines(system.sections?.rules ?? undefined, "rules");
+  const guidelines = rules ? recordedGuidelines(dm, ctx, rules, declarations.map((tool) => tool.name).filter((name) => pins.current.has(name))) : new Map;
+  return new Map(declarations.map((declaration) => {
+    const pin = { declaration };
+    if (snippets)
+      pin.snippet = { text: snippets.find((line) => line.startsWith(`- ${declaration.name}: `))?.slice(declaration.name.length + 4) };
+    const recovered = guidelines.get(declaration.name);
+    if (recovered)
+      pin.guidelines = recovered;
+    return [declaration.name, pin];
+  }));
+}
+function pinsFor(dm) {
+  const existing = pinsByApi.get(dm);
+  if (existing)
+    return existing;
+  const pins = { current: new Map, declared: new Map, registered: new Map, sections: {} };
+  pinsByApi.set(dm, pins);
+  const refresh = (ctx) => {
+    const system = recordedSystemMessage(ctx);
+    pins.sections = system?.sections ?? {};
+    pins.declared = declaredPins(dm, pins, ctx, system);
+    for (const name of pins.current.keys())
+      register(dm, pins, name);
+  };
+  dm.on("session_start", (_event, ctx) => refresh(ctx));
+  dm.on("session_tree", (_event, ctx) => refresh(ctx));
+  return pins;
+}
+export function recordedPromptSection(dm, name) {
+  return sectionLines(pinsFor(dm).sections[name] ?? undefined, name)?.join(`
+`);
+}
+export function registerPinnedTool(dm, tool) {
+  const pins = pinsFor(dm);
+  pins.current.set(tool.name, tool);
+  pins.registered.delete(tool.name);
+  register(dm, pins, tool.name);
+}

package/extensions/dm-subagents/src/extension/doctor.js

@@ -2,8 +2,7 @@ import * as fs from "node:fs";
 import * as path from "node:path";
 import { discoverAgentsAll } from "../agents/agents.js";
 import { isAsyncAvailable } from "../runs/background/async-execution.js";
-import { formatSpawnBudgetSummary, getSpawnBudgetSnapshot } from "../runs/shared/spawn-budget.js";
-import { getActiveAsyncCapacitySnapshot, resolveAbandonedSlotReleaseAfterMs, resolveMaxActiveAsyncRunsPerSession } from "../runs/background/active-async-capacity.js";
+import { formatSpawnBudgetSummary } from "../runs/shared/spawn-budget.js";
 import { diagnoseIntercomBridge } from "../intercom/intercom-bridge.js";
 import { discoverAvailableSkills } from "../agents/skills.js";
 import {
@@ -126,7 +125,7 @@ function formatIntercomDiagnostic(diagnostic, context) {
   return lines;
 }
 function formatSpawnBudgetSection(input) {
-  const snapshot = getSpawnBudgetSnapshot(input.state, input.config, input.currentSessionId ?? input.state.currentSessionId);
+  const snapshot = input.spawnBudget;
   return [
     `- usage: ${formatSpawnBudgetSummary(snapshot)}`,
     `- recent grants: ${snapshot.grantHistory.length === 0 ? "none" : snapshot.grantHistory.map((grant) => `+${grant.amount} at ${new Date(grant.grantedAt).toISOString()} (${grant.previousLimit} → ${grant.limit})`).join("; ")}`,
@@ -139,10 +138,7 @@ function formatRunFanoutSection(input) {
   return [`- configured limit: ${configured} (${source})`, "- usage: available after a run starts", "- reset boundary: cumulative claims are never released; a new top-level run creates a new budget"];
 }
 function formatActiveAsyncCapacitySection(input) {
-  const limit = resolveMaxActiveAsyncRunsPerSession(input.config.maxActiveAsyncRunsPerSession);
-  const sessionId = input.currentSessionId ?? input.state.currentSessionId;
-  const snapshot = sessionId ? getActiveAsyncCapacitySnapshot(sessionId, limit, { liveWorkflowRunIds: new Set(input.state.workflowControllers?.keys() ?? []), abandonedSlotReleaseAfterMs: resolveAbandonedSlotReleaseAfterMs(input.config.capacity?.abandonedSlotReleaseAfterMs) }) : { used: 0, limit: limit ?? 0 };
-  input.state.activeAsyncCapacity = snapshot;
+  const snapshot = input.activeAsyncCapacity;
   return [
     `- usage: ${snapshot.used}/${snapshot.limit || "unlimited"} used`,
     "- scope: top-level async runs in the current parent session; foreground and nested workflow children are not charged again",
@@ -170,6 +166,7 @@ function formatPermissionSystemSection() {
 }
 function formatWorkflowScriptSection() {
   return [
+    '- launch: write a ```js workflow block in the reply, then call subagent({ workflow: true }); or pass a file as workflow: "./path.js"',
     "- helpers: runs.run, runs.all, runs.steer, runs.status, runs.ref/refs, emit, console",
     "- recovery: if runs.all is missing, reload or update dm-subagents; await Promise.all([runs.run(...)]) is also supported"
   ];

package/extensions/dm-subagents/src/extension/fanout-child.js

@@ -5,16 +5,20 @@ import { discoverAgents } from "../agents/agents.js";
 import { getArtifactsDir } from "../shared/artifacts.js";
 import { createSubagentExecutor } from "../runs/foreground/subagent-executor.js";
 import { resolveWaitToolConfig } from "../runs/background/wait-config.js";
-import { readNestedControlRequests, resolveInheritedNestedRoute, writeNestedControlResult } from "../runs/shared/nested-events.js";
+import { nestedRunNotActiveMessage, readNestedControlRequests, resolveInheritedNestedRoute, writeNestedControlResult } from "../runs/shared/nested-events.js";
 import { deliverSubagentIntercomMessageEvent } from "../intercom/result-intercom.js";
 import { createNativeSupervisorChannel, NATIVE_SUPERVISOR_TOOL_NAME, resolveSupervisorChannelDir } from "../intercom/native-supervisor-channel.js";
 import { readStatus } from "../shared/utils.js";
 import { resolveSubagentIntercomTarget } from "../intercom/intercom-bridge.js";
 import { createSubagentParamsSchema } from "./schemas.js";
+import { registerPinnedTool } from "./declaration-pinning.js";
+import { resolveDisabledFeatureSurface } from "../shared/disabled-features.js";
 import { finalizeToolResult } from "./tool-result.js";
+import { flattenSubagentToolOptions } from "./subagent-options.js";
 import { loadConfig, resolveAsyncByDefault } from "./config.js";
 import { SUBAGENT_ASYNC_STARTED_EVENT } from "../shared/types.js";
 import { createChildExternalJobBridgeSweeper } from "../runs/shared/external-job-bridge.js";
+import { MODEL_ONLY_TOOL } from "../shared/extension-context.js";
 function getSubagentSessionRoot(parentSessionFile) {
   if (parentSessionFile) {
     const baseName = path.basename(parentSessionFile, ".jsonl");
@@ -73,7 +77,7 @@ function startNestedControlInboxListener(dm, state, route, inboxState) {
               try {
                 const control = state.foregroundControls.get(request.targetRunId);
                 if (!control) {
-                  message = `Nested run ${request.targetRunId} is not active in this fanout child.`;
+                  message = nestedRunNotActiveMessage(request.targetRunId);
                 } else if (request.action === "interrupt") {
                   ok = control.interrupt?.() === true;
                   message = ok ? `Interrupt requested for nested run ${request.targetRunId}.` : `Nested run ${request.targetRunId} has no active child step to interrupt.`;
@@ -188,22 +192,26 @@ export default function registerFanoutChildSubagentExtension(dm, childConfig) {
     activateSupervisorTransport: supervisorChannel.activateTransport,
     findPendingAsks: supervisorChannel.findPendingAsks
   });
-  const params = createSubagentParamsSchema();
+  const disabledFeatures = resolveDisabledFeatureSurface(config);
+  const listEnabled = (actions) => actions.filter((action) => !disabledFeatures.actions.has(action)).join(", ");
+  const blockedActions = listEnabled(["create", "update", "delete", "eject", "disable", "enable", "reset", "grant-spawn-budget", "lane.recordMerge", "lane.recordSupersession"]);
+  const params = createSubagentParamsSchema(disabledFeatures);
   const tool = {
     name: "subagent",
+    ...MODEL_ONLY_TOOL,
     label: "Subagent",
     description: [
       "Delegate to subagents from child-safe fanout mode.",
-      "Allowed management/control actions: list, get, status, lane.status, interrupt, resume, steer, doctor.",
-      "Mutating management actions (create, update, delete, eject, disable, enable, reset, grant-spawn-budget, lane.recordMerge, lane.recordSupersession) are blocked in this mode."
+      `Allowed management/control actions: ${listEnabled(["list", "get", "status", "lane.status", "interrupt", "resume", "steer", "doctor"])}.`,
+      ...blockedActions ? [`Mutating management actions (${blockedActions}) are blocked in this mode.`] : []
     ].join(`
 `),
     parameters: params,
     async execute(id, params, signal, onUpdate, ctx) {
-      return finalizeToolResult(await executor.executePublic(id, params, signal ?? new AbortController().signal, onUpdate, ctx));
+      return finalizeToolResult(await executor.executePublic(id, flattenSubagentToolOptions(params, disabledFeatures), signal ?? new AbortController().signal, onUpdate, ctx));
     }
   };
-  dm.registerTool(tool);
+  registerPinnedTool(dm, tool);
   const bridgeSweeper = createChildExternalJobBridgeSweeper();
   const unsubscribeBridgeStarted = dm.events.on(SUBAGENT_ASYNC_STARTED_EVENT, (payload) => {
     const info = payload;

package/extensions/dm-subagents/src/extension/herdr-dm-bridge.js

@@ -11,6 +11,7 @@ import { buildAgentMemoryInjection } from "../agents/agent-memory.js";
 import { appendAgentRefinementOverlay } from "../agents/agent-refinements.js";
 import { rewriteSubagentPrompt } from "../runs/shared/subagent-prompt-runtime.js";
 import { resolveExistingReadPaths } from "../shared/settings.js";
+import { MODEL_ONLY_TOOL } from "../shared/extension-context.js";
 function gitEvidence(cwd) {
   const run = (args) => spawnSync("git", args, { cwd, encoding: "utf8", timeout: 5000, maxBuffer: 128 * 1024 });
   const inside = run(["rev-parse", "--is-inside-work-tree"]);
@@ -96,6 +97,7 @@ export default function registerHerdrPiBridge(dm) {
   const activeTools = (ctx) => ctx.getActiveTools?.() ?? [];
   dm.registerTool({
     name: "contact_supervisor",
+    ...MODEL_ONLY_TOOL,
     label: "Contact supervisor",
     description: "Contact the parent/supervisor session for a blocking decision, structured interview, or progress update.",
     parameters: Type.Object({ reason: Type.Union([Type.Literal("need_decision"), Type.Literal("interview_request"), Type.Literal("progress_update")]), message: Type.Optional(Type.String({ maxLength: 65536 })), interview: Type.Optional(Type.Unknown()) }, { additionalProperties: false }),