@duckmind/dm-linux-x64 0.65.5 → 0.65.6

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

@@ -0,0 +1,299 @@
+import { createHash } from "node:crypto";
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { fileURLToPath } from "node:url";
+import {
+  formatUnresolvedMcpDirectToolSelectors,
+  resolveMcpDirectToolResolution
+} from "./mcp-direct-tool-allowlist.js";
+import {
+  TEMP_ROOT_DIR
+} from "../../shared/types.js";
+import { THINKING_LEVELS } from "../../shared/model-info.js";
+import { getAgentDir } from "../../shared/utils.js";
+import { snapshotRequiredChildExtensions } from "../../shared/required-child-extensions.js";
+import {
+  capabilityCeilingAgentRestrictionSources,
+  intersectSubagentCapabilityCeilings,
+  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 SUBAGENT_RUNTIME_EXTENSION_PATHS = new Set([
+  PROMPT_RUNTIME_EXTENSION_PATH,
+  FANOUT_CHILD_EXTENSION_PATH,
+  FAST_MODE_EXTENSION_PATH
+].map((extensionPath) => path.normalize(extensionPath)));
+export function isSubagentRuntimeExtensionPath(extensionPath) {
+  return SUBAGENT_RUNTIME_EXTENSION_PATHS.has(path.normalize(extensionPath));
+}
+const FAST_MODE_PROVIDER_PREFIX = "openai-codex/";
+const OPENAI_PROMPT_CACHE_KEY_MAX_LENGTH = 64;
+export function deriveForkPromptCacheKey(parentSessionId) {
+  const parent = parentSessionId?.trim();
+  if (!parent)
+    return;
+  const digest = createHash("sha256").update(parent).digest("hex").slice(0, OPENAI_PROMPT_CACHE_KEY_MAX_LENGTH - "dm-fork:".length);
+  return `dm-fork:${digest}`;
+}
+function sanitizeSupervisorChannelSegment(value) {
+  return value.trim().replace(/[^A-Za-z0-9._-]+/g, "-").replace(/^-+|-+$/g, "") || "unknown";
+}
+export function supervisorChannelDir(runId, agent, childIndex) {
+  return path.join(TEMP_ROOT_DIR, "supervisor-channels", `${sanitizeSupervisorChannelSegment(runId)}-${sanitizeSupervisorChannelSegment(agent)}-${childIndex}`);
+}
+export function applyThinkingSuffix(model, thinking, replaceExisting = false) {
+  if (!model || !thinking)
+    return model;
+  const colonIdx = model.lastIndexOf(":");
+  if (colonIdx !== -1 && THINKING_LEVELS.some((level) => level === model.substring(colonIdx + 1))) {
+    return replaceExisting ? `${model.slice(0, colonIdx)}:${thinking}` : model;
+  }
+  return `${model}:${thinking}`;
+}
+function stripThinkingSuffix(model) {
+  const colonIdx = model.lastIndexOf(":");
+  if (colonIdx === -1)
+    return model;
+  return THINKING_LEVELS.some((level) => level === model.substring(colonIdx + 1)) ? model.slice(0, colonIdx) : model;
+}
+function resolveFastModeExtension(input) {
+  if (!input.fast)
+    return [];
+  const candidates = (input.model ? [input.model] : []).map(stripThinkingSuffix);
+  if (candidates.length === 0) {
+    throw new Error(`fast mode requires an explicit supported native OpenAI-Codex model${input.agentName ? ` for agent '${input.agentName}'` : ""}.`);
+  }
+  const unsupported = candidates.filter((model) => !model.startsWith(FAST_MODE_PROVIDER_PREFIX));
+  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];
+}
+function extensionIdentifier(value) {
+  return `sha256:${createHash("sha256").update(path.normalize(value.trim())).digest("hex").slice(0, 16)}`;
+}
+function boundedExtensionIdentifiers(values) {
+  const ids = [...new Set(values.map(extensionIdentifier))];
+  return {
+    ids: ids.slice(0, MAX_LAUNCH_RESOLVED_EXTENSION_IDS),
+    omitted: Math.max(0, ids.length - MAX_LAUNCH_RESOLVED_EXTENSION_IDS)
+  };
+}
+function hasPermissionRules(rules) {
+  return rules !== undefined && Object.keys(rules).length > 0;
+}
+export function formatRuntimeSnapshotMcpServersError(agentName, serverNames) {
+  const subject = agentName ? `Agent '${agentName}'` : "Subagent";
+  return `${subject} selects MCP tools from servers that exist only in dm-mcp-adapter's runtime snapshot (${serverNames.join(", ")}). MCP servers from the runtime snapshot cannot be provided to in-process children; MCP tools must come from an ambient adapter extension in a background child (\`async: true\`), so add the server to the adapter's configuration file instead.`;
+}
+export function projectLaunchResolvedChildExtensions(toolPlan) {
+  const runtime = boundedExtensionIdentifiers(toolPlan.runtimeExtensions);
+  const configured = boundedExtensionIdentifiers(toolPlan.configuredExtensions);
+  const effective = boundedExtensionIdentifiers(toolPlan.extensionArgs);
+  return {
+    version: 1,
+    source: "launch-resolved",
+    disableAmbientExtensions: toolPlan.disableAmbientExtensions,
+    runtime: runtime.ids,
+    configured: configured.ids,
+    required: toolPlan.requiredExtensions.map(({ id }) => id),
+    effective: effective.ids,
+    omitted: {
+      runtime: runtime.omitted,
+      configured: configured.omitted,
+      required: 0,
+      effective: effective.omitted
+    }
+  };
+}
+export function resolvePermissionSystemExtension() {
+  const agentDir = getAgentDir();
+  const candidates = [
+    path.join(agentDir, "npm", "node_modules", "@gotgenes", "dm-permission-system"),
+    path.join(agentDir, "extensions", "dm-permission-system")
+  ];
+  const errors = [];
+  for (const extDir of candidates) {
+    if (!fs.existsSync(extDir))
+      continue;
+    const pkgPath = path.join(extDir, "package.json");
+    if (!fs.existsSync(pkgPath)) {
+      errors.push(new Error(`Permission-system package manifest is missing at ${pkgPath}.`));
+      continue;
+    }
+    try {
+      let pkg;
+      const parsed = JSON.parse(fs.readFileSync(pkgPath, "utf-8"));
+      if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+        throw new Error("manifest root must be an object");
+      }
+      pkg = parsed;
+      const extensions = pkg.dm?.extensions;
+      const entry = Array.isArray(extensions) ? extensions[0] : undefined;
+      if (typeof entry !== "string" || !entry.trim()) {
+        throw new Error(`Permission-system package manifest at ${pkgPath} must declare dm.extensions[0] as a non-empty string.`);
+      }
+      const resolved = path.resolve(extDir, entry);
+      if (fs.existsSync(resolved))
+        return resolved;
+      throw new Error(`Permission-system extension entry ${JSON.stringify(entry)} in ${pkgPath} does not exist at ${resolved}.`);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      errors.push(message.startsWith("Permission-system") ? new Error(message) : new Error(`Cannot read permission-system package manifest at ${pkgPath}: ${message}`));
+    }
+  }
+  if (errors.length > 0)
+    throw errors[0];
+  return;
+}
+export function resolvePiLaunchToolPlan(input) {
+  const capabilityCeiling = intersectSubagentCapabilityCeilings(input.capabilityCeiling, input.inheritedCapabilityCeiling);
+  const requiredExtensions = snapshotRequiredChildExtensions(input.requiredExtensions ?? []);
+  if (requiredExtensions.length > 0 && capabilityCeiling?.denyExtensions) {
+    throw new Error(`Capability ceiling from ${capabilityCeiling.sources.join(", ") || "unknown source"} denies extensions but this host requires: ${requiredExtensions.map(({ id }) => id).join(", ")}.`);
+  }
+  const allowedToolSet = capabilityCeiling?.allowedTools === undefined ? undefined : new Set(capabilityCeiling.allowedTools);
+  const requestedBuiltinTools = input.tools?.filter((tool) => !(tool.includes("/") || tool.endsWith(".ts") || tool.endsWith(".js"))) ?? [];
+  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 declaredBuiltinTools = ceilingFilteredBuiltinTools;
+  const excludeTools = [...new Set((input.excludeTools ?? []).map((tool) => tool.trim()).filter(Boolean))];
+  const excludedToolSet = new Set(excludeTools);
+  const effectiveDeclaredBuiltinTools = declaredBuiltinTools.filter((tool) => !excludedToolSet.has(tool));
+  const fanoutAuthorized = effectiveDeclaredBuiltinTools.includes("subagent") || input.allowNestedSubagents === true && !excludedToolSet.has("subagent") && (!allowedToolSet || allowedToolSet.has("subagent"));
+  if (effectiveDeclaredBuiltinTools.includes("subagent_supervisor") && !fanoutAuthorized) {
+    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);
+  if (mcpResolution.runtimeServerNames?.length) {
+    throw new Error(formatRuntimeSnapshotMcpServersError(input.agentName, mcpResolution.runtimeServerNames));
+  }
+  if (mcpResolution.unresolvedSelectors.length > 0) {
+    throw new Error(formatUnresolvedMcpDirectToolSelectors(mcpResolution.unresolvedSelectors));
+  }
+  const resolvedMcpSelections = mcpResolution.selections;
+  const resolvedMcpNames = new Set(resolvedMcpSelections.map((selection) => selection.name));
+  const legacyMcpNameCounts = 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 explicitToolAllowlist = input.tools !== undefined || (input.mcpDirectTools?.length ?? 0) > 0 || allowedToolSet !== undefined;
+  const internalTools = (input.structuredOutput ? ["structured_output"] : []).filter((tool) => !excludedToolSet.has(tool));
+  const effectiveToolAllowlist = [
+    ...new Set([
+      ...effectiveDeclaredBuiltinTools,
+      ...effectiveMcpTools,
+      ...internalTools
+    ])
+  ];
+  const legacySupervisorPairing = effectiveDeclaredBuiltinTools.includes("contact_supervisor");
+  const requiredChildTools = explicitToolAllowlist ? [
+    ...new Set([
+      ...input.tools !== undefined ? effectiveDeclaredBuiltinTools : [],
+      ...input.mcpDirectTools?.length ? effectiveMcpTools : [],
+      ...internalTools
+    ].filter((tool) => tool !== "contact_supervisor" && (!legacySupervisorPairing || tool !== "intercom")))
+  ] : [];
+  const permSystemExt = capabilityCeiling?.denyExtensions ? undefined : hasPermissionRules(input.permissionRules) ? resolvePermissionSystemExtension() : undefined;
+  if (input.fast && capabilityCeiling?.denyExtensions)
+    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,
+    ...fastModeExtensions,
+    ...fanoutAuthorized ? [FANOUT_CHILD_EXTENSION_PATH] : [],
+    ...permSystemExt ? [permSystemExt] : []
+  ];
+  const disableAmbientExtensions = capabilityCeiling?.denyExtensions === true || input.extensions !== undefined;
+  const warnings = [];
+  if (capabilityCeiling?.denyExtensions !== true && Array.isArray(input.extensions) && input.extensions.length === 0) {
+    const agentLabel = input.agentName ? ` for agent '${input.agentName}'` : "";
+    warnings.push(`extensions: [] override${agentLabel} disables ALL ambient extensions for this child (not just "adds nothing"), ` + "including any model-provider extension needed to resolve a provider-qualified model. " + "List the extensions this child actually needs instead of an empty array.");
+  }
+  const configuredExtensions = capabilityCeiling?.denyExtensions ? [] : [
+    ...toolExtensionPaths,
+    ...input.extensions ?? [],
+    ...input.subagentOnlyExtensions ?? []
+  ];
+  const ordinaryExtensionArgs = disableAmbientExtensions ? [...new Set([...runtimeExtensions, ...configuredExtensions])] : [
+    ...new Set([
+      ...runtimeExtensions,
+      ...toolExtensionPaths,
+      ...input.subagentOnlyExtensions ?? []
+    ])
+  ];
+  const extensionArgs = [...new Set([...ordinaryExtensionArgs, ...requiredExtensions.map(({ path }) => path)])];
+  const requestedToolNames = input.tools !== undefined ? [
+    ...new Set([
+      ...requestedBuiltinTools,
+      ...resolvedMcpSelections.map((selection) => selection.name)
+    ])
+  ] : undefined;
+  const capabilityAudit = capabilityCeiling ? {
+    ceiling: capabilityCeiling,
+    ...requestedToolNames ? { requestedTools: requestedToolNames } : {},
+    effectiveTools: effectiveToolAllowlist,
+    ...excludeTools.length > 0 ? { excludeTools } : {},
+    removedTools: requestedToolNames?.filter((tool) => !effectiveToolAllowlist.includes(tool)) ?? [],
+    internalTools,
+    extensionsDenied: capabilityCeiling.denyExtensions,
+    removedExtensionCount: capabilityCeiling.denyExtensions ? (input.extensions?.length ?? 0) + (input.subagentOnlyExtensions?.length ?? 0) + (input.tools ?? []).filter((tool) => tool.includes("/") || tool.endsWith(".ts") || tool.endsWith(".js")).length : 0,
+    requestedMcpToolCount: input.mcpDirectTools?.length ?? 0,
+    effectiveMcpTools,
+    agentAllowed: input.agentName === undefined ? true : isAgentAllowedByCapabilityCeiling(input.agentName, capabilityCeiling),
+    ...capabilityCeilingAgentRestrictionSources(capabilityCeiling) ? {
+      agentRestrictionSources: capabilityCeilingAgentRestrictionSources(capabilityCeiling)
+    } : {}
+  } : undefined;
+  return {
+    ...capabilityCeiling ? { capabilityCeiling } : {},
+    requestedBuiltinTools,
+    declaredBuiltinTools,
+    excludeTools,
+    toolExtensionPaths,
+    resolvedMcpSelections,
+    effectiveMcpSelections,
+    effectiveMcpTools,
+    explicitToolAllowlist,
+    internalTools,
+    effectiveToolAllowlist,
+    requiredChildTools,
+    fanoutAuthorized,
+    runtimeExtensions,
+    configuredExtensions,
+    requiredExtensions,
+    extensionArgs,
+    disableAmbientExtensions,
+    warnings,
+    ...capabilityAudit ? { capabilityAudit } : {}
+  };
+}
+function countLegacyUnderscoreMcpToolNames(selections) {
+  const counts = new Map;
+  for (const selection of selections) {
+    const legacyName = legacyUnderscoreMcpToolName(selection);
+    if (legacyName !== selection.name)
+      counts.set(legacyName, (counts.get(legacyName) ?? 0) + 1);
+  }
+  return counts;
+}
+function isLegacyUnderscoreMcpToolAllowed(selection, allowedToolSet, resolvedMcpNames, legacyMcpNameCounts) {
+  const legacyName = legacyUnderscoreMcpToolName(selection);
+  return legacyMcpNameCounts.get(legacyName) === 1 && !resolvedMcpNames.has(legacyName) && allowedToolSet.has(legacyName);
+}
+function legacyUnderscoreMcpToolName(selection) {
+  const slash = selection.selector.indexOf("/");
+  if (slash < 1)
+    return selection.name;
+  const toolName = selection.selector.slice(slash + 1);
+  const suffix = `_${toolName}`;
+  if (!selection.name.endsWith(suffix))
+    return selection.name;
+  const prefix = selection.name.slice(0, -suffix.length);
+  return `${prefix.replace(/-/g, "_")}${suffix}`;
+}

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

@@ -107,7 +107,7 @@ export function resolveClaudeCodeLaunch(input) {
       versionArgs: [...prefix, "--version"],
       helpArgs: [...prefix, "--help"],
       validate(result) {
-        if (!/^\d+\.\d+\.\d+(?:[-+][0-9A-Za-z.-]+)? \(Claude Code\)$/.test(result.version))
+        if (!/^(?:\d+\.\d+\.\d+(?:[-+][0-9A-Za-z.-]+)? \(Claude Code\)|\d{4}\.\d{1,2}\.\d{1,2} [A-Za-z0-9._-]+ \(\d{4}-\d{2}-\d{2}\))$/.test(result.version))
           throw new Error(`Unsupported Claude Code version response: ${JSON.stringify(result.version)}.`);
         for (const required of ["Claude Code - starts an interactive session", "--print", "--input-format", "stream-json", "--verbose", "--permission-mode", writer ? "acceptEdits" : "plan", "--tools", "--strict-mcp-config", "--mcp-config", "--setting-sources", "--no-session-persistence", "--disable-slash-commands", "--no-chrome"]) {
           if (!result.help.includes(required))

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

@@ -1,23 +1,41 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
 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 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)
+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"));
+      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)) {
+          try {
+            if (JSON.parse(readFileSync(parentManifest, "utf-8")).name === DM_CODING_AGENT_PACKAGE)
+              return parent;
+          } catch {}
+        }
         return dir;
+      }
     }
-    dir = path.dirname(dir);
+    dir = pathApi.dirname(dir);
   }
   return;
 }
 export function resolveInstalledPiPackageRoot() {
-  return findPiPackageRootFromEntry(fileURLToPath(import.meta.resolve(DM_CODING_AGENT_PACKAGE)));
+  try {
+    return findPiPackageRootFromEntry(fileURLToPath(import.meta.resolve(DM_CODING_AGENT_PACKAGE)));
+  } catch {
+    return;
+  }
 }
 export function resolvePiPackageRoot() {
   try {
@@ -27,10 +45,87 @@ 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) {
+    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];
+  if (!bunVersion || !entry || !/^(?:\/\$bunfs\/|B:[\\/]~BUN[\\/])/.test(entry))
+    return;
+  const env = deps.env ?? process.env;
+  return env[DM_SUBAGENT_PI_BINARY_ENV]?.trim() || (deps.execPath ?? process.execPath);
+}
+function isNodeScriptPath(filePath) {
+  return /\.(?:mjs|cjs|js)$/i.test(filePath);
+}
 function isRunnableNodeScript(filePath, existsSync) {
   if (!existsSync(filePath))
     return false;
-  return /\.(?:mjs|cjs|js)$/i.test(filePath);
+  return isNodeScriptPath(filePath);
 }
 function normalizePath(filePath) {
   return path.isAbsolute(filePath) ? filePath : path.resolve(filePath);
@@ -39,11 +134,23 @@ function isStandalonePiExecutable(execPath) {
   const executableName = execPath.split(/[\\/]/).pop();
   return /^dm(?:\.exe)?$/i.test(executableName ?? "");
 }
+function resolvePiCliScriptFromPackageJson(packageJsonPath, readFileSync, existsSync) {
+  const packageJson = JSON.parse(readFileSync(packageJsonPath, "utf-8"));
+  if (packageJson.name !== DM_CODING_AGENT_PACKAGE)
+    return;
+  const binField = packageJson.bin;
+  const binPath = typeof binField === "string" ? binField : binField?.dm ?? Object.values(binField ?? {})[0];
+  if (!binPath)
+    return;
+  const candidate = path.resolve(path.dirname(packageJsonPath), binPath);
+  return isRunnableNodeScript(candidate, existsSync) ? candidate : undefined;
+}
 export function resolvePiCliScript(deps = {}) {
   const existsSync = deps.existsSync ?? fs.existsSync;
   const realpathSync = deps.realpathSync ?? fs.realpathSync;
   const readFileSync = deps.readFileSync ?? ((filePath, encoding) => fs.readFileSync(filePath, encoding));
   const argv1 = deps.argv1 ?? process.argv[1];
+  const env = deps.env ?? process.env;
   if (argv1) {
     const argvPath = normalizePath(argv1);
     if (isRunnableNodeScript(argvPath, existsSync)) {
@@ -55,35 +162,41 @@ export function resolvePiCliScript(deps = {}) {
       } catch {}
     }
   }
-  try {
-    const resolvePackageJson = deps.resolvePackageJson ?? (() => {
-      const root = deps.piPackageRoot ?? resolvePiPackageRoot();
-      if (root)
-        return path.join(root, "package.json");
-      const packageRoot = deps.resolvePackageEntry ? findPiPackageRootFromEntry(deps.resolvePackageEntry()) : resolveInstalledPiPackageRoot();
-      if (!packageRoot)
-        throw new Error(`Could not resolve ${DM_CODING_AGENT_PACKAGE} package root`);
-      return path.join(packageRoot, "package.json");
-    });
-    const packageJsonPath = resolvePackageJson();
-    const packageJson = JSON.parse(readFileSync(packageJsonPath, "utf-8"));
-    const binField = packageJson.bin;
-    const binPath = typeof binField === "string" ? binField : binField?.dm ?? Object.values(binField ?? {})[0];
-    if (!binPath)
-      return;
-    const candidate = path.resolve(path.dirname(packageJsonPath), binPath);
-    if (isRunnableNodeScript(candidate, existsSync)) {
-      return candidate;
-    }
-  } catch {
-    return;
+  const packageJsonCandidates = [];
+  if (deps.resolvePackageJson)
+    packageJsonCandidates.push(deps.resolvePackageJson);
+  for (const root of [deps.piPackageRoot, env[DM_CODING_AGENT_PACKAGE_ROOT_ENV], resolvePiPackageRoot()]) {
+    const trimmed = root?.trim();
+    if (trimmed)
+      packageJsonCandidates.push(() => path.join(trimmed, "package.json"));
+  }
+  packageJsonCandidates.push(() => {
+    const packageRoot = deps.resolvePackageEntry ? findPiPackageRootFromEntry(deps.resolvePackageEntry()) : resolveInstalledPiPackageRoot();
+    return packageRoot ? path.join(packageRoot, "package.json") : undefined;
+  });
+  for (const candidatePackageJson of packageJsonCandidates) {
+    try {
+      const packageJsonPath = candidatePackageJson();
+      if (!packageJsonPath)
+        continue;
+      const candidate = resolvePiCliScriptFromPackageJson(packageJsonPath, readFileSync, existsSync);
+      if (candidate)
+        return candidate;
+    } catch {}
   }
   return;
 }
 export function getPiSpawnCommand(args, deps = {}) {
+  const platform = deps.platform ?? process.platform;
   const env = deps.env ?? process.env;
   const piBinary = env[DM_SUBAGENT_PI_BINARY_ENV]?.trim();
   if (piBinary) {
+    if (platform === "win32" && isNodeScriptPath(piBinary)) {
+      return {
+        command: deps.execPath ?? process.execPath,
+        args: [piBinary, ...args]
+      };
+    }
     return { command: piBinary, args };
   }
   const execPath = deps.execPath ?? process.execPath;
@@ -97,5 +210,8 @@ export function getPiSpawnCommand(args, deps = {}) {
       args: [piCliPath, ...args]
     };
   }
+  if (platform === "win32") {
+    throw new Error(`Could not resolve the DM CLI on Windows. Set ${DM_SUBAGENT_PI_BINARY_ENV} or ensure ${DM_CODING_AGENT_PACKAGE} is installed.`);
+  }
   return { command: "dm", args };
 }

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

@@ -11,7 +11,7 @@ const DYNAMIC_STEP_KEYS = new Set(["expand", "parallel", "collect", "concurrency
 const RUNNER_DYNAMIC_STEP_KEYS = new Set([...DYNAMIC_STEP_KEYS, "effectiveAcceptance", "acceptanceInput", "acceptanceRole", "sessionFiles", "thinkingOverrides"]);
 const DYNAMIC_EXPAND_KEYS = new Set(["from", "item", "key", "maxItems", "onEmpty"]);
 const DYNAMIC_EXPAND_FROM_KEYS = new Set(["output", "path"]);
-const DYNAMIC_PARALLEL_KEYS = new Set(["agent", "task", "phase", "label", "outputSchema", "cwd", "output", "outputMode", "reads", "progress", "skill", "model", "fast", "toolBudget", "acceptance", "agentContract", "gateOn"]);
+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,
   "outputName",
@@ -29,24 +29,26 @@ const RUNNER_DYNAMIC_PARALLEL_KEYS = new Set([
   "structuredOutput",
   "structuredOutputSchema",
   "tools",
+  "excludeTools",
   "allowNestedSubagents",
   "extensions",
   "subagentOnlyExtensions",
   "mcpDirectTools",
   "mutationTools",
   "capabilityCeiling",
-  "completionGuard",
   "systemPrompt",
   "systemPromptMode",
   "thinking",
-  "modelCandidates",
+  "requestedModel",
   "sessionFile",
   "effectiveAcceptance",
   "acceptanceInput",
   "acceptanceRole",
   "parentSessionId",
+  "requiredExtensions",
   "launchResolvedExtensions",
-  "requestedCwd"
+  "requestedCwd",
+  "machineEnv"
 ]);
 const DYNAMIC_COLLECT_KEYS = new Set(["as", "outputSchema"]);
 export function isSafeOutputName(name) {

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

@@ -0,0 +1,19 @@
+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}
+
+${section}` : section;
+}
+export function buildEffectiveSystemPrompt(input) {
+  let prompt = input.agent.systemPrompt?.trim() ?? "";
+  if (input.resolvedSkills.length > 0)
+    prompt = appendSection(prompt, buildSkillInjection(input.resolvedSkills));
+  const memoryInjection = buildAgentMemoryInjection(input.agent, input.cwd);
+  if (memoryInjection)
+    prompt = appendSection(prompt, memoryInjection);
+  prompt = appendAgentRefinementOverlay(prompt, { cwd: input.cwd, agentName: input.agent.name });
+  return injectOutputPathSystemPrompt(prompt, input.outputPath, input.agent);
+}

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

@@ -76,6 +76,7 @@ export function resolveExternalCliRunnerStatus(input) {
     ...claudeCodeWriter ? { safety: { access: "workspace-write", authentication: "existing-cli-required", permissionMode: "acceptEdits", tools: "Read,Write,Edit,Glob,Grep", mcp: "empty-strict", settingSources: "user", userSettingsTrust: "required", sessionPersistence: false } } : {},
     ...cursorAgent ? { safety: { access: "read-only", authentication: "cursor-api-key-or-existing-login", mode: "ask", sandbox: "enabled", workspaceTrust: "existing-required", sessionReuse: false } } : {},
     ...cursorAgentWriter ? { safety: { access: "workspace-write", authentication: "cursor-api-key-or-existing-login", mode: "print", sandbox: "enabled", workspaceTrust: "existing-required", sessionReuse: false } } : {},
+    ...input.machine ? { machine: input.machine } : {},
     capabilities: {
       stop: true,
       steer: false,
@@ -98,11 +99,13 @@ export function normalizeExternalCliRunnerStatus(value) {
     return;
   const args = Array.isArray(input.args) && input.args.every((arg) => typeof arg === "string") ? input.args : undefined;
   const promptDelivery = input.promptDelivery === "stdin" ? "stdin" : undefined;
+  const machine = input.machine && typeof input.machine === "object" && !Array.isArray(input.machine) ? input.machine : undefined;
   const adapterId = input.adapter && typeof input.adapter === "object" && !Array.isArray(input.adapter) ? input.adapter.id : undefined;
   if (adapterId === "grok-build") {
     return {
       type: "external-cli",
       command: input.command,
+      ...machine ? { machine } : {},
       args: args ?? [],
       promptDelivery: "prompt-file",
       adapter: { id: "grok-build", version: 1, executionMode: "one-shot-prompt-file" },
@@ -112,13 +115,15 @@ export function normalizeExternalCliRunnerStatus(value) {
     };
   }
   const adapter = isCodeOwnedExternalCliAdapterId(adapterId) ? adapterId : undefined;
-  return resolveExternalCliRunnerStatus({ ...adapter ? { adapter } : {}, command: input.command, ...args ? { args } : {}, ...promptDelivery ? { promptDelivery } : {} });
+  return resolveExternalCliRunnerStatus({ ...adapter ? { adapter } : {}, command: input.command, ...args ? { args } : {}, ...promptDelivery ? { promptDelivery } : {}, ...machine ? { machine } : {} });
 }
 export function externalCliReceiptMetadata(input) {
   const { runner } = input;
+  const machine = input.externalProcess?.machine ?? runner.machine;
   return {
     adapter: { ...runner.adapter },
     capabilities: { ...runner.capabilities },
+    ...machine ? { machine: { ...machine, ...machine.remoteGit ? { remoteGit: { ...machine.remoteGit } } : {} } } : {},
     ...runner.safety ? { safety: { ...runner.safety } } : {},
     ...input.externalProcess ? {
       outputArtifacts: {