@duckmind/dm-linux-x64 0.65.4 → 0.65.6

package/extensions/dm-subagents/src/agents/builtin-names.js

@@ -7,6 +7,7 @@ export const BUILTIN_AGENT_NAMES = [
   "cursor-agent",
   "cursor-agent-writer",
   "delegate",
+  "evidence-auditor",
   "oracle",
   "researcher",
   "reviewer",

package/extensions/dm-subagents/src/agents/chain-serializer.js

@@ -20,6 +20,11 @@ function parseStepBody(agent, sectionBody) {
       continue;
     const key = keyValue.trim().toLowerCase();
     const rawValue = rawValueValue.trim();
+    if (key === "machine") {
+      if (rawValue)
+        step.machine = rawValue;
+      continue;
+    }
     if (key === "output") {
       if (rawValue === "false")
         step.output = false;
@@ -266,6 +271,8 @@ export function serializeChain(config) {
   for (let i = 0;i < config.steps.length; i++) {
     const step = config.steps[i];
     lines.push(`## ${step.agent}`);
+    if (step.machine)
+      lines.push(`machine: ${step.machine}`);
     if (step.output === false)
       lines.push("output: false");
     else if (step.output)

package/extensions/dm-subagents/src/agents/global-npm-root.js

@@ -0,0 +1,47 @@
+import { exec, execFile } from "node:child_process";
+import { promises as fs } from "node:fs";
+import path from "node:path";
+export async function resolveGlobalNpmRoot(options = {}) {
+  const env = options.env ?? process.env;
+  const offline = env.PI_OFFLINE?.toLowerCase();
+  if (offline === "1" || offline === "true" || offline === "yes")
+    return null;
+  if ((options.platform ?? process.platform) === "win32" && env.APPDATA) {
+    const appDataRoot = path.join(env.APPDATA, "npm", "node_modules");
+    try {
+      if ((await fs.stat(appDataRoot)).isDirectory())
+        return await fs.realpath(appDataRoot);
+    } catch {}
+  }
+  const timeoutMs = options.timeoutMs ?? 5000;
+  const output = await new Promise((resolve) => {
+    let settled = false;
+    const finish = (value) => {
+      if (settled)
+        return;
+      settled = true;
+      clearTimeout(timer);
+      resolve(value);
+    };
+    const commandOptions = {
+      encoding: "utf8",
+      timeout: timeoutMs,
+      windowsHide: true,
+      env,
+      maxBuffer: 64 * 1024
+    };
+    const callback = (error, stdout) => finish(error ? null : stdout.trim());
+    const child = (options.platform ?? process.platform) === "win32" ? exec("npm root -g", commandOptions, callback) : execFile("npm", ["root", "-g"], commandOptions, callback);
+    const timer = setTimeout(() => {
+      child.kill();
+      finish(null);
+    }, timeoutMs);
+  });
+  if (!output)
+    return null;
+  try {
+    return await fs.realpath(output);
+  } catch {
+    return null;
+  }
+}

package/extensions/dm-subagents/src/agents/proactive-skills.js

@@ -100,7 +100,7 @@ export function recommendProactiveSkillSubagents(input) {
       addSource(counts, skill, `chain:${chain.name}`);
     }
   }
-  return [...counts.entries()].filter(([skill, sources]) => sources.size >= config.minReferences && (!availableByName || availableByName.has(skill))).map(([skill, sources]) => {
+  return [...counts.entries()].filter(([skill, sources]) => sources.size >= config.minReferences && (!availableByName || availableByName.has(skill)) && availableByName?.get(skill)?.disableModelInvocation !== true).map(([skill, sources]) => {
     const description = availableByName?.get(skill)?.description;
     return {
       skill,

package/extensions/dm-subagents/src/agents/runtime-agent-registry.js

@@ -3,6 +3,7 @@ import { validateAcceptanceInput } from "../runs/shared/acceptance.js";
 import { validatePermissionRules } from "../runs/shared/permissions.js";
 import { validateToolBudgetConfig } from "../runs/shared/tool-budget.js";
 import { BUILTIN_AGENT_NAMES } from "./builtin-names.js";
+import { applyRuntimeAgentSettings } from "./agents.js";
 export const RUNTIME_AGENT_REGISTRY_KEY = "dm-subagents.runtime-agents.v1";
 const MAX_RUNTIME_AGENTS_PER_PI = 200;
 const MAX_AGENT_NAME_LENGTH = 128;
@@ -154,10 +155,10 @@ function validateDefinition(value) {
     "systemPrompt",
     "aliases",
     "tools",
+    "excludeTools",
     "allowNestedSubagents",
     "mcpDirectTools",
     "model",
-    "fallbackModels",
     "thinking",
     "systemPromptMode",
     "inheritProjectContext",
@@ -170,6 +171,7 @@ function validateDefinition(value) {
     "defaultAcceptance",
     "acceptanceRole",
     "runner",
+    "machine",
     "skills",
     "skillPath",
     "extensions",
@@ -181,7 +183,6 @@ function validateDefinition(value) {
     "defaultProgress",
     "interactive",
     "maxSubagentDepth",
-    "completionGuard",
     "toolBudget",
     "permissions"
   ]);
@@ -205,10 +206,12 @@ function validateDefinition(value) {
     throw new Error("Runtime agent definition outputMode must be 'inline' or 'file-only'.");
   const aliases = validateStringList(definition.aliases, "Runtime agent definition aliases");
   const tools = validateStringList(definition.tools, "Runtime agent definition tools");
+  const excludeTools = validateStringList(definition.excludeTools, "Runtime agent definition excludeTools");
   const allowNestedSubagents = validateBoolean(definition.allowNestedSubagents, "Runtime agent definition allowNestedSubagents");
   const mcpDirectTools = validateStringList(definition.mcpDirectTools, "Runtime agent definition mcpDirectTools");
   const model = validateOptionalString(definition.model, "Runtime agent definition model");
-  const fallbackModels = validateStringList(definition.fallbackModels, "Runtime agent definition fallbackModels");
+  if (definition.fallbackModels !== undefined)
+    throw new Error("Runtime agent definition fallbackModels was removed; configure one model instead.");
   const inheritProjectContext = validateBoolean(definition.inheritProjectContext, "Runtime agent definition inheritProjectContext");
   const inheritGlobalContext = validateBoolean(definition.inheritGlobalContext, "Runtime agent definition inheritGlobalContext");
   const inheritSkills = validateBoolean(definition.inheritSkills, "Runtime agent definition inheritSkills");
@@ -222,12 +225,12 @@ function validateDefinition(value) {
   const extensions = validateStringList(definition.extensions, "Runtime agent definition extensions");
   const subagentOnlyExtensions = validateStringList(definition.subagentOnlyExtensions, "Runtime agent definition subagentOnlyExtensions");
   const mutationTools = validateStringList(definition.mutationTools, "Runtime agent definition mutationTools");
+  const machine = validateOptionalString(definition.machine, "Runtime agent definition machine");
   const output = validateOptionalString(definition.output, "Runtime agent definition output");
   const defaultReads = validateStringList(definition.defaultReads, "Runtime agent definition defaultReads");
   const defaultProgress = validateBoolean(definition.defaultProgress, "Runtime agent definition defaultProgress");
   const interactive = validateBoolean(definition.interactive, "Runtime agent definition interactive");
   const maxSubagentDepth = validatePositiveInteger(definition.maxSubagentDepth, "Runtime agent definition maxSubagentDepth");
-  const completionGuard = validateBoolean(definition.completionGuard, "Runtime agent definition completionGuard");
   const toolBudget = validateToolBudget(definition.toolBudget);
   const permissions = validatePermissionRules(definition.permissions, "Runtime agent definition permissions");
   return {
@@ -235,10 +238,10 @@ function validateDefinition(value) {
     systemPrompt: validateString(definition.systemPrompt, "Runtime agent definition systemPrompt", MAX_SYSTEM_PROMPT_LENGTH),
     ...aliases ? { aliases } : {},
     ...tools ? { tools } : {},
+    ...excludeTools ? { excludeTools } : {},
     ...allowNestedSubagents !== undefined ? { allowNestedSubagents } : {},
     ...mcpDirectTools ? { mcpDirectTools } : {},
     ...model ? { model } : {},
-    ...fallbackModels ? { fallbackModels } : {},
     ...thinking !== undefined ? { thinking } : {},
     ...systemPromptMode !== undefined ? { systemPromptMode } : {},
     ...inheritProjectContext !== undefined ? { inheritProjectContext } : {},
@@ -256,13 +259,13 @@ function validateDefinition(value) {
     ...extensions ? { extensions } : {},
     ...subagentOnlyExtensions ? { subagentOnlyExtensions } : {},
     ...mutationTools ? { mutationTools } : {},
+    ...machine ? { machine } : {},
     ...output ? { output } : {},
     ...outputMode !== undefined ? { outputMode } : {},
     ...defaultReads ? { defaultReads } : {},
     ...defaultProgress !== undefined ? { defaultProgress } : {},
     ...interactive !== undefined ? { interactive } : {},
     ...maxSubagentDepth !== undefined ? { maxSubagentDepth } : {},
-    ...completionGuard !== undefined ? { completionGuard } : {},
     ...toolBudget !== undefined ? { toolBudget } : {},
     ...permissions !== undefined ? { permissions } : {}
   };
@@ -311,10 +314,10 @@ function toAgentConfig(name, definition) {
     ...aliases ? { aliases } : {},
     ...definition.runner !== undefined ? { runner: definition.runner } : {},
     ...definition.tools !== undefined ? { tools: [...definition.tools] } : {},
+    ...definition.excludeTools !== undefined ? { excludeTools: [...definition.excludeTools] } : {},
     ...definition.allowNestedSubagents !== undefined ? { allowNestedSubagents: definition.allowNestedSubagents } : {},
     ...definition.mcpDirectTools !== undefined ? { mcpDirectTools: [...definition.mcpDirectTools] } : {},
     ...definition.model !== undefined ? { model: definition.model } : {},
-    ...definition.fallbackModels !== undefined ? { fallbackModels: [...definition.fallbackModels] } : {},
     ...definition.thinking !== undefined ? { thinking: definition.thinking } : {},
     systemPromptMode: definition.systemPromptMode ?? defaultSystemPromptMode(name),
     inheritProjectContext: definition.inheritProjectContext ?? defaultInheritProjectContext(name),
@@ -334,13 +337,13 @@ function toAgentConfig(name, definition) {
     ...definition.extensions !== undefined ? { extensions: [...definition.extensions] } : {},
     ...definition.subagentOnlyExtensions !== undefined ? { subagentOnlyExtensions: [...definition.subagentOnlyExtensions] } : {},
     ...definition.mutationTools !== undefined ? { mutationTools: [...definition.mutationTools] } : {},
+    ...definition.machine !== undefined ? { machine: definition.machine } : {},
     ...definition.output !== undefined ? { output: definition.output } : {},
     ...definition.outputMode !== undefined ? { outputMode: definition.outputMode } : {},
     ...definition.defaultReads !== undefined ? { defaultReads: [...definition.defaultReads] } : {},
     ...definition.defaultProgress !== undefined ? { defaultProgress: definition.defaultProgress } : {},
     ...definition.interactive !== undefined ? { interactive: definition.interactive } : {},
     ...definition.maxSubagentDepth !== undefined ? { maxSubagentDepth: definition.maxSubagentDepth } : {},
-    ...definition.completionGuard !== undefined ? { completionGuard: definition.completionGuard } : {},
     ...definition.toolBudget !== undefined ? { toolBudget: definition.toolBudget } : {},
     ...definition.permissions !== undefined ? { permissions: definition.permissions } : {}
   };
@@ -402,11 +405,12 @@ function assertNoConfiguredCollision(configuredAgents, runtimeAgents) {
     }
   }
 }
-export function mergeRuntimeAgents(dm, discovered, configuredAgents = discovered.agents) {
-  const runtimeAgents = listRuntimeAgentConfigs(dm).filter((agent) => agent.disabled !== true);
-  if (runtimeAgents.length === 0)
+export function mergeRuntimeAgents(dm, discovered, configuredAgents = discovered.agents, settings) {
+  const registered = listRuntimeAgentConfigs(dm).filter((agent) => agent.disabled !== true);
+  if (registered.length === 0)
     return discovered;
-  assertNoIdentityCollisions(runtimeAgents, "Runtime agent registration");
-  assertNoConfiguredCollision(configuredAgents, runtimeAgents);
+  assertNoIdentityCollisions(registered, "Runtime agent registration");
+  assertNoConfiguredCollision(configuredAgents, registered);
+  const runtimeAgents = settings ? applyRuntimeAgentSettings(registered, settings) : registered;
   return { ...discovered, agents: [...discovered.agents, ...runtimeAgents] };
 }

package/extensions/dm-subagents/src/agents/skills.js

@@ -2,6 +2,7 @@ import { execSync } from "node:child_process";
 import * as fs from "node:fs";
 import * as os from "node:os";
 import * as path from "node:path";
+import { parse as parseYaml } from "yaml";
 import { parseFrontmatter } from "./frontmatter.js";
 import { getAgentDir, getProjectConfigDir } from "../shared/utils.js";
 const skillCache = new Map;
@@ -85,7 +86,7 @@ function getGlobalNpmRoot() {
     } catch {}
   }
   try {
-    cachedGlobalNpmRoot = fs.realpathSync(execSync("npm root -g", { encoding: "utf-8", timeout: 5000, windowsHide: true }).trim());
+    cachedGlobalNpmRoot = fs.realpathSync(execSync("npm root -g", { encoding: "utf-8", timeout: 5000, windowsHide: true, stdio: ["ignore", "pipe", "ignore"] }).trim());
     return cachedGlobalNpmRoot;
   } catch {
     cachedGlobalNpmRoot = "";
@@ -331,9 +332,28 @@ function chooseHigherPrioritySkill(existing, candidate) {
 function parseSkillDescription(content) {
   return parseFrontmatter(content).frontmatter.description;
 }
-function maybeReadSkillDescription(filePath) {
+function maybeReadSkillMetadata(filePath) {
   try {
-    return parseSkillDescription(fs.readFileSync(filePath, "utf-8"));
+    const content = fs.readFileSync(filePath, "utf-8");
+    return { description: parseSkillDescription(content), disableModelInvocation: maybeReadSkillDisableModelInvocation(content) };
+  } catch {
+    return {};
+  }
+}
+function maybeReadSkillDisableModelInvocation(content) {
+  try {
+    const normalized = content.replace(/\r\n/g, `
+`);
+    if (!normalized.startsWith("---"))
+      return;
+    const endIndex = normalized.indexOf(`
+---`, 3);
+    if (endIndex === -1)
+      return;
+    const parsed = parseYaml(normalized.slice(4, endIndex));
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed))
+      return;
+    return parsed["disable-model-invocation"] === true ? true : undefined;
   } catch {
     return;
   }
@@ -348,17 +368,18 @@ function collectFilesystemSkills(cwd, agentDir, skillPaths) {
     if (!fs.existsSync(resolvedFile))
       return;
     const source = inferSkillSource(resolvedFile, cwd, agentDir, sourceHint);
-    const description = maybeReadSkillDescription(resolvedFile);
+    const { description, disableModelInvocation } = maybeReadSkillMetadata(resolvedFile);
     const existingIndex = seen.get(resolvedFile);
     if (existingIndex !== undefined) {
       const existing = entries[existingIndex];
       if (existing && (SOURCE_PRIORITY[source] ?? 0) > (SOURCE_PRIORITY[existing.source] ?? 0)) {
-        const { description: _description, ...existingWithoutDescription } = existing;
+        const { description: _description, disableModelInvocation: _disableModelInvocation, ...existingWithoutMetadata } = existing;
         entries[existingIndex] = {
-          ...existingWithoutDescription,
+          ...existingWithoutMetadata,
           name,
           source,
-          ...description !== undefined ? { description } : {}
+          ...description !== undefined ? { description } : {},
+          ...disableModelInvocation !== undefined ? { disableModelInvocation } : {}
         };
       }
       return;
@@ -369,6 +390,7 @@ function collectFilesystemSkills(cwd, agentDir, skillPaths) {
       filePath: resolvedFile,
       source,
       ...description !== undefined ? { description } : {},
+      ...disableModelInvocation !== undefined ? { disableModelInvocation } : {},
       order: order++
     });
   };
@@ -507,11 +529,13 @@ function readSkill(skillName, skillPath, source) {
     const raw = fs.readFileSync(skillPath, "utf-8");
     const content = stripSkillFrontmatter(raw);
     const description = parseSkillDescription(raw);
+    const disableModelInvocation = maybeReadSkillDisableModelInvocation(raw);
     const skill = {
       name: skillName,
       path: skillPath,
       content,
       ...description !== undefined ? { description } : {},
+      ...disableModelInvocation !== undefined ? { disableModelInvocation } : {},
       source
     };
     skillCache.set(skillPath, { mtime: stat.mtimeMs, skill });
@@ -575,7 +599,8 @@ export function resolveSkillsWithFallback(skillNames, primaryCwd, fallbackCwd, l
   };
 }
 export function buildSkillInjection(skills) {
-  if (skills.length === 0)
+  const visibleSkills = skills.filter((skill) => !skill.disableModelInvocation);
+  if (visibleSkills.length === 0)
     return "";
   const lines = [
     "The following configured skills are available to this subagent.",
@@ -584,7 +609,7 @@ export function buildSkillInjection(skills) {
     "",
     "<available_skills>"
   ];
-  for (const skill of skills) {
+  for (const skill of visibleSkills) {
     lines.push("  <skill>");
     lines.push(`    <name>${escapeXmlText(skill.name)}</name>`);
     lines.push(`    <description>${escapeXmlText(skill.description ?? "")}</description>`);
@@ -622,7 +647,8 @@ export function discoverAvailableSkills(cwd) {
   return skills.filter((s) => s.name !== SUBAGENT_ORCHESTRATION_SKILL).map((s) => ({
     name: s.name,
     source: s.source,
-    ...s.description !== undefined ? { description: s.description } : {}
+    ...s.description !== undefined ? { description: s.description } : {},
+    ...s.disableModelInvocation !== undefined ? { disableModelInvocation: s.disableModelInvocation } : {}
   })).sort((a, b) => a.name.localeCompare(b.name));
 }
 export function clearSkillCache() {

package/extensions/dm-subagents/src/api/capability-ceiling.js

@@ -1,5 +1,4 @@
 export {
-  SUBAGENT_CAPABILITY_CEILING_ENV,
   SUBAGENT_CAPABILITY_CEILING_REGISTRY_KEY,
   SUBAGENT_CAPABILITY_CEILING_VERSION,
   decodeSubagentCapabilityCeiling,

package/extensions/dm-subagents/src/api/child-tool-plan.js

@@ -0,0 +1,3 @@
+export {
+  resolvePiLaunchToolPlan
+} from "../runs/shared/child-tool-plan.js";

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

@@ -3,28 +3,31 @@ 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 { buildSkillInjection, normalizeSkillInput, resolveSkillsWithFallback } from "../agents/skills.js";
-import { buildAgentMemoryInjection } from "../agents/agent-memory.js";
-import { buildModelCandidates, inheritsParentModel, resolveEffectiveSubagentModel } from "../runs/shared/model-fallback.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 { applyThinkingSuffix, resolvePiLaunchToolPlan } from "../runs/shared/dm-args.js";
-import { injectOutputPathSystemPrompt, normalizeSingleOutputOverride, resolveSingleOutputPath } from "../runs/shared/single-output.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";
 import { getArtifactPaths, getArtifactsDir } from "../shared/artifacts.js";
 import { resolveEffectiveThinking } from "../shared/model-info.js";
-import { assertThinkingWithinCeiling, decodeThinkingCeiling, intersectThinkingCeilings, SUBAGENT_THINKING_CEILING_ENV } from "../shared/thinking-ceiling.js";
+import { assertThinkingWithinCeiling, intersectThinkingCeilings } from "../shared/thinking-ceiling.js";
 import { SUBAGENT_LIFECYCLE_ARTIFACT_VERSION } from "../shared/types.js";
 import { capabilityCeilingAgentRestrictionMessage, intersectSubagentCapabilityCeilings } from "../runs/shared/capability-ceiling.js";
 import { resolvePermissionRules } from "../runs/shared/permissions.js";
 import { resolveStepBehavior } from "../shared/settings.js";
 import { canPreferForkFromSnapshot, resolveSubagentLaunchContext } from "../shared/fork-context.js";
 import { loadConfig } from "../extension/config.js";
-import { agentDefinitionDigest, AGENT_DEFINITION_PROJECTION_VERSION, launchBindingDigest, stableJsonDigest } from "../shared/launch-contract.js";
+import { applyIntercomBridgeToAgent, resolveIntercomBridge, validateIntercomBridgeConfig } from "../intercom/intercom-bridge.js";
+import { AGENT_DEFINITION_PROJECTION_VERSION, resolveLaunchBinding, stableJsonDigest } from "../shared/launch-contract.js";
 import { DIRS, TEMP_ROOT_DIR } from "../shared/types.js";
 import { processTerminalCandidatePath, processTerminalPath } from "../runs/background/process-terminal.js";
 import { resultFilePath } from "../runs/background/result-files.js";
 import { nestedResultsPath } from "../runs/shared/nested-events.js";
 import { normalizeExtensionBindings } from "../runs/shared/extension-bindings.js";
-export const SUBAGENT_LAUNCH_CONTRACT_VERSION = 2;
+import { resolveRequiredChildExtensions } from "../shared/required-child-extensions.js";
+export const SUBAGENT_LAUNCH_CONTRACT_VERSION = 3;
+const PREFLIGHT_ORCHESTRATOR_TARGET = "preflight";
 function packageVersion() {
   const packagePath = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..", "..", "package.json");
   const parsed = JSON.parse(fs.readFileSync(packagePath, "utf-8"));
@@ -99,6 +102,13 @@ export async function resolveSubagentLaunchContract(input) {
   if (input.artifactDir !== undefined && input.artifactDir !== "project" && input.artifactDir !== "session" && input.artifactDir !== "temp") {
     return { ok: false, code: "invalid_artifact_dir", message: `Unsupported artifactDir '${String(input.artifactDir)}'; expected 'project', 'session', or 'temp'.`, diagnostics };
   }
+  const bridgeOverride = input.intercomBridge === undefined ? undefined : validateIntercomBridgeConfig({ value: input.intercomBridge, label: "intercomBridge" });
+  if (bridgeOverride && !bridgeOverride.ok) {
+    return { ok: false, code: "invalid_intercom_bridge", message: bridgeOverride.error, diagnostics };
+  }
+  if (input.orchestratorTarget !== undefined && (typeof input.orchestratorTarget !== "string" || !input.orchestratorTarget.trim())) {
+    return { ok: false, code: "invalid_intercom_bridge", message: "orchestratorTarget must be a non-empty string when provided.", diagnostics };
+  }
   const scope = resolveExecutionAgentScope(input.agentScope);
   const parentProvider = input.preferredProvider ?? input.parentModel?.provider;
   const discovery = discoverAgentSnapshot(effectiveCwd, scope, parentProvider, { includeChains: false });
@@ -116,20 +126,30 @@ export async function resolveSubagentLaunchContract(input) {
   if (!resolvedAgent.agent) {
     return { ok: false, code: "missing_agent", message: formatUnknownAgentError(input.agent, unknownAgentDiagnosticContext(discovered)), diagnostics };
   }
-  const agent = resolvedAgent.agent;
+  const definitionAgent = resolvedAgent.agent;
   let extensionBindings;
   try {
     extensionBindings = normalizeExtensionBindings(input.extensionBindings)?.value;
   } catch (error) {
     return { ok: false, code: "invalid_extension_bindings", message: error instanceof Error ? error.message : String(error), diagnostics };
   }
-  if (extensionBindings !== undefined && (agent.runner?.type === "external-cli" || agent.runner?.type === "external-job")) {
-    return { ok: false, code: "unsupported_mode", message: `extensionBindings is not supported for runner.type='${agent.runner.type}'.`, diagnostics };
+  if (extensionBindings !== undefined && (definitionAgent.runner?.type === "external-cli" || definitionAgent.runner?.type === "external-job")) {
+    return { ok: false, code: "unsupported_mode", message: `extensionBindings is not supported for runner.type='${definitionAgent.runner.type}'.`, diagnostics };
   }
-  const context = resolveLaunchContractContext(input, agent);
+  const context = resolveLaunchContractContext(input, definitionAgent);
   if (context === "fork") {
-    diagnostics.push({ code: "host_required", severity: "host-required", message: "Exact fork session branching and fork-thinking downgrade checks require DM host session and model-registry snapshots." });
+    diagnostics.push({ code: "host_required", severity: "host-required", message: "Exact fork session branching requires DM host session snapshots." });
+  }
+  const bridge = resolveIntercomBridge({
+    config: loadConfig().intercomBridge,
+    ...bridgeOverride ? { override: bridgeOverride.value } : {},
+    context,
+    orchestratorTarget: input.orchestratorTarget ?? PREFLIGHT_ORCHESTRATOR_TARGET
+  });
+  if (bridge.active && bridge.interpolatesOrchestratorTarget && input.orchestratorTarget === undefined) {
+    diagnostics.push({ code: "host_required", severity: "host-required", message: "The intercomBridge instruction file names the supervisor session; supply orchestratorTarget to bind the exact child prompt." });
   }
+  const agent = applyIntercomBridgeToAgent(definitionAgent, bridge);
   const effectiveCapabilityCeiling = intersectSubagentCapabilityCeilings(input.capabilityCeiling, input.inheritedCapabilityCeiling);
   const restrictionMessage = capabilityCeilingAgentRestrictionMessage(agent.name, effectiveCapabilityCeiling);
   if (restrictionMessage)
@@ -141,7 +161,8 @@ export async function resolveSubagentLaunchContract(input) {
     ...outputOverride !== undefined ? { output: outputOverride } : {},
     ...input.outputMode !== undefined ? { outputMode: input.outputMode } : {},
     ...skillInput !== undefined ? { skills: skillInput } : {},
-    ...input.model !== undefined ? { model: input.model } : {}
+    ...input.model !== undefined ? { model: input.model } : {},
+    ...input.outputSchema !== undefined ? { outputSchema: input.outputSchema } : {}
   });
   const requestedSkills = behavior.skills === false ? [] : behavior.skills;
   const resolvedSkills = resolveSkillsWithFallback(requestedSkills, effectiveCwd, effectiveCwd, agent.skillPath, agent.filePath ? path.dirname(agent.filePath) : effectiveCwd);
@@ -151,22 +172,27 @@ 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";
+  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 primaryModel = externalRunner ? undefined : resolveEffectiveSubagentModel(input.model, agent.model, input.parentModel, availableModels, preferredProvider, { scope: modelScopes });
+  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,
+    source: modelOrigin === "explicit" ? "explicit" : "inherited"
+  });
   const effectiveThinkingConfig = input.thinking !== undefined ? input.thinking : agent.thinking;
-  const thinkingCeiling = externalRunner ? undefined : intersectThinkingCeilings(discovered.maxThinking, input.thinkingCeiling, input.inheritedThinkingCeiling, decodeThinkingCeiling(process.env[SUBAGENT_THINKING_CEILING_ENV]));
-  const model = externalRunner ? undefined : applyThinkingSuffix(primaryModel, effectiveThinkingConfig, input.thinking !== undefined);
-  const modelCandidates = externalRunner ? [] : buildModelCandidates(primaryModel, agent.fallbackModels, availableModels, preferredProvider, {
+  const thinkingCeiling = externalRunner ? undefined : intersectThinkingCeilings(discovered.maxThinking, input.thinkingCeiling, input.inheritedThinkingCeiling);
+  const model = externalRunner ? undefined : applyThinkingSuffix(resolveModelSelection(primaryModel, availableModels, preferredProvider, {
     scope: modelScopes,
-    primaryModelFromParent: inheritsParentModel(input.model, agent.model, input.parentModel)
-  }).map((candidate) => applyThinkingSuffix(candidate, effectiveThinkingConfig, input.thinking !== undefined) ?? candidate);
+    primaryModelFromParent: modelOrigin === "inherited" || inheritsParentModel(input.model, agent.model, input.parentModel),
+    origin: modelOrigin
+  }).model, effectiveThinkingConfig, input.thinking !== undefined);
   if (!externalRunner) {
     try {
       assertThinkingWithinCeiling({ model, configThinking: effectiveThinkingConfig, ceiling: thinkingCeiling, agent: agent.name, runId });
-      for (const candidate of modelCandidates)
-        assertThinkingWithinCeiling({ model: candidate, configThinking: effectiveThinkingConfig, ceiling: thinkingCeiling, agent: agent.name, runId });
     } catch (error) {
       const message = error instanceof Error ? error.message : String(error);
       diagnostics.push({ code: "thinking_ceiling", severity: "error", message });
@@ -176,19 +202,21 @@ export async function resolveSubagentLaunchContract(input) {
   let toolPlan;
   const permissionRules = resolvePermissionRules(loadConfig().permissions, agent.permissions);
   const fast = input.fast ?? agent.fast;
+  const requiredExtensions = externalRunner ? [] : resolveRequiredChildExtensions(input.parentSessionId);
   try {
     toolPlan = resolvePiLaunchToolPlan({
       tools: agent.tools,
+      excludeTools: agent.excludeTools,
       allowNestedSubagents: agent.allowNestedSubagents,
       extensions: agent.extensions,
       subagentOnlyExtensions: agent.subagentOnlyExtensions,
+      requiredExtensions,
       mcpDirectTools: agent.mcpDirectTools,
       cwd: effectiveCwd,
       requireReadTool: resolvedSkills.resolved.length > 0,
-      structuredOutput: Boolean(input.outputSchema),
+      structuredOutput: Boolean(behavior.outputSchema),
       fast,
       model,
-      modelCandidates,
       capabilityCeiling: effectiveCapabilityCeiling,
       agentName: agent.name,
       permissionRules
@@ -202,7 +230,7 @@ export async function resolveSubagentLaunchContract(input) {
   const artifactsDir = artifactsEnabled ? getArtifactsDir(input.parentSessionFile ?? null, effectiveCwd, input.artifactDir) : undefined;
   const artifactPaths = artifactsDir ? getArtifactPaths(artifactsDir, runId, agent.name, 0) : undefined;
   const outputPath = resolveSingleOutputPath(behavior.output, effectiveCwd, effectiveCwd, artifactsDir ? path.join(artifactsDir, "outputs", runId) : undefined);
-  const sessionRoot = input.sessionDir ? path.resolve(input.sessionDir) : input.sessionRoot ? path.join(path.resolve(input.sessionRoot), runId) : undefined;
+  const sessionRoot = input.sessionDir ? path.join(path.resolve(input.sessionDir), runId) : input.sessionRoot ? path.join(path.resolve(input.sessionRoot), runId) : undefined;
   const sessionDir = sessionRoot ? path.join(sessionRoot, "run-0") : undefined;
   const lifecycleAsyncDir = input.nestedRootRunId ? path.join(TEMP_ROOT_DIR, "nested-subagent-runs", input.nestedRootRunId, runId) : path.join(DIRS.async, runId);
   const lifecycleResultPath = input.nestedRootRunId ? nestedResultsPath(input.nestedRootRunId, runId) : resultFilePath(DIRS.results, runId);
@@ -214,22 +242,23 @@ export async function resolveSubagentLaunchContract(input) {
   if (resolvedSkills.missing.length > 0) {
     return { ok: false, code: "missing_skill", message: `Missing skills: ${resolvedSkills.missing.join(", ")}`, diagnostics };
   }
-  let effectiveSystemPrompt = agent.systemPrompt?.trim() ?? "";
-  if (resolvedSkills.resolved.length > 0) {
-    const skillInjection = buildSkillInjection(resolvedSkills.resolved);
-    effectiveSystemPrompt = effectiveSystemPrompt ? `${effectiveSystemPrompt}
-
-${skillInjection}` : skillInjection;
-  }
-  const memoryInjection = buildAgentMemoryInjection(agent, effectiveCwd);
-  if (memoryInjection)
-    effectiveSystemPrompt = effectiveSystemPrompt ? `${effectiveSystemPrompt}
-
-${memoryInjection}` : memoryInjection;
-  effectiveSystemPrompt = injectOutputPathSystemPrompt(effectiveSystemPrompt, outputPath, agent);
+  const effectiveThinking = resolveEffectiveThinking(model, effectiveThinkingConfig);
+  const binding = resolveLaunchBinding({
+    agent,
+    task: input.task ?? "",
+    model,
+    ...fast !== undefined ? { fast } : {},
+    ...effectiveThinking ? { thinking: effectiveThinking } : {},
+    systemPrompt: buildEffectiveSystemPrompt({ agent, resolvedSkills: resolvedSkills.resolved, cwd: effectiveCwd, ...outputPath ? { outputPath } : {} }),
+    skills: requestedSkills,
+    toolPlan,
+    ...outputPath ? { outputPath } : {},
+    outputMode: behavior.outputMode,
+    ...behavior.outputSchema ? { structuredOutputSchema: behavior.outputSchema } : {},
+    ...extensionBindings ? { extensionBindings } : {}
+  });
   const candidates = candidateList(input.agent, agent, discovery.all);
   const shadowedCandidates = candidates.filter((candidate) => !candidate.selected);
-  const definitionDigest = agentDefinitionDigest(agent);
   const contractBase = {
     version: SUBAGENT_LAUNCH_CONTRACT_VERSION,
     runId,
@@ -240,13 +269,12 @@ ${memoryInjection}` : memoryInjection;
       source: agent.source,
       filePath: agent.filePath,
       definitionProjectionVersion: AGENT_DEFINITION_PROJECTION_VERSION,
-      definitionDigest,
+      definitionDigest: binding.definitionDigest,
       shadowedCandidates
     },
     context,
     ...model ? { model } : {},
-    modelCandidates,
-    ...resolveEffectiveThinking(model, effectiveThinkingConfig) ? { thinking: resolveEffectiveThinking(model, effectiveThinkingConfig) } : {},
+    ...effectiveThinking ? { thinking: effectiveThinking } : {},
     ...thinkingCeiling ? { thinkingCeiling } : {},
     systemPromptMode: agent.systemPromptMode,
     inheritProjectContext: agent.inheritProjectContext,
@@ -260,6 +288,7 @@ ${memoryInjection}` : memoryInjection;
     tools: {
       requestedBuiltin: toolPlan.requestedBuiltinTools,
       declaredBuiltin: toolPlan.declaredBuiltinTools,
+      ...toolPlan.excludeTools.length > 0 ? { excludeTools: toolPlan.excludeTools } : {},
       effectiveAllowlist: toolPlan.effectiveToolAllowlist,
       explicitAllowlist: toolPlan.explicitToolAllowlist,
       requiredChildTools: toolPlan.requiredChildTools,
@@ -269,12 +298,14 @@ ${memoryInjection}` : memoryInjection;
       toolExtensionPaths: toolPlan.toolExtensionPaths,
       runtimeExtensions: toolPlan.runtimeExtensions,
       configuredExtensions: toolPlan.configuredExtensions,
-      extensionArgs: toolPlan.extensionArgs,
+      requiredExtensionIds: toolPlan.requiredExtensions.map(({ id }) => id),
+      extensionArgs: toolPlan.extensionArgs.filter((extensionPath) => !requiredExtensions.some(({ path }) => path === extensionPath)),
       disableAmbientExtensions: toolPlan.disableAmbientExtensions,
       fanoutAuthorized: toolPlan.fanoutAuthorized,
       ...toolPlan.capabilityCeiling ? { capabilityCeiling: toolPlan.capabilityCeiling } : {},
       ...toolPlan.capabilityAudit ? { capabilityAudit: toolPlan.capabilityAudit } : {}
     },
+    intercomBridge: bridge.active && bridge.mode !== "off" ? { active: true, mode: bridge.mode } : { active: false, mode: bridge.mode },
     roots: {
       cwd: effectiveCwd,
       ...sessionRoot ? { sessionRoot } : {},
@@ -296,27 +327,7 @@ ${memoryInjection}` : memoryInjection;
       packageVersion: packageVersion()
     },
     diagnostics,
-    launchContractDigest: launchBindingDigest({
-      task: input.task ?? "",
-      definitionDigest,
-      ...model ? { model } : {},
-      modelCandidates,
-      ...fast !== undefined ? { fast } : {},
-      ...resolveEffectiveThinking(model, effectiveThinkingConfig) ? { thinking: resolveEffectiveThinking(model, effectiveThinkingConfig) } : {},
-      systemPrompt: effectiveSystemPrompt,
-      systemPromptMode: agent.systemPromptMode,
-      inheritProjectContext: agent.inheritProjectContext,
-      inheritGlobalContext: agent.inheritGlobalContext,
-      inheritSkills: agent.inheritSkills,
-      skills: requestedSkills,
-      tools: toolPlan.effectiveToolAllowlist,
-      extensions: toolPlan.extensionArgs,
-      mcpDirectTools: toolPlan.effectiveMcpTools,
-      ...outputPath ? { outputPath } : {},
-      outputMode: behavior.outputMode,
-      ...input.outputSchema ? { structuredOutputSchema: input.outputSchema } : {},
-      ...extensionBindings ? { extensionBindings } : {}
-    })
+    launchContractDigest: binding.launchContractDigest
   };
   return { ok: true, contract: { ...contractBase, digest: digestContract(contractBase) } };
 }

package/extensions/dm-subagents/src/api/required-child-extensions.js

@@ -0,0 +1,3 @@
+export {
+  registerRequiredChildExtensions
+} from "../shared/required-child-extensions.js";

package/extensions/dm-subagents/src/api/workflow-resources.js

@@ -0,0 +1 @@
+export { registerWorkflowResource } from "../workflows/workflow-resources.js";