@duckmind/dm-darwin-x64 0.66.4 → 0.66.6

package/extensions/dm-subagents/src/runs/shared/dm-spawn.js

@@ -4,29 +4,25 @@ import { fileURLToPath } from "node:url";
 import { DM_CODING_AGENT_PACKAGE_ROOT_ENV } from "../../shared/utils.js";
 export const DM_CODING_AGENT_PACKAGE = "@duckmind/dm-coding-agent";
 export const DM_SUBAGENT_PI_BINARY_ENV = "DM_SUBAGENT_PI_BINARY";
-export const PI_PACKAGE_DIR_ENV = "PI_PACKAGE_DIR";
-export function findPiPackageRootFromEntry(entryPoint, deps = {}) {
-  const pathApi = (deps.platform ?? process.platform) === "win32" ? path.win32 : path.posix;
-  const existsSync = deps.existsSync ?? fs.existsSync;
-  const readFileSync = deps.readFileSync ?? ((filePath, encoding) => fs.readFileSync(filePath, encoding));
-  let dir = pathApi.dirname(entryPoint);
-  while (dir !== pathApi.dirname(dir)) {
-    const packageJsonPath = pathApi.join(dir, "package.json");
-    if (existsSync(packageJsonPath)) {
-      const pkg = JSON.parse(readFileSync(packageJsonPath, "utf-8"));
+export function findPiPackageRootFromEntry(entryPoint) {
+  let dir = path.dirname(entryPoint);
+  while (dir !== path.dirname(dir)) {
+    const packageJsonPath = path.join(dir, "package.json");
+    if (fs.existsSync(packageJsonPath)) {
+      const pkg = JSON.parse(fs.readFileSync(packageJsonPath, "utf-8"));
       if (pkg.name === DM_CODING_AGENT_PACKAGE) {
-        const parent = pathApi.dirname(dir);
-        const parentManifest = pathApi.join(parent, "package.json");
-        if (pathApi.basename(dir) === "dist" && existsSync(parentManifest)) {
+        const parent = path.dirname(dir);
+        const parentManifest = path.join(parent, "package.json");
+        if (path.basename(dir) === "dist" && fs.existsSync(parentManifest)) {
           try {
-            if (JSON.parse(readFileSync(parentManifest, "utf-8")).name === DM_CODING_AGENT_PACKAGE)
+            if (JSON.parse(fs.readFileSync(parentManifest, "utf-8")).name === DM_CODING_AGENT_PACKAGE)
               return parent;
           } catch {}
         }
         return dir;
       }
     }
-    dir = pathApi.dirname(dir);
+    dir = path.dirname(dir);
   }
   return;
 }
@@ -45,76 +41,6 @@ export function resolvePiPackageRoot() {
     return;
   }
 }
-function validateRunningPiRoot(root, source, readFileSync, manifestPath) {
-  const sourceLabel = source === "DM_SUBAGENTS_DM_CODING_AGENT_PACKAGE_ROOT" ? `${source} override` : source;
-  let parsed;
-  try {
-    parsed = JSON.parse(readFileSync(manifestPath, "utf-8"));
-  } catch (error) {
-    const message = error instanceof Error ? error.message : String(error);
-    return { reason: `Could not read a valid DM package manifest at ${manifestPath} (${sourceLabel}): ${message}` };
-  }
-  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed) || parsed.name !== DM_CODING_AGENT_PACKAGE) {
-    const name = parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed.name : undefined;
-    const bundledPlatform = typeof name === "string" && /^@duckmind\/dm-(?:darwin-(?:arm64|x64)|linux-(?:arm64|x64)|windows-x64)$/.test(name) && path.basename(root) === name.slice("@duckmind/".length);
-    if (source !== "bun-adjacent" || !bundledPlatform) {
-      return { reason: `${manifestPath} is not ${DM_CODING_AGENT_PACKAGE} (${sourceLabel})` };
-    }
-  }
-  return { root, source };
-}
-export function resolveRunningPiPackageRoot(deps = {}) {
-  const env = deps.env ?? process.env;
-  const platform = deps.platform ?? process.platform;
-  const pathApi = platform === "win32" ? path.win32 : path.posix;
-  const argv1 = deps.argv1 ?? process.argv[1];
-  const readFileSync = deps.readFileSync ?? ((filePath, encoding) => fs.readFileSync(filePath, encoding));
-  const existsSync = deps.existsSync ?? fs.existsSync;
-  const realpathSync = deps.realpathSync ?? fs.realpathSync;
-  if (argv1) {
-    let entry;
-    try {
-      entry = realpathSync(argv1);
-    } catch {}
-    if (entry) {
-      try {
-        const root = findPiPackageRootFromEntry(entry, { platform, existsSync, readFileSync });
-        if (root)
-          return { root, source: "argv" };
-      } catch (error) {
-        return { reason: `Could not inspect the running DM entry at ${entry}: ${error instanceof Error ? error.message : String(error)}` };
-      }
-    }
-  }
-  for (const [source, value] of [
-    [PI_PACKAGE_DIR_ENV, env[PI_PACKAGE_DIR_ENV]],
-    [DM_CODING_AGENT_PACKAGE_ROOT_ENV, env[DM_CODING_AGENT_PACKAGE_ROOT_ENV]]
-  ]) {
-    const root = value?.trim();
-    if (root)
-      return validateRunningPiRoot(root, source, readFileSync, pathApi.join(root, "package.json"));
-  }
-  const bunVersion = deps.bunVersion ?? process.versions.bun;
-  if (!bunVersion || !argv1 || !/^(?:\/\$bunfs\/|B:[\\/]~BUN[\\/])/.test(argv1))
-    return;
-  const imagePath = deps.execPath ?? process.execPath;
-  let canonicalImage = imagePath;
-  try {
-    canonicalImage = realpathSync(imagePath);
-  } catch {}
-  const imageDir = pathApi.dirname(canonicalImage);
-  const candidates = [
-    { root: imageDir, source: "bun-adjacent" },
-    { root: pathApi.resolve(imageDir, "..", "share", "dm-coding-agent"), source: "bun-share" }
-  ];
-  for (const candidate of candidates) {
-    const manifestPath = pathApi.join(candidate.root, "package.json");
-    if (!existsSync(manifestPath))
-      continue;
-    return validateRunningPiRoot(candidate.root, candidate.source, readFileSync, manifestPath);
-  }
-  return;
-}
 export function resolveBunPiExecutable(deps = {}) {
   const bunVersion = deps.bunVersion ?? process.versions.bun;
   const entry = deps.argv1 ?? process.argv[1];

package/extensions/dm-subagents/src/runs/shared/dynamic-fanout.js

@@ -14,6 +14,7 @@ const DYNAMIC_EXPAND_FROM_KEYS = new Set(["output", "path"]);
 const DYNAMIC_PARALLEL_KEYS = new Set(["agent", "task", "phase", "label", "outputSchema", "cwd", "machine", "output", "outputMode", "reads", "progress", "skill", "model", "fast", "toolBudget", "acceptance", "agentContract", "gateOn"]);
 const RUNNER_DYNAMIC_PARALLEL_KEYS = new Set([
   ...DYNAMIC_PARALLEL_KEYS,
+  "runner",
   "outputName",
   "structured",
   "inheritProjectContext",
@@ -34,6 +35,7 @@ const RUNNER_DYNAMIC_PARALLEL_KEYS = new Set([
   "extensions",
   "subagentOnlyExtensions",
   "mcpDirectTools",
+  "builtinMcpTools",
   "mutationTools",
   "capabilityCeiling",
   "systemPrompt",
@@ -45,6 +47,7 @@ const RUNNER_DYNAMIC_PARALLEL_KEYS = new Set([
   "acceptanceInput",
   "acceptanceRole",
   "parentSessionId",
+  "parentSessionFile",
   "requiredExtensions",
   "launchResolvedExtensions",
   "requestedCwd",

package/extensions/dm-subagents/src/runs/shared/effective-system-prompt.js

@@ -1,7 +1,6 @@
 import { buildAgentMemoryInjection } from "../../agents/agent-memory.js";
 import { appendAgentRefinementOverlay } from "../../agents/agent-refinements.js";
 import { buildSkillInjection } from "../../agents/skills.js";
-import { injectOutputPathSystemPrompt } from "./single-output.js";
 function appendSection(prompt, section) {
   return prompt ? `${prompt}
 
@@ -15,5 +14,5 @@ export function buildEffectiveSystemPrompt(input) {
   if (memoryInjection)
     prompt = appendSection(prompt, memoryInjection);
   prompt = appendAgentRefinementOverlay(prompt, { cwd: input.cwd, agentName: input.agent.name });
-  return injectOutputPathSystemPrompt(prompt, input.outputPath, input.agent);
+  return prompt;
 }

package/extensions/dm-subagents/src/runs/shared/external-cli-preflight.js

@@ -1,6 +1,7 @@
 import { spawnSync } from "node:child_process";
 import * as fs from "node:fs";
 import * as path from "node:path";
+import { resolveNodeExecutable } from "../../shared/node-executable.js";
 const MAX_PROBE_OUTPUT_BYTES = 256 * 1024;
 const MAX_PROBE_TIMEOUT_MS = 5000;
 const MAX_REMOTE_PROBE_TIMEOUT_MS = 15000;
@@ -8,21 +9,26 @@ const MAX_CACHE_ENTRIES = 64;
 const MAX_AVAILABILITY_REASON_LENGTH = 256;
 const cache = new Map;
 const lookup = new Map;
-function resolveBinary(command, env) {
-  if (path.isAbsolute(command) || command.includes(path.sep)) {
+const BATCH_FILE = /\.(cmd|bat)$/i;
+function resolveBinary(command, env, platform = process.platform) {
+  const windows = platform === "win32";
+  if (path.isAbsolute(command) || command.includes(path.sep) || windows && command.includes("/")) {
     const resolved = path.resolve(command);
     fs.accessSync(resolved, fs.constants.X_OK);
     return resolved;
   }
-  const extensions = process.platform === "win32" ? (env.PATHEXT ?? ".EXE;.CMD;.BAT;.COM").split(";") : [""];
-  for (const directory of (env.PATH ?? "").split(path.delimiter)) {
+  const read = (name) => windows ? Object.entries(env).find(([key]) => key.toUpperCase() === name)?.[1] : env[name];
+  const pathExt = windows ? (read("PATHEXT") ?? ".EXE;.CMD;.BAT;.COM").split(";").filter(Boolean) : [];
+  const named = pathExt.some((extension) => command.toLowerCase().endsWith(extension.toLowerCase()));
+  const extensions = windows ? named ? ["", ...pathExt] : pathExt : [""];
+  for (const directory of (read("PATH") ?? "").split(path.delimiter)) {
     if (!directory)
       continue;
     for (const extension of extensions) {
       const candidate = path.join(directory, `${command}${extension}`);
       try {
         fs.accessSync(candidate, fs.constants.X_OK);
-        return fs.realpathSync(candidate);
+        return windows && BATCH_FILE.test(candidate) ? candidate : fs.realpathSync(candidate);
       } catch {}
     }
   }
@@ -37,8 +43,53 @@ export function resolveExternalCliBinaryAvailability(command, env) {
     return { available: false, unavailableReason: reason.slice(0, MAX_AVAILABILITY_REASON_LENGTH) };
   }
 }
+const NPM_NODE_SHIM_HEAD = `@ECHO off
+GOTO start
+:find_dp0
+SET dp0=%~dp0
+EXIT /b
+:start
+SETLOCAL
+CALL :find_dp0
+
+IF EXIST "%dp0%\\node.exe" (
+  SET "_prog=%dp0%\\node.exe"
+) ELSE (
+  SET "_prog=node"
+  SET PATHEXT=%PATHEXT:;.JS;=;%
+)
+
+endLocal & goto #_undefined_# 2>NUL || title %COMSPEC% & "%_prog%"  "%dp0%\\`;
+const NPM_NODE_SHIM_TAIL = `" %*
+`;
+export function resolveExternalCliSpawn(command, args, env, platform = process.platform) {
+  const unchanged = { command, args };
+  if (platform !== "win32")
+    return unchanged;
+  let resolved;
+  try {
+    resolved = resolveBinary(command, env, platform);
+  } catch (error) {
+    if (BATCH_FILE.test(command))
+      throw error;
+    return unchanged;
+  }
+  if (!BATCH_FILE.test(resolved))
+    return unchanged;
+  const shim = fs.readFileSync(resolved, "utf-8").replace(/\r\n/g, `
+`);
+  const target = /\.cmd$/i.test(resolved) && shim.startsWith(NPM_NODE_SHIM_HEAD) && shim.endsWith(NPM_NODE_SHIM_TAIL) ? shim.slice(NPM_NODE_SHIM_HEAD.length, shim.length - NPM_NODE_SHIM_TAIL.length) : "";
+  const directory = path.dirname(resolved);
+  const script = path.resolve(directory, target.split("\\").join(path.sep));
+  if (!target || /^\\|["%:/\n]/.test(target) || !fs.statSync(script, { throwIfNoEntry: false })?.isFile()) {
+    throw new Error(`External CLI '${resolved}' is a batch wrapper that cannot run without a shell. On Windows, only npm-generated Node shims and .exe files can launch.`);
+  }
+  const bundledNode = path.join(directory, "node.exe");
+  return { command: fs.existsSync(bundledNode) ? bundledNode : resolveNodeExecutable(), args: [script, ...args] };
+}
 function probeWithTimeout(binaryPath, args, env, label, timeoutMs, cwd) {
-  const result = spawnSync(binaryPath, [...args], {
+  const launch = resolveExternalCliSpawn(binaryPath, args, env);
+  const result = spawnSync(launch.command, launch.args, {
     cwd,
     env,
     encoding: "utf-8",

package/extensions/dm-subagents/src/runs/shared/external-cli-runner.js

@@ -8,7 +8,8 @@ import { omitExtensionBindingsEnv } from "./extension-bindings.js";
 import { omitGitRoutingEnv } from "./git-environment.js";
 import {
   invalidateExternalCliPreflight,
-  preflightExternalCli
+  preflightExternalCli,
+  resolveExternalCliSpawn
 } from "./external-cli-preflight.js";
 const MAX_OUTPUT_TAIL_BYTES = 64 * 1024;
 const MAX_ERROR_TAIL_BYTES = 64 * 1024;
@@ -144,6 +145,7 @@ export function runExternalCli(input) {
     };
     const env = externalEnvironment(input.environment?.allowlist, input.environment?.values);
     let preflight;
+    let launch;
     try {
       for (const directory of input.temporaryDirectories ?? []) {
         fs.mkdirSync(directory, { mode: 448 });
@@ -160,6 +162,7 @@ export function runExternalCli(input) {
       }
       if (input.preflight)
         preflight = preflightExternalCli(input.command, input.preflight, env, input.cwd);
+      launch = resolveExternalCliSpawn(preflight?.binaryPath ?? input.command, input.args ?? [], env);
     } catch (error) {
       const endedAt = Date.now();
       const externalProcess = { startedAt, endedAt, durationMs: endedAt - startedAt, exitCode: 1, processSignal: null, stdoutPath, stderrPath, ...input.finalOutputPath ? { finalOutputPath: input.finalOutputPath } : {} };
@@ -303,7 +306,7 @@ export function runExternalCli(input) {
       }
       appendPendingLine(chunk.subarray(start));
     };
-    const child = spawn(preflight?.binaryPath ?? input.command, input.args ?? [], {
+    const child = spawn(launch.command, launch.args, {
       cwd: input.cwd,
       env,
       stdio: ["pipe", "pipe", "pipe"],
@@ -384,7 +387,7 @@ export function runExternalCli(input) {
         const stderr = stderrTail.text().trim();
         const parserFailure = parserError?.message ?? (parserTerminal?.state === "failed" ? parserTerminal.error ?? "External CLI parser reported terminal failure." : undefined);
         const treeFailure = process.platform !== "win32" && treeProof?.state === "unknown" ? `Process-tree cleanup failed: ${treeProof.reason}.` : undefined;
-        const error = stopped ? input.stopMessage ?? "Subagent stopped by user." : timedOut ? input.timeoutMessage ?? "Subagent timed out." : spawnError?.message ?? parserFailure ?? treeFailure ?? (exitCode === 0 ? undefined : stderr || `External CLI exited with code ${exitCode}.`);
+        const error = stopped ? input.stopMessage ?? "Subagent stopped." : timedOut ? input.timeoutMessage ?? "Subagent timed out." : spawnError?.message ?? parserFailure ?? treeFailure ?? (exitCode === 0 ? undefined : stderr || `External CLI exited with code ${exitCode}.`);
         if (error && input.preflight && !parserError)
           invalidateExternalCliPreflight(input.command, input.preflight, classifyInvalidation(error));
         const result = {

package/extensions/dm-subagents/src/runs/shared/herdr-placed-run.js

@@ -526,6 +526,7 @@ export class BridgeChannel {
   failure;
   #rejectFailure;
   #failed = false;
+  #adopted = false;
   constructor(socketPath, runId) {
     this.runId = runId;
     this.failure = new Promise((_resolve, reject) => {
@@ -538,9 +539,11 @@ export class BridgeChannel {
         for (const frame of this.decoder.push(chunk)) {
           if (frame.runId !== runId)
             throw new Error("Bridge run identity mismatch.");
-          this.frames.push(frame);
-          if (this.frames.length > 1024)
-            throw new Error("Bridge replay queue exceeded its bound.");
+          if (!this.#adopted) {
+            this.frames.push(frame);
+            if (this.frames.length > 1024)
+              throw new Error("Bridge replay queue exceeded its bound.");
+          }
           const key = typeof frame.requestId === "string" ? `${frame.type}:${frame.requestId}` : "";
           const waiter = this.waiters.get(key);
           if (waiter) {
@@ -572,6 +575,11 @@ export class BridgeChannel {
   get failed() {
     return this.#failed;
   }
+  adopt(listener) {
+    this.#adopted = true;
+    this.listeners.add(listener);
+    return this.frames.splice(0);
+  }
   wait(type, requestId) {
     return new Promise((resolve, reject) => this.waiters.set(`${type}:${requestId}`, { resolve, reject }));
   }
@@ -639,7 +647,7 @@ export class HerdrPiSession {
     this.supervisorDir = runtime.supervisorChannelDir;
     this.#snapshot = { connection: "connected", state: "ready", identity: owner.identity, revision: 0 };
     this.#initialGit = initialGit;
-    bridge.listeners.add((frame) => this.#frame(frame));
+    bridge.adopt((frame) => this.#frame(frame));
     if (this.supervisorDir) {
       this.#replyTimer = setInterval(() => {
         const replies = path.join(this.supervisorDir, "replies");
@@ -707,10 +715,9 @@ export class HerdrPiSession {
     this.bridge = input.bridge;
     this.identity = { ...this.identity, paneId: input.paneId };
     this.#reconnectFailure = undefined;
-    for (const frame of input.bridge.frames)
+    for (const frame of input.bridge.adopt((frame) => this.#frame(frame)))
       if (typeof frame.cursor === "number" && frame.cursor > this.#evidenceCursor)
         this.#frame(frame);
-    input.bridge.listeners.add((frame) => this.#frame(frame));
     for (const operation of this.#operations.values())
       if (!operation.accepted && !operation.settled) {
         operation.settled = true;

package/extensions/dm-subagents/src/runs/shared/mcp-config-sources.js

@@ -25,7 +25,7 @@ export function isMcpServerDefinition(value) {
     if (value[field] !== undefined && !isStringRecord(value[field]))
       return false;
   }
-  for (const field of ["exposeResources", "literalEnv"]) {
+  for (const field of ["exposeResources", "literalEnv", "inheritEnv"]) {
     if (value[field] !== undefined && typeof value[field] !== "boolean")
       return false;
   }

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

@@ -32,6 +32,9 @@ export function resolveMcpDirectToolResolution(mcpDirectTools, cwd = process.cwd
   const selectors = normalizeMcpDirectToolSelectors(mcpDirectTools);
   if (selectors.length === 0)
     return { selections: [], unresolvedSelectors: [] };
+  if (usesBuiltinMcp(runtimeSnapshotHost)) {
+    return resolveBuiltinMcpSelections(selectors, runtimeSnapshotHost.getAllTools?.() ?? []);
+  }
   const config = configOverride ?? loadMcpConfig(cwd);
   const { servers: selectedServers, tools: selectedTools } = parseMcpDirectToolSelectors(selectors);
   const runtimeSelectionServers = new Set([...selectedServers, ...selectedTools.keys()]);
@@ -63,6 +66,55 @@ export function resolveMcpDirectToolResolution(mcpDirectTools, cwd = process.cwd
 export function resolveMcpDirectToolSelections(mcpDirectTools, cwd = process.cwd(), runtimeSnapshotHost) {
   return resolveMcpDirectToolResolution(mcpDirectTools, cwd, runtimeSnapshotHost).selections;
 }
+function usesBuiltinMcp(host) {
+  const commands = host?.getCommands?.() ?? [];
+  return commands.find((command) => command.name === "mcp")?.sourceInfo.path === "builtin:mcp" && !commands.some((command) => /^mcp-adapter(?::\d+)?$/.test(command.name));
+}
+function resolveBuiltinMcpSelections(selectors, tools) {
+  const selections = [];
+  const unresolvedSelectors = [];
+  for (const selector of selectors) {
+    const slash = selector.indexOf("/");
+    const server = slash === -1 ? selector : selector.slice(0, slash);
+    const inServer = tools.filter((tool) => tool.namespace?.name === `mcp__${server.replace(/-/g, "_")}`);
+    const toolName = slash === -1 ? undefined : builtinMcpToolNames(server, selector.slice(slash + 1)).find((name) => inServer.some((tool) => tool.name === name));
+    const matches = inServer.filter((tool) => tool.exposure !== "hidden" && (slash === -1 || tool.name === toolName));
+    if (matches.length === 0)
+      unresolvedSelectors.push(selector);
+    for (const tool of matches) {
+      if (!selections.some((selection) => selection.name === tool.name))
+        selections.push({ name: tool.name, selector });
+    }
+  }
+  return { selections, unresolvedSelectors, builtin: true };
+}
+function builtinMcpToolNames(server, tool) {
+  const name = `mcp__${server}__${tool}`.replace(/[^A-Za-z0-9_]/g, "_");
+  const hash = createHash("sha256").update(`${server}\x00${tool}`).digest("hex").slice(0, 8);
+  const suffixed = `${name.slice(0, 64 - hash.length - 1)}_${hash}`;
+  return name.length <= 64 ? [suffixed, name] : [suffixed];
+}
+export function formatUnresolvedBuiltinMcpSelectors(agentName, selectors) {
+  const subject = agentName ? `Agent '${agentName}'` : "Subagent";
+  return `${subject} selects MCP tools that DM's built-in MCP does not offer: ${selectors.map((selector) => `mcp:${selector}`).join(", ")}. The server may be missing, disconnected, still connecting, or its tools hidden; check /mcp.`;
+}
+export function extensionOnlyMcpServers(selections, host, cwd, projectTrusted) {
+  const registered = new Set(host.getMcpServers?.().map(({ name }) => name));
+  const servers = [...new Set(selections.map(({ selector }) => selector.split("/")[0]))].filter((server) => registered.has(server));
+  if (servers.length === 0)
+    return [];
+  const files = [path.join(getAgentDir(), "mcp.json"), ...projectTrusted ? [path.join(cwd, ".dm", "mcp.json")] : []];
+  const configured = new Set(files.flatMap((file) => {
+    let parsed;
+    try {
+      parsed = JSON.parse(fs.readFileSync(file, "utf-8"));
+    } catch {
+      return [];
+    }
+    return isRecord(parsed) && isRecord(parsed.mcpServers) ? Object.keys(parsed.mcpServers) : [];
+  }));
+  return servers.filter((server) => !configured.has(server));
+}
 function loadMetadataCache() {
   const cachePath = path.join(getAgentDir(), "mcp-cache.json");
   let parsed;
@@ -168,18 +220,15 @@ function loadMcpConfig(cwd) {
   return mergeConfigs({ mcpServers: packageOnlyServers }, mergeConfigs({ mcpServers: pluginServers }, config));
 }
 function getConfigPaths(projectRoot) {
-  const piGlobalPath = path.join(getAgentDir(), "mcp.json");
-  const projectPath = path.resolve(projectRoot, ".mcp.json");
-  const projectPiPath = path.resolve(getProjectConfigDir(projectRoot), "mcp.json");
-  const sources = [];
-  if (GENERIC_GLOBAL_CONFIG_PATH !== piGlobalPath)
-    sources.push(GENERIC_GLOBAL_CONFIG_PATH);
-  sources.push(piGlobalPath);
-  if (projectPath !== piGlobalPath)
-    sources.push(projectPath);
-  if (projectPiPath !== piGlobalPath && projectPiPath !== projectPath)
-    sources.push(projectPiPath);
-  return sources;
+  const agentDir = getAgentDir();
+  const projectDir = getProjectConfigDir(projectRoot);
+  const candidates = [
+    GENERIC_GLOBAL_CONFIG_PATH,
+    path.join(agentDir, "mcp-adapter.json"),
+    path.resolve(projectRoot, ".mcp.json"),
+    path.join(projectDir, "mcp-adapter.json")
+  ];
+  return [...new Set(candidates)];
 }
 function readConfig(configPath) {
   let parsed;
@@ -285,11 +334,14 @@ function isServerCacheValid(entry, definition) {
   return Date.now() - entry.cachedAt <= CACHE_MAX_AGE_MS;
 }
 export function computeMcpServerHash(definition) {
+  const isStdio = definition.command !== undefined;
+  const literalEnv = isStdio && definition.literalEnv === true;
   const identity = {
-    command: definition.command,
+    command: resolveConfigPath(definition.command),
     args: definition.args,
     socket: resolveConfigPath(definition.socket),
-    env: interpolateEnvRecord(definition.env),
+    env: literalEnv ? definition.env : interpolateEnvRecord(definition.env),
+    ...isStdio ? { inheritEnv: definition.inheritEnv !== false, literalEnv } : {},
     cwd: resolveConfigPath(definition.cwd),
     url: resolveServerUrl(definition),
     headers: interpolateEnvRecord(definition.headers),

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

@@ -19,25 +19,45 @@ export function formatChildModelResolutionDiagnostic(diagnostic) {
   if (capabilityCeilingDeniesExtensions(diagnostic)) {
     return (diagnostic.host === "parent" ? [
       `${subject} ran as a foreground child, which never loads the parent's ambient extensions.`,
-      `${denyExtensionsClause(diagnostic)}, so if ${model} is served by a provider extension, that extension cannot load for this child: \`async: true\` does not help either, and listed \`subagentOnlyExtensions\` or \`extensions\` entries are suppressed.`,
+      `${denyExtensionsClause(diagnostic)}, so if ${model} is served by a provider extension or is an extension-registered virtual model, that extension cannot load for this child: \`async: true\` does not help either, and listed \`subagentOnlyExtensions\` or \`extensions\` entries are suppressed.`,
       "Relax the capability ceiling to allow extensions, or use a model that the parent's model registry already resolves."
     ] : [
       `${subject} ran as a background child without the ambient extensions.`,
-      `${denyExtensionsClause(diagnostic)}, so if ${model} is served by a provider extension, that extension cannot load for this child: listed \`subagentOnlyExtensions\` or \`extensions\` entries are suppressed, and leaving \`extensions\` unset does not enable ambient loading.`,
+      `${denyExtensionsClause(diagnostic)}, so if ${model} is served by a provider extension or is an extension-registered virtual model, that extension cannot load for this child: listed \`subagentOnlyExtensions\` or \`extensions\` entries are suppressed, and leaving \`extensions\` unset does not enable ambient loading.`,
       "Relax the capability ceiling to allow extensions, or use a model that the child's model registry already resolves."
     ]).join(`
 `);
   }
   if (diagnostic.host === "parent") {
     return [
-      `${subject} ran as a foreground child, which never loads the parent's ambient extensions but inherits the providers they registered.`,
-      `If ${model} is served by a provider extension, check the parent's \`/model\` list and the child extension diagnostics, or load the extension for this child with \`subagentOnlyExtensions\` or \`extensions\` in the agent frontmatter.`
+      `${subject} ran as a foreground child, which never loads the parent's ambient extensions. It inherits the providers they registered, but not virtual models registered with \`dm.registerVirtualModel()\`.`,
+      `If ${model} is served by a provider extension, check the parent's \`/model\` list and the child extension diagnostics. If it is an extension-registered virtual model, the extension that registers it must load in this child.`,
+      `Load the extension for this child with \`subagentOnlyExtensions\` or \`extensions\` in the agent frontmatter, or register it from the host with \`registerRequiredChildExtensions\` so it loads for every launch.`
     ].join(`
 `);
   }
   return [
     `${subject} ran as a background child without the ambient extensions.`,
-    `If ${model} is served by a provider extension, that extension is not loaded for this child: list it in \`subagentOnlyExtensions\` or \`extensions\` in the agent frontmatter, or leave \`extensions\` unset so the child loads the ambient extensions.`
+    `If ${model} is served by a provider extension or is an extension-registered virtual model, that extension is not loaded for this child: list it in \`subagentOnlyExtensions\` or \`extensions\` in the agent frontmatter, leave \`extensions\` unset so the child loads the ambient extensions, or register it from the host with \`registerRequiredChildExtensions\` so it loads for every launch.`
+  ].join(`
+`);
+}
+export function formatInheritedProviderDiagnostic(diagnostic) {
+  const subject = diagnostic.agent ? `Agent '${diagnostic.agent}'` : "Subagent";
+  const model = diagnostic.model ? `'${diagnostic.model}'` : "this model";
+  const provider = `'${diagnostic.provider}'`;
+  const facts = `${subject} ran as a foreground child, which never loads the parent's ambient extensions. Provider ${provider} for ${model} was registered by a parent extension; the child inherited the provider but not that extension's session hooks.`;
+  if (capabilityCeilingDeniesExtensions(diagnostic)) {
+    return [
+      facts,
+      `${denyExtensionsClause(diagnostic)}, so that extension cannot load for this child: \`async: true\` does not help either, and listed \`subagentOnlyExtensions\` or \`extensions\` entries are suppressed.`,
+      `If ${provider} depends on those hooks, relax the capability ceiling to allow extensions, or use a model whose provider does not.`
+    ].join(`
+`);
+  }
+  return [
+    facts,
+    `If ${provider} depends on those hooks, run this agent with \`async: true\` (a background child loads the ambient extensions unless the agent sets \`extensions\`), or load the extension for this agent with \`subagentOnlyExtensions\` or \`extensions\` in the agent frontmatter.`
   ].join(`
 `);
 }

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

@@ -1,11 +1,15 @@
 import { splitKnownThinkingSuffix as splitThinkingSuffix } from "../../shared/model-info.js";
-import { checkModelScope } from "./model-scope.js";
+import { checkModelScope, SCOPED_PATTERN } from "./model-scope.js";
+import { editDistance } from "../../shared/edit-distance.js";
 
 export { splitThinkingSuffix };
-export function formatSubagentModelVerificationError(expectedModel, observedModel, availableModels, modelResponseAliases) {
+export function formatSubagentModelVerificationError(expectedModel, observedModel, availableModels, modelResponseAliases, observedVirtualModel) {
   if (!availableModels || availableModels.length === 0)
     return;
   const expectedBase = splitThinkingSuffix(expectedModel).baseModel;
+  if (observedVirtualModel !== undefined) {
+    return observedVirtualModel === expectedBase ? undefined : `model_verification_failed: native DM child selected virtual model '${observedVirtualModel}', but the launch candidate was '${expectedModel}'. modelResponseAliases does not apply to a virtual-model selection.`;
+  }
   if (modelResponseAliases && Object.hasOwn(modelResponseAliases, expectedBase) && modelResponseAliases[expectedBase]?.includes(observedModel))
     return;
   const observedBase = splitThinkingSuffix(observedModel).baseModel;
@@ -33,6 +37,19 @@ export function normalizeParentModel(model) {
     return;
   return { provider: candidate.provider, id: candidate.id };
 }
+export function scopedModelIdsFromContext(ctx) {
+  const scoped = ctx.scopedModels;
+  if (!Array.isArray(scoped))
+    return [];
+  const ids = [];
+  for (const entry of scoped) {
+    const model = entry?.model;
+    const normalized = normalizeParentModel(model);
+    if (normalized)
+      ids.push(`${normalized.provider}/${normalized.id}`);
+  }
+  return ids;
+}
 export function normalizeModelSegment(segment) {
   return segment.toLowerCase().replace(/[._]+/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "");
 }
@@ -97,7 +114,12 @@ function resolveBaseModelCandidate(baseModel, availableModels, preferredProvider
     if (exactId)
       return exactId;
   }
-  return fuzzyResolveModel(baseModel, availableModels, preferredProvider);
+  const fuzzy = fuzzyResolveModel(baseModel, availableModels, preferredProvider);
+  if (fuzzy || queryProvider === undefined)
+    return fuzzy;
+  const queryId = normalizeModelSegment(baseModel);
+  const prefixedIdMatches = availableModels.filter((entry) => normalizeModelSegment(entry.id) === queryId && normalizeModelSegment(entry.provider) === queryProvider);
+  return prefixedIdMatches.length === 1 ? prefixedIdMatches[0].fullId : undefined;
 }
 export function fuzzyResolveModel(baseModel, availableModels, preferredProvider) {
   const { queryProvider, queryIdRaw } = splitQualifiedModelQuery(baseModel, availableModels);
@@ -164,12 +186,33 @@ function suggestAlternateProviderModel(model, availableModels) {
     return;
   return `${suggestion}${thinkingSuffix}`;
 }
+const MAX_MODEL_CANDIDATES = 5;
+function closestModelCandidates(model, availableModels) {
+  if (!availableModels || availableModels.length === 0)
+    return [];
+  const { baseModel, thinkingSuffix } = splitThinkingSuffix(model);
+  const { queryProvider, queryIdRaw } = splitQualifiedModelQuery(baseModel, availableModels);
+  const queryId = normalizeModelSegment(queryIdRaw);
+  const queryIdNoDate = stripTrailingDateStamp(queryId);
+  return availableModels.map((entry) => {
+    const id = normalizeModelSegment(entry.id);
+    const distance = editDistance(queryId, id);
+    return {
+      fullId: entry.fullId,
+      sameId: id === queryId || stripTrailingDateStamp(id) === queryIdNoDate,
+      sameProvider: normalizeModelSegment(entry.provider) === queryProvider,
+      distance,
+      close: distance <= Math.max(2, Math.floor(id.length / 3))
+    };
+  }).filter((entry) => entry.sameId || entry.close).sort((left, right) => Number(right.sameId) - Number(left.sameId) || left.distance - right.distance || Number(right.sameProvider) - Number(left.sameProvider) || left.fullId.localeCompare(right.fullId)).slice(0, MAX_MODEL_CANDIDATES).map((entry) => `${entry.fullId}${thinkingSuffix}`);
+}
 function resolveRequiredSubagentModelCandidate(model, availableModels, preferredProvider) {
   const resolved = resolveSubagentModelCandidate(model, availableModels, preferredProvider);
   if (resolved)
     return resolved;
   const suggestion = suggestAlternateProviderModel(model, availableModels);
-  throw new Error(`Unknown subagent model '${model}' in the active DM model registry.${suggestion ? ` Did you mean '${suggestion}'?` : ""}`);
+  const candidates = closestModelCandidates(model, availableModels).filter((candidate) => candidate !== suggestion);
+  throw new Error(`Unknown subagent model '${model}' in the active DM model registry.${suggestion ? ` Did you mean '${suggestion}'?` : ""}${candidates.length ? ` Closest registry models: ${candidates.join(", ")}.` : ""}`);
 }
 function defaultScopeWarn(violation) {
   console.warn(`[dm-subagents] ${violation.message}`);
@@ -177,12 +220,13 @@ function defaultScopeWarn(violation) {
 function configuredScopes(scope) {
   return scope ? Array.isArray(scope) ? scope : [scope] : [];
 }
-function throwForUnresolvedEnforcedInheritScope(scope, includeMixed = false) {
-  const unresolvedInheritScope = configuredScopes(scope).find((entry) => entry.enforce === true && (includeMixed ? entry.allow?.includes(INHERIT_MODEL) : entry.allow?.length === 1 && entry.allow[0] === INHERIT_MODEL));
-  if (!unresolvedInheritScope)
+function throwForUnresolvedEnforcedReservedScope(scope, includeMixed = false) {
+  const unresolvedReservedScope = configuredScopes(scope).find((entry) => entry.enforce === true && (includeMixed ? entry.allow?.some((pattern) => pattern === INHERIT_MODEL || pattern === SCOPED_PATTERN) : entry.allow?.length === 1 && (entry.allow[0] === INHERIT_MODEL || entry.allow[0] === SCOPED_PATTERN)));
+  if (!unresolvedReservedScope)
     return;
-  const origin = unresolvedInheritScope.origin ?? "modelScope";
-  throw new Error(`Cannot enforce subagent model scope (${origin}): 'inherit' requires a current parent session model.`);
+  const origin = unresolvedReservedScope.origin ?? "modelScope";
+  const token = unresolvedReservedScope.allow?.includes(INHERIT_MODEL) ? INHERIT_MODEL : SCOPED_PATTERN;
+  throw new Error(`Cannot enforce subagent model scope (${origin}): '${token}' requires a current parent session model.`);
 }
 function enforceModelScopes(model, scope, source, onWarn) {
   const violations = configuredScopes(scope).map((entry) => checkModelScope(model, entry, source)).filter((violation) => violation !== undefined);
@@ -196,7 +240,7 @@ export function resolveSubagentModelOverride(requestedModel, parentModel, availa
   const trimmed = typeof requestedModel === "string" ? requestedModel.trim() : "";
   const explicit = trimmed && trimmed !== INHERIT_MODEL ? trimmed : undefined;
   if (!parentModel)
-    throwForUnresolvedEnforcedInheritScope(options?.scope, explicit === undefined || options?.source === "inherited");
+    throwForUnresolvedEnforcedReservedScope(options?.scope, explicit === undefined || options?.source === "inherited");
   let resolved;
   let resolvedFromRegistry = explicit === undefined;
   if (explicit === undefined) {
@@ -243,7 +287,7 @@ export function inheritsParentModel(explicitModel, agentModel, parentModel) {
 }
 export function resolveModelSelection(model, availableModels, preferredProvider, options) {
   if (!model)
-    throwForUnresolvedEnforcedInheritScope(options?.scope, true);
+    throwForUnresolvedEnforcedReservedScope(options?.scope, true);
   const origin = options?.origin ?? (options?.primaryModelFromParent ? "inherited" : "configured");
   const requestedModel = origin === "inherited" ? undefined : model;
   const scopes = configuredScopes(options?.scope);