@duckmind/dm-darwin-x64 0.66.5 → 0.66.6

package/extensions/dm-subagents/src/runs/shared/child-session.js

@@ -1,6 +1,8 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
 import { pathToFileURL } from "node:url";
+import { CHILD_COMMAND_TOOL, createChildCommandRuntime } from "./child-commands.js";
+import { supervisorChannelDir } from "./child-tool-plan.js";
 import { pinChildCacheRetention } from "../../shared/child-cache-retention.js";
 import { splitKnownThinkingSuffix } from "../../shared/model-info.js";
 import { getAgentDir, DM_CODING_AGENT_PACKAGE_ROOT_ENV } from "../../shared/utils.js";
@@ -22,14 +24,15 @@ export function childSessionHasQueuedMessages(session) {
     return false;
   }
 }
-function childRegistry(dm, agentDir) {
-  return dm.ModelRegistry.create(dm.AuthStorage.create(path.join(agentDir, "auth.json")), path.join(agentDir, "models.json"));
+function childRegistry(dm, agentDir, parentProviders, model) {
+  const authStorage = parentProviders && "authStorage" in parentProviders ? parentProviders.authStorage : model?.startsWith("openai-codex/") && (process.env.auth_file || process.env.AUTHS_DIR) ? dm.createUltraAuthStorage() : dm.AuthStorage.create(path.join(agentDir, "auth.json"));
+  return dm.ModelRegistry.create(authStorage, path.join(agentDir, "models.json"));
 }
-function childRuntime(dm, agentDir) {
+function childRuntime(dm, agentDir, parentProviders, model) {
   const legacy = dm.ModelRuntime;
   if (legacy?.create)
     return legacy.create().then((runtime) => ({ runtime }));
-  const registry = childRegistry(dm, agentDir);
+  const registry = childRegistry(dm, agentDir, parentProviders, model);
   return Promise.resolve({
     registry,
     runtime: {
@@ -61,7 +64,7 @@ function inheritParentProviders(modelRuntime, parentProviders, claimedProviderId
     onError?.({ extensionPath: "<parent-providers>", event: "inherit_provider", error });
     throw new Error(`Failed to enumerate parent providers: ${error instanceof Error ? error.message : String(error)}`, { cause: error });
   }
-  let registered = false;
+  const inherited = new Set;
   for (const providerId of new Set(providerIds)) {
     if (claimedProviderIds.has(providerId))
       continue;
@@ -74,24 +77,48 @@ function inheritParentProviders(modelRuntime, parentProviders, claimedProviderId
         modelRuntime.registerProvider(providerId, config);
       else
         throw new Error(`Parent provider '${providerId}' has no registered native provider or config.`);
-      registered = true;
+      inherited.add(providerId);
     } catch (error) {
       onError?.({ extensionPath: `<parent-provider:${providerId}>`, event: "inherit_provider", error });
       throw new Error(`Failed to inherit parent provider '${providerId}': ${error instanceof Error ? error.message : String(error)}`, { cause: error });
     }
   }
-  return registered;
+  return inherited;
 }
 const CHILD_PROMPT_RUNTIME_EXTENSION_PATH = "<inline:dm-subagents:prompt-runtime>";
-function prioritizeChildPromptRuntime(result) {
-  const index = result.extensions.findIndex(({ path }) => path === CHILD_PROMPT_RUNTIME_EXTENSION_PATH);
-  if (index <= 0)
+const CHILD_PROMPT_BOUNDARY_EXTENSION_PATH = "<inline:dm-subagents:prompt-boundary>";
+function orderChildPromptHooks(result, hooks = []) {
+  const isHook = (path, name) => path === `<inline:${name}>` || /^<inline:(\d+)>$/.exec(path)?.[1] !== undefined && hooks[Number(/^<inline:(\d+)>$/.exec(path)[1]) - 1]?.name === name;
+  const runtime = result.extensions.filter(({ path }) => isHook(path, "dm-subagents:prompt-runtime"));
+  const boundary = result.extensions.filter(({ path }) => isHook(path, "dm-subagents:prompt-boundary"));
+  const others = result.extensions.filter(({ path }) => !isHook(path, "dm-subagents:prompt-runtime") && !isHook(path, "dm-subagents:prompt-boundary"));
+  return { ...result, extensions: [...runtime, ...others, ...boundary] };
+}
+function prioritizeChildCommandRuntime(result) {
+  const index = result.extensions.findIndex(({ path }) => path === "<inline:dm-subagents:commands>");
+  if (index < 0)
     return result;
-  const extensions = [...result.extensions];
-  const [promptRuntime] = extensions.splice(index, 1);
-  if (!promptRuntime)
+  if (result.extensions.some((extension, otherIndex) => otherIndex !== index && extension.tools?.has("bash"))) {
+    const extensions = result.extensions.filter((_, otherIndex) => otherIndex !== index);
+    if (!extensions.some((extension) => extension.tools?.has(CHILD_COMMAND_TOOL))) {
+      const commands = result.extensions[index];
+      const registered = commands.tools.get(CHILD_COMMAND_TOOL);
+      const reason = "Native command controls are unavailable with the active custom bash backend. Use that backend's own command controls.";
+      extensions.push({ ...commands, tools: new Map([[CHILD_COMMAND_TOOL, { ...registered, definition: {
+        ...registered.definition,
+        description: reason,
+        execute: async () => {
+          throw new Error(reason);
+        }
+      } }]]) });
+    }
+    return { ...result, extensions };
+  }
+  if (index === 0)
     return result;
-  extensions.unshift(promptRuntime);
+  const extensions = [...result.extensions];
+  const [commands] = extensions.splice(index, 1);
+  extensions.unshift(commands);
   return { ...result, extensions };
 }
 let loading = Promise.resolve();
@@ -111,6 +138,52 @@ function applyProcessEnv(values) {
       process.env[name] = value;
   }
 }
+function selectedBuiltinMcpExtension(dm, selections, registeredDirect) {
+  const createMcpExtension = dm.createMcpExtension;
+  if (typeof createMcpExtension !== "function")
+    throw new Error(`Selected built-in MCP tools (${selections.map(({ name }) => name).join(", ")}) need a DM version with built-in MCP.`);
+  const selectors = new Map(selections.map(({ name, selector }) => [name, selector]));
+  const split = (value) => {
+    const slash = value.indexOf("/");
+    return { server: (slash === -1 ? value : value.slice(0, slash)).replace(/-/g, "_"), tool: slash === -1 ? undefined : value.slice(slash + 1) };
+  };
+  const granted = (tool) => {
+    const selector = selectors.get(tool.name);
+    if (selector === undefined || tool.exposure === "hidden" || tool.label === undefined)
+      return false;
+    const want = split(selector);
+    const have = split(tool.label);
+    return have.tool !== undefined && have.server === want.server && (want.tool === undefined || want.tool === have.tool);
+  };
+  const mcp = createMcpExtension();
+  const factory = (api) => mcp(new Proxy(api, {
+    get(target, prop) {
+      if (prop === "registerTool") {
+        return (tool) => {
+          const direct = granted(tool);
+          target.registerTool({ ...tool, exposure: direct ? "direct" : "hidden" });
+          if (direct)
+            registeredDirect.add(tool.name);
+          else
+            registeredDirect.delete(tool.name);
+        };
+      }
+      const value = Reflect.get(target, prop, target);
+      return typeof value === "function" ? value.bind(target) : value;
+    }
+  }));
+  return { name: "mcp", factory, builtin: true, replaceable: true };
+}
+async function missingBuiltinMcpTools(session, names, registeredDirect, timeoutMs, stopped) {
+  const deadline = Date.now() + timeoutMs;
+  for (;; ) {
+    const active = new Set(session.getActiveToolNames());
+    const missing = names.filter((name) => !active.has(name) || !registeredDirect.has(name));
+    if (missing.length === 0 || stopped() || Date.now() >= deadline)
+      return missing;
+    await new Promise((resolve) => setTimeout(resolve, 50));
+  }
+}
 function flushQueuedProviderRegistrations(loader, modelRuntime, onError, requiredPaths) {
   const claimedProviderIds = new Set;
   if (!("getExtensions" in loader) || typeof loader.getExtensions !== "function")
@@ -144,6 +217,23 @@ function flushQueuedProviderRegistrations(loader, modelRuntime, onError, require
   }
   if (Array.isArray(runtime.pendingNativeProviderRegistrations))
     runtime.pendingNativeProviderRegistrations = [];
+  const virtualModelRuntime = modelRuntime;
+  const virtualModelQueue = runtime;
+  const pendingVirtualModelRegistrations = virtualModelQueue.pendingVirtualModelRegistrations ?? [];
+  for (const { definition, extensionPath } of pendingVirtualModelRegistrations) {
+    if (typeof virtualModelRuntime.registerVirtualModel !== "function")
+      break;
+    try {
+      virtualModelRuntime.registerVirtualModel(definition);
+      registered = true;
+    } catch (error) {
+      onError?.({ extensionPath, event: "register_virtual_model", error });
+      if (requiredPaths.has(extensionPath))
+        throw new Error(`Required child extension virtual model registration failed for '${extensionPath}': ${error instanceof Error ? error.message : String(error)}`);
+    }
+  }
+  if (Array.isArray(virtualModelQueue.pendingVirtualModelRegistrations))
+    virtualModelQueue.pendingVirtualModelRegistrations = [];
   return { claimedProviderIds, registered };
 }
 export async function loadHostPiCodingAgent() {
@@ -184,9 +274,12 @@ function isUnknownRecord(value) {
 export function createDefaultChildSessionFactory(options = {}) {
   const loadPiCodingAgent = options.loadPiCodingAgent ?? loadHostPiCodingAgent;
   const shutdownTimeoutMs = options.shutdownTimeoutMs ?? 5000;
+  const builtinMcpToolWaitMs = options.builtinMcpToolWaitMs ?? 1e4;
   let runtime;
   const live = new Set;
   const shutdowns = new Set;
+  const mcpWaits = new Set;
+  let disposals = 0;
   const sharedRuntime = async (dm, agentDir) => {
     runtime ??= childRuntime(dm, agentDir).catch((error) => {
       runtime = undefined;
@@ -196,29 +289,55 @@ export function createDefaultChildSessionFactory(options = {}) {
   };
   return {
     async create(launch) {
+      const disposalsAtStart = disposals;
       const dm = await loadPiCodingAgent();
+      const builtinMcpTools = launch.builtinMcpTools ?? [];
+      const registeredDirectMcp = new Set;
+      const builtinMcp = builtinMcpTools.length ? selectedBuiltinMcpExtension(dm, builtinMcpTools, registeredDirectMcp) : undefined;
       const agentDir = getAgentDir();
-      const { runtime: modelRuntime, registry: modelRegistry } = launch.parentProviderRegistry ? await childRuntime(dm, agentDir) : await sharedRuntime(dm, agentDir);
-      const settingsManager = dm.SettingsManager.create(launch.cwd, agentDir);
+      const detachedUltra = !launch.parentProviderRegistry && launch.model?.startsWith("openai-codex/") && (process.env.auth_file || process.env.AUTHS_DIR);
+      const { runtime: modelRuntime, registry: modelRegistry } = launch.parentProviderRegistry || detachedUltra ? await childRuntime(dm, agentDir, launch.parentProviderRegistry, launch.model) : await sharedRuntime(dm, agentDir);
+      const commands = launch.runtime.runId && launch.runtime.agent && launch.runtime.childIndex !== undefined && launch.tools?.includes("bash") && launch.tools.includes(CHILD_COMMAND_TOOL) && !launch.excludeTools?.includes("bash") && !launch.excludeTools?.includes(CHILD_COMMAND_TOOL) && typeof dm.createBashTool === "function" ? createChildCommandRuntime(supervisorChannelDir(launch.runtime.runId, launch.runtime.agent, launch.runtime.childIndex)) : undefined;
+      const settingsManager = dm.SettingsManager.create(launch.cwd, agentDir, { projectTrusted: launch.projectTrusted });
       const themeKey = Symbol.for("@duckmind/dm-coding-agent:theme");
       const themeInitialized = Boolean(globalThis[themeKey]);
       if (!themeInitialized && typeof dm.initTheme === "function")
         dm.initTheme(settingsManager.getTheme());
+      const createCodemodeExtension = dm.createCodemodeExtension;
+      const codemode = typeof createCodemodeExtension === "function" && !launch.runtime.capabilityCeiling?.denyExtensions && (launch.tools === undefined || launch.tools.includes("codemode")) && !launch.excludeTools?.includes("codemode") ? [{ name: "codemode", factory: createCodemodeExtension(), replaceable: true }] : [];
       const loader = new dm.DefaultResourceLoader({
         cwd: launch.cwd,
         agentDir,
         settingsManager,
         noExtensions: !launch.ambientExtensions,
         noSkills: launch.noSkills,
+        skillsOverride: launch.noSkills ? (base) => ({ ...base, skills: [] }) : undefined,
         noPromptTemplates: true,
         noThemes: true,
         noContextFiles: launch.noContextFiles,
-        additionalExtensionPaths: launch.extensionPaths,
-        extensionFactories: launch.hooks.map(({ factory }) => factory),
-        extensionsOverride: prioritizeChildPromptRuntime,
+        additionalExtensionPaths: builtinMcp ? [...launch.extensionPaths, "builtin:mcp"] : launch.extensionPaths,
+        extensionFactories: [...launch.hooks, ...commands ? [{ name: "dm-subagents:commands", factory: (api) => {
+          api.registerTool(commands.wrap(dm.createBashTool(launch.cwd, { commandPrefix: settingsManager.getShellCommandPrefix(), shellPath: settingsManager.getShellPath() })));
+          api.registerTool(commands.tool());
+        } }] : [], ...codemode, ...builtinMcp ? [builtinMcp] : []].map(({ factory }) => factory),
+        extensionsOverride: (result) => orderChildPromptHooks(prioritizeChildCommandRuntime(result), launch.hooks),
         ...launch.systemPrompt !== undefined ? { systemPrompt: launch.systemPrompt } : {},
         ...launch.appendSystemPrompt !== undefined ? { appendSystemPrompt: [launch.appendSystemPrompt] } : {}
       });
+      const shutdownSession = async (session) => {
+        try {
+          await commands?.shutdown();
+          const runner = session.extensionRunner;
+          if (runner.hasHandlers("session_shutdown")) {
+            await Promise.race([runner.emit({ type: "session_shutdown", reason: "quit" }), new Promise((resolve) => setTimeout(resolve, shutdownTimeoutMs).unref?.())]);
+          }
+        } catch (error) {
+          launch.onExtensionError?.({ extensionPath: "<session>", event: "session_shutdown", error });
+        } finally {
+          session.dispose();
+        }
+      };
+      let inheritedProviders = new Set;
       const open = async () => {
         const requiredPaths = new Set((launch.requiredExtensions ?? []).map(({ path }) => path));
         applyProcessEnv(launch.processEnv);
@@ -229,8 +348,9 @@ export function createDefaultChildSessionFactory(options = {}) {
         if (loadErrors.length > 0)
           throw new Error(`Required child extension failed to load: ${loadErrors.map(({ path, error }) => `${path}: ${error}`).join("; ")}`);
         const queued = flushQueuedProviderRegistrations(loader, modelRuntime, launch.onExtensionError, requiredPaths);
-        const inherited = launch.parentProviderRegistry ? inheritParentProviders(modelRuntime, launch.parentProviderRegistry, queued.claimedProviderIds, launch.onExtensionError) : false;
-        if (queued.registered || inherited) {
+        if (launch.parentProviderRegistry)
+          inheritedProviders = inheritParentProviders(modelRuntime, launch.parentProviderRegistry, queued.claimedProviderIds, launch.onExtensionError);
+        if (queued.registered || inheritedProviders.size > 0) {
           try {
             await modelRuntime.refresh({ allowNetwork: false });
           } catch (error) {
@@ -238,7 +358,12 @@ export function createDefaultChildSessionFactory(options = {}) {
             throw new Error(`Failed to refresh child providers: ${error instanceof Error ? error.message : String(error)}`, { cause: error });
           }
         }
-        const sessionManager = launch.storage.kind === "file" ? dm.SessionManager.open(launch.storage.sessionFile, undefined, launch.cwd) : launch.storage.kind === "dir" ? dm.SessionManager.create(launch.cwd, launch.storage.sessionDir) : launch.storage.kind === "memory" ? dm.SessionManager.inMemory(launch.cwd) : dm.SessionManager.create(launch.cwd);
+        const newSessionOptions = launch.parentSessionFile ? { parentSession: launch.parentSessionFile } : undefined;
+        const newSessionFile = launch.storage.kind === "file" && !fs.existsSync(launch.storage.sessionFile);
+        const sessionManager = launch.storage.kind === "file" ? dm.SessionManager.open(launch.storage.sessionFile, undefined, launch.cwd) : launch.storage.kind === "dir" ? dm.SessionManager.create(launch.cwd, launch.storage.sessionDir, newSessionOptions) : launch.storage.kind === "memory" ? dm.SessionManager.inMemory(launch.cwd, newSessionOptions) : dm.SessionManager.create(launch.cwd, undefined, newSessionOptions);
+        const header = newSessionFile && launch.parentSessionFile ? sessionManager.getHeader() : null;
+        if (header)
+          header.parentSession = launch.parentSessionFile;
         const resolvedModel = launch.model ? modelRegistry ? resolveChildModel(modelRegistry, launch.model) : dm.resolveCliModel?.({ cliModel: launch.model, modelRuntime }) : undefined;
         if (launch.model && !resolvedModel)
           throw new Error("child model resolver is unavailable");
@@ -247,7 +372,7 @@ export function createDefaultChildSessionFactory(options = {}) {
         const { session } = await dm.createAgentSession({
           cwd: launch.cwd,
           agentDir,
-          ...modelRegistry ? { modelRegistry } : {},
+          ...modelRegistry ? { modelRegistry, authStorage: modelRegistry.authStorage } : {},
           ...resolvedModel?.model ? { model: resolvedModel.model } : {},
           ...resolvedModel?.thinkingLevel ? { thinkingLevel: resolvedModel.thinkingLevel } : {},
           ...launch.tools ? { tools: launch.tools } : {},
@@ -258,14 +383,26 @@ export function createDefaultChildSessionFactory(options = {}) {
           sessionStartEvent: { type: "session_start", reason: "startup" }
         });
         pinChildCacheRetention(session.agent);
+        const requiredStartupErrors = [];
+        let binding = true;
         try {
           await session.bindExtensions({
             mode: "print",
-            onError: (error) => launch.onExtensionError?.({ extensionPath: error.extensionPath, event: error.event, error: error.error })
+            onError: (error) => {
+              if (binding && requiredPaths.has(error.extensionPath))
+                requiredStartupErrors.push(`${error.extensionPath} (${error.event}): ${error.error}`);
+              launch.onExtensionError?.({ extensionPath: error.extensionPath, event: error.event, error: error.error });
+            }
           });
         } catch (error) {
           session.dispose();
           throw error;
+        } finally {
+          binding = false;
+        }
+        if (requiredStartupErrors.length > 0) {
+          await shutdownSession(session);
+          throw new Error(`Required child extension failed during startup: ${requiredStartupErrors.join("; ")}`);
         }
         return session;
       };
@@ -273,21 +410,26 @@ export function createDefaultChildSessionFactory(options = {}) {
       loading = opened;
       const session = await opened;
       let pending;
-      const shutdown = async () => {
+      const shutdown = () => shutdownSession(session);
+      if (builtinMcpTools.length) {
+        const disposed = () => disposals !== disposalsAtStart;
+        const ready = missingBuiltinMcpTools(session, builtinMcpTools.map(({ name }) => name), registeredDirectMcp, builtinMcpToolWaitMs, disposed).then(async (missing) => {
+          if (!missing.length && !disposed())
+            return;
+          await shutdown();
+          throw new Error(disposed() ? "The child session factory was disposed while the child waited for its MCP tools." : `Selected built-in MCP tools did not register in the child session: ${missing.join(", ")}. The MCP server may have failed to connect, or the name belongs to a different tool than the selector names; check it with /mcp.`);
+        });
+        mcpWaits.add(ready);
         try {
-          const runner = session.extensionRunner;
-          if (runner.hasHandlers("session_shutdown")) {
-            await Promise.race([runner.emit({ type: "session_shutdown", reason: "quit" }), new Promise((resolve) => setTimeout(resolve, shutdownTimeoutMs).unref?.())]);
-          }
-        } catch (error) {
-          launch.onExtensionError?.({ extensionPath: "<session>", event: "session_shutdown", error });
+          await ready;
         } finally {
-          session.dispose();
+          mcpWaits.delete(ready);
         }
-      };
+      }
       const child = {
         subscribe: (listener) => session.subscribe((event) => listener(event)),
         prompt: (text) => session.prompt(text),
+        ...commands ? { finishCommands: () => commands.finish() } : {},
         steer: (text) => session.steer(text),
         followUp: (text) => session.followUp(text),
         abort: () => session.abort(),
@@ -314,6 +456,12 @@ export function createDefaultChildSessionFactory(options = {}) {
         get modelId() {
           return session.model ? `${session.model.provider}/${session.model.id}` : undefined;
         },
+        get inheritedProvider() {
+          return session.model && inheritedProviders.has(session.model.provider) ? session.model.provider : undefined;
+        },
+        get virtualModelId() {
+          return session.model?.api === "dm-virtual" ? `${session.model.provider}/${session.model.id}` : undefined;
+        },
         get contextWindow() {
           return session.model?.contextWindow;
         }
@@ -322,6 +470,7 @@ export function createDefaultChildSessionFactory(options = {}) {
       return child;
     },
     async dispose() {
+      disposals += 1;
       const children = [...live].filter((child) => !child.detached);
       for (const child of children)
         child.shutDown = true;
@@ -331,7 +480,7 @@ export function createDefaultChildSessionFactory(options = {}) {
           child.dispose();
         } catch {}
       }
-      await Promise.allSettled([...shutdowns]);
+      await Promise.allSettled([...shutdowns, ...mcpWaits]);
       if (live.size === 0)
         runtime = undefined;
     }

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

@@ -3,6 +3,7 @@ import * as fs from "node:fs";
 import * as path from "node:path";
 import { fileURLToPath } from "node:url";
 import {
+  formatUnresolvedBuiltinMcpSelectors,
   formatUnresolvedMcpDirectToolSelectors,
   resolveMcpDirectToolResolution
 } from "./mcp-direct-tool-allowlist.js";
@@ -11,6 +12,7 @@ import {
 } from "../../shared/types.js";
 import { THINKING_LEVELS } from "../../shared/model-info.js";
 import { getAgentDir } from "../../shared/utils.js";
+import { resolveRuntimeModulePath, RUNTIME_MODULE_EXTENSIONS } from "../../shared/runtime-module-path.js";
 import { snapshotRequiredChildExtensions } from "../../shared/required-child-extensions.js";
 import {
   capabilityCeilingAgentRestrictionSources,
@@ -18,14 +20,13 @@ import {
   isAgentAllowedByCapabilityCeiling
 } from "./capability-ceiling.js";
 const MAX_LAUNCH_RESOLVED_EXTENSION_IDS = 32;
-const PROMPT_RUNTIME_EXTENSION_PATH = path.join(path.dirname(fileURLToPath(import.meta.url)), `subagent-prompt-runtime${path.extname(fileURLToPath(import.meta.url))}`);
-const FANOUT_CHILD_EXTENSION_PATH = path.join(path.dirname(fileURLToPath(import.meta.url)), "..", "..", "extension", `fanout-child${path.extname(fileURLToPath(import.meta.url))}`);
-const FAST_MODE_EXTENSION_PATH = path.join(path.dirname(fileURLToPath(import.meta.url)), `fast-mode-extension${path.extname(fileURLToPath(import.meta.url))}`);
+const RUNTIME_EXTENSION_DIR = path.dirname(fileURLToPath(import.meta.url));
+const FANOUT_CHILD_EXTENSION_DIR = path.join(RUNTIME_EXTENSION_DIR, "..", "..", "extension");
 const SUBAGENT_RUNTIME_EXTENSION_PATHS = new Set([
-  PROMPT_RUNTIME_EXTENSION_PATH,
-  FANOUT_CHILD_EXTENSION_PATH,
-  FAST_MODE_EXTENSION_PATH
-].map((extensionPath) => path.normalize(extensionPath)));
+  path.join(RUNTIME_EXTENSION_DIR, "subagent-prompt-runtime"),
+  path.join(RUNTIME_EXTENSION_DIR, "fast-mode-extension"),
+  path.join(FANOUT_CHILD_EXTENSION_DIR, "fanout-child")
+].flatMap((base) => RUNTIME_MODULE_EXTENSIONS.map((extension) => path.normalize(`${base}${extension}`))));
 export function isSubagentRuntimeExtensionPath(extensionPath) {
   return SUBAGENT_RUNTIME_EXTENSION_PATHS.has(path.normalize(extensionPath));
 }
@@ -70,7 +71,7 @@ function resolveFastModeExtension(input) {
   if (unsupported.length > 0) {
     throw new Error(`fast mode supports only native ${FAST_MODE_PROVIDER_PREFIX}* models; unsupported model${unsupported.length === 1 ? "" : "s"}: ${unsupported.join(", ")}.`);
   }
-  return [FAST_MODE_EXTENSION_PATH];
+  return [resolveRuntimeModulePath(RUNTIME_EXTENSION_DIR, "fast-mode-extension")];
 }
 function extensionIdentifier(value) {
   return `sha256:${createHash("sha256").update(path.normalize(value.trim())).digest("hex").slice(0, 16)}`;
@@ -160,7 +161,7 @@ export function resolvePiLaunchToolPlan(input) {
   if (input.requireReadTool && allowedToolSet && !allowedToolSet.has("read")) {
     throw new Error(`Capability ceiling from ${capabilityCeiling?.sources.join(", ") || "unknown source"} excludes required tool 'read' for lazy skill loading.`);
   }
-  const ceilingFilteredBuiltinTools = input.tools === undefined ? allowedToolSet ? [...allowedToolSet] : [] : (input.requireReadTool && requestedBuiltinTools.length > 0 && !requestedBuiltinTools.includes("read") && !allowedToolSet ? ["read", ...requestedBuiltinTools] : requestedBuiltinTools).filter((tool) => !allowedToolSet || allowedToolSet.has(tool));
+  const ceilingFilteredBuiltinTools = input.tools === undefined ? allowedToolSet ? [...allowedToolSet].filter((tool) => tool !== "subagent_command") : [] : (input.requireReadTool && requestedBuiltinTools.length > 0 && !requestedBuiltinTools.includes("read") && !allowedToolSet ? ["read", ...requestedBuiltinTools] : requestedBuiltinTools).filter((tool) => !allowedToolSet || allowedToolSet.has(tool));
   const declaredBuiltinTools = ceilingFilteredBuiltinTools;
   const excludeTools = [...new Set((input.excludeTools ?? []).map((tool) => tool.trim()).filter(Boolean))];
   const excludedToolSet = new Set(excludeTools);
@@ -170,18 +171,19 @@ export function resolvePiLaunchToolPlan(input) {
     throw new Error("Tool 'subagent_supervisor' requires fanout authorization: include 'subagent' in the effective tools allowlist or enable allowNestedSubagents.");
   }
   const toolExtensionPaths = capabilityCeiling?.denyExtensions ? [] : (input.tools ?? []).filter((tool) => !requestedBuiltinTools.includes(tool) && (tool.includes("/") || tool.endsWith(".ts") || tool.endsWith(".js")));
-  const mcpResolution = capabilityCeiling?.denyExtensions ? { selections: [], unresolvedSelectors: [] } : resolveMcpDirectToolResolution(input.mcpDirectTools, input.cwd, input.runtimeSnapshotHost);
+  const mcpResolution = capabilityCeiling?.denyExtensions ? { selections: [], unresolvedSelectors: [] } : input.builtinMcpTools ? { selections: input.builtinMcpTools, unresolvedSelectors: [], builtin: true } : resolveMcpDirectToolResolution(input.mcpDirectTools, input.cwd, input.runtimeSnapshotHost);
   if (mcpResolution.runtimeServerNames?.length) {
     throw new Error(formatRuntimeSnapshotMcpServersError(input.agentName, mcpResolution.runtimeServerNames));
   }
   if (mcpResolution.unresolvedSelectors.length > 0) {
-    throw new Error(formatUnresolvedMcpDirectToolSelectors(mcpResolution.unresolvedSelectors));
+    throw new Error(mcpResolution.builtin ? formatUnresolvedBuiltinMcpSelectors(input.agentName, mcpResolution.unresolvedSelectors) : formatUnresolvedMcpDirectToolSelectors(mcpResolution.unresolvedSelectors));
   }
   const resolvedMcpSelections = mcpResolution.selections;
   const resolvedMcpNames = new Set(resolvedMcpSelections.map((selection) => selection.name));
-  const legacyMcpNameCounts = countLegacyUnderscoreMcpToolNames(resolvedMcpSelections);
+  const legacyMcpNameCounts = mcpResolution.builtin ? new Map : countLegacyUnderscoreMcpToolNames(resolvedMcpSelections);
   const effectiveMcpSelections = resolvedMcpSelections.filter((selection) => !allowedToolSet || allowedToolSet.has(selection.name) || isLegacyUnderscoreMcpToolAllowed(selection, allowedToolSet, resolvedMcpNames, legacyMcpNameCounts)).filter((selection) => !excludedToolSet.has(selection.name));
   const effectiveMcpTools = effectiveMcpSelections.map((selection) => selection.name);
+  const builtinMcpTools = mcpResolution.builtin ? effectiveMcpSelections : undefined;
   const explicitToolAllowlist = input.tools !== undefined || (input.mcpDirectTools?.length ?? 0) > 0 || allowedToolSet !== undefined;
   const internalTools = (input.structuredOutput ? ["structured_output"] : []).filter((tool) => !excludedToolSet.has(tool));
   const effectiveToolAllowlist = [
@@ -204,9 +206,9 @@ export function resolvePiLaunchToolPlan(input) {
     throw new Error("fast mode requires a child runtime extension, but this launch denies extensions.");
   const fastModeExtensions = resolveFastModeExtension({ fast: input.fast, model: input.model, agentName: input.agentName });
   const runtimeExtensions = [
-    PROMPT_RUNTIME_EXTENSION_PATH,
+    resolveRuntimeModulePath(RUNTIME_EXTENSION_DIR, "subagent-prompt-runtime"),
     ...fastModeExtensions,
-    ...fanoutAuthorized ? [FANOUT_CHILD_EXTENSION_PATH] : [],
+    ...fanoutAuthorized ? [resolveRuntimeModulePath(FANOUT_CHILD_EXTENSION_DIR, "fanout-child")] : [],
     ...permSystemExt ? [permSystemExt] : []
   ];
   const disableAmbientExtensions = capabilityCeiling?.denyExtensions === true || input.extensions !== undefined;
@@ -259,6 +261,7 @@ export function resolvePiLaunchToolPlan(input) {
     resolvedMcpSelections,
     effectiveMcpSelections,
     effectiveMcpTools,
+    builtinMcpTools,
     explicitToolAllowlist,
     internalTools,
     effectiveToolAllowlist,

package/extensions/dm-subagents/src/runs/shared/claude-code-adapter.js

@@ -1,8 +1,14 @@
 import { parseExternalCliJsonlEvent } from "./external-cli-runner.js";
+import { splitKnownThinkingSuffix, THINKING_LEVELS } from "../../shared/model-info.js";
+import { assertThinkingWithinCeiling } from "../../shared/thinking-ceiling.js";
+import { checkModelScope } from "./model-scope.js";
 const MAX_EVENT_TYPE_LENGTH = 128;
 const MAX_ERROR_LENGTH = 4096;
 export const CLAUDE_CODE_ADAPTER_ID = "claude-code";
 export const CLAUDE_CODE_WRITER_ADAPTER_ID = "claude-code-writer";
+export function isClaudeCodeAdapterId(value) {
+  return value === CLAUDE_CODE_ADAPTER_ID || value === CLAUDE_CODE_WRITER_ADAPTER_ID;
+}
 export const CLAUDE_CODE_WRITER_TOOLS = "Read,Write,Edit,Glob,Grep";
 export const CLAUDE_CODE_ENV_ALLOWLIST = [
   "PATH",
@@ -38,6 +44,85 @@ export const CLAUDE_CODE_ENV_ALLOWLIST = [
   "SSL_CERT_FILE",
   "SSL_CERT_DIR"
 ];
+const CLAUDE_CODE_EFFORT_BY_THINKING = {
+  off: undefined,
+  minimal: "low",
+  low: "low",
+  medium: "medium",
+  high: "high",
+  xhigh: "xhigh",
+  max: "max"
+};
+const CLAUDE_CODE_MODEL_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._:/-]*$/;
+const INVALID_CLAUDE_CODE_MODEL = 'expected an alias such as "opus" or a model id such as "claude-opus-5.5"';
+function agentPinnedModel(agent) {
+  const model = typeof agent?.model === "string" ? agent.model : undefined;
+  if (!model)
+    return;
+  if (agent?.modelSource?.type === "subagents.defaultModel" && agent.modelSource.model === model)
+    return;
+  return model;
+}
+function combineClaudeCodeModel(launch, pinned) {
+  if (launch === undefined)
+    return pinned;
+  const { baseModel, thinkingSuffix } = splitKnownThinkingSuffix(launch);
+  if (baseModel)
+    return launch;
+  if (!launch)
+    return launch;
+  const pinnedBase = pinned ? splitKnownThinkingSuffix(pinned).baseModel : "";
+  return pinnedBase && thinkingSuffix ? `${pinnedBase}${thinkingSuffix}` : launch;
+}
+export function resolveClaudeCodeOverride(input) {
+  const args = [];
+  let model;
+  let level;
+  const launchModel = input.model === undefined ? undefined : input.model.trim();
+  const requested = combineClaudeCodeModel(launchModel, agentPinnedModel(input.agent));
+  if (requested !== undefined) {
+    const { baseModel, thinkingSuffix } = splitKnownThinkingSuffix(requested);
+    level = thinkingSuffix ? thinkingSuffix.slice(1) : undefined;
+    if (baseModel) {
+      if (!CLAUDE_CODE_MODEL_PATTERN.test(baseModel))
+        throw new Error(`Invalid Claude Code model ${JSON.stringify(requested)}; ${INVALID_CLAUDE_CODE_MODEL}.`);
+      model = baseModel;
+      args.push("--model", baseModel);
+    } else if (!level) {
+      throw new Error(`Invalid Claude Code model ${JSON.stringify(requested)}; ${INVALID_CLAUDE_CODE_MODEL}.`);
+    }
+  }
+  if (!level && input.thinking !== undefined) {
+    const thinking = input.thinking.trim();
+    if (!THINKING_LEVELS.includes(thinking)) {
+      throw new Error(`Invalid thinking level ${JSON.stringify(input.thinking)}; expected one of ${THINKING_LEVELS.join(", ")}.`);
+    }
+    level = thinking;
+  }
+  if (level) {
+    assertThinkingWithinCeiling({ model: `:${level}`, ceiling: input.thinkingCeiling, agent: input.agentName, runId: input.runId });
+    const effort = CLAUDE_CODE_EFFORT_BY_THINKING[level];
+    if (effort)
+      args.push("--effort", effort);
+  }
+  if (args.length === 0)
+    return;
+  return { args, ...model ? { model } : {} };
+}
+export function assertClaudeCodeModelScope(input) {
+  const enforced = input.scopes.filter((scope) => scope.enforce === true);
+  if (enforced.length === 0)
+    return;
+  if (!input.model) {
+    const subject = input.runId ? `agent '${input.agent}' run '${input.runId}'` : `agent '${input.agent}'`;
+    throw new Error(`${subject} does not name a Claude Code model, so it cannot be checked against an enforced subagent model scope (modelScope). Name the model on the launch, or in the agent's frontmatter, or turn enforcement off.`);
+  }
+  for (const scope of enforced) {
+    const violation = checkModelScope(input.model, scope, "explicit");
+    if (violation)
+      throw new Error(violation.message);
+  }
+}
 function terminalError(event) {
   for (const value of [event.error, event.result]) {
     if (typeof value === "string" && value.trim())
@@ -96,7 +181,8 @@ export function resolveClaudeCodeLaunch(input) {
     "user",
     "--no-session-persistence",
     "--disable-slash-commands",
-    "--no-chrome"
+    "--no-chrome",
+    ...input.overrideArgs ?? []
   ];
   return {
     command: input.command,