@duckmind/dm-linux-x64 0.65.5 → 0.65.6

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

@@ -0,0 +1,212 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { intersectThinkingCeilings } from "../../shared/thinking-ceiling.js";
+import {
+  resolveChildDepth
+} from "../../shared/types.js";
+import { encodeExtensionBindings, DM_SUBAGENT_EXTENSION_BINDINGS_ENV } from "./extension-bindings.js";
+import { intersectSubagentCapabilityCeilings } from "./capability-ceiling.js";
+import {
+  isSubagentRuntimeExtensionPath,
+  projectLaunchResolvedChildExtensions,
+  resolvePiLaunchToolPlan,
+  supervisorChannelDir
+} from "./child-tool-plan.js";
+import { createCapturedChildHooks, withChildSessionErrorReporting } from "./child-hooks.js";
+import { resolveRequiredChildExtensions } from "../../shared/required-child-extensions.js";
+export const MCP_DIRECT_TOOLS_ENV = "MCP_DIRECT_TOOLS";
+export function inheritedChildRuntime(config) {
+  if (!config)
+    return;
+  return {
+    depth: config.depth,
+    ...config.maxDepth !== undefined ? { maxDepth: config.maxDepth } : {},
+    ...config.nestedRoute ? { nestedRoute: config.nestedRoute } : {},
+    ...config.nestedParent ? { nestedParent: config.nestedParent } : {},
+    ...config.capabilityCeiling ? { capabilityCeiling: config.capabilityCeiling } : {},
+    ...config.thinkingCeiling ? { thinkingCeiling: config.thinkingCeiling } : {},
+    ...config.runFanoutBudget ? { runFanoutBudget: config.runFanoutBudget } : {},
+    ...config.requiredExtensions ? { requiredExtensions: config.requiredExtensions } : {}
+  };
+}
+export function createReportedChildSessionInput(launch, transcriptWriter) {
+  return withChildSessionErrorReporting(launch.session, transcriptWriter);
+}
+function escapeXmlAttr(value) {
+  return value.replace(/&/g, "&amp;").replace(/"/g, "&quot;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
+function inheritedCapabilityCeiling(inherited) {
+  return inherited?.capabilityCeiling;
+}
+function childProcessEnv(input, toolPlan) {
+  const env = {};
+  env[DM_SUBAGENT_EXTENSION_BINDINGS_ENV] = encodeExtensionBindings(input.extensionBindings);
+  if (!toolPlan.capabilityCeiling && input.mcpDirectTools?.length)
+    env[MCP_DIRECT_TOOLS_ENV] = input.mcpDirectTools.join(",");
+  else if (toolPlan.capabilityCeiling && toolPlan.effectiveMcpSelections.length && !toolPlan.capabilityCeiling.denyExtensions) {
+    env[MCP_DIRECT_TOOLS_ENV] = toolPlan.effectiveMcpSelections.map((selection) => selection.selector).join(",");
+  } else
+    env[MCP_DIRECT_TOOLS_ENV] = "__none__";
+  return env;
+}
+function childStorage(input) {
+  if (input.sessionFile) {
+    fs.mkdirSync(path.dirname(input.sessionFile), { recursive: true });
+    return { kind: "file", sessionFile: input.sessionFile };
+  }
+  if (!input.sessionEnabled)
+    return { kind: "memory" };
+  if (input.sessionDir) {
+    fs.mkdirSync(input.sessionDir, { recursive: true });
+    return { kind: "dir", sessionDir: input.sessionDir };
+  }
+  return { kind: "default" };
+}
+export function buildInProcessChildLaunch(input) {
+  const requiredExtensions = input.requiredExtensions ?? input.inherited?.requiredExtensions ?? resolveRequiredChildExtensions(input.parentSessionId);
+  const agentCapabilityCeiling = input.descendantAllowedAgents === undefined ? undefined : { version: 1, allowedAgents: [...input.descendantAllowedAgents], denyExtensions: false, sources: [`agent:${input.childAgentName}`] };
+  const inheritedCeiling = inheritedCapabilityCeiling(input.inherited);
+  const capabilityCeilingForPlanning = agentCapabilityCeiling && !input.capabilityCeiling && !inheritedCeiling ? { version: 1, denyExtensions: false, sources: [] } : input.capabilityCeiling;
+  const toolPlan = resolvePiLaunchToolPlan({
+    tools: input.tools,
+    excludeTools: input.excludeTools,
+    allowNestedSubagents: input.allowNestedSubagents,
+    extensions: input.extensions,
+    subagentOnlyExtensions: input.subagentOnlyExtensions,
+    requiredExtensions,
+    mcpDirectTools: input.mcpDirectTools,
+    cwd: input.cwd,
+    requireReadTool: input.requireReadTool,
+    structuredOutput: Boolean(input.structuredOutput),
+    fast: input.fast,
+    model: input.model,
+    capabilityCeiling: capabilityCeilingForPlanning,
+    inheritedCapabilityCeiling: inheritedCeiling,
+    agentName: input.childAgentName,
+    permissionRules: input.permissionRules,
+    runtimeSnapshotHost: input.runtimeSnapshotHost
+  });
+  toolPlan.capabilityCeiling = intersectSubagentCapabilityCeilings(toolPlan.capabilityCeiling, agentCapabilityCeiling);
+  if (toolPlan.capabilityAudit && toolPlan.capabilityCeiling) {
+    toolPlan.capabilityAudit = { ...toolPlan.capabilityAudit, ceiling: toolPlan.capabilityCeiling };
+  }
+  const inherited = input.inherited;
+  const fanout = toolPlan.fanoutAuthorized;
+  const inheritedRoute = inherited?.nestedRoute;
+  const parentRunId = input.runId ?? inherited?.nestedParent?.parentRunId ?? "";
+  const parentChildIndex = input.childIndex;
+  const parentDepth = inheritedRoute && inherited?.nestedParent ? inherited.nestedParent.depth + 1 : 1;
+  const parentPath = [
+    ...inherited?.nestedParent?.path ?? [],
+    ...parentRunId ? [{ runId: parentRunId, stepIndex: parentChildIndex, agent: input.childAgentName }] : []
+  ];
+  const nestedRoute = fanout ? input.nestedRoute ?? inheritedRoute : undefined;
+  const childDepth = resolveChildDepth(input.maxSubagentDepth, inherited);
+  const permissions = input.permissionRules && Object.keys(input.permissionRules).length > 0 ? { rules: input.permissionRules, ...input.permissionAuditPath ? { auditPath: input.permissionAuditPath } : {} } : undefined;
+  let supervisorDir;
+  if (input.orchestratorIntercomTarget && input.parentSessionId && input.runId) {
+    supervisorDir = supervisorChannelDir(input.runId, input.childAgentName, input.childIndex);
+    fs.mkdirSync(path.join(supervisorDir, "requests"), { recursive: true });
+    fs.mkdirSync(path.join(supervisorDir, "replies"), { recursive: true });
+  }
+  const thinkingCeiling = intersectThinkingCeilings(input.thinkingCeiling, inherited?.thinkingCeiling);
+  let structuredValue;
+  let structuredAcceptanceReport;
+  let structuredCalled = false;
+  let structuredAcceptanceProvided = false;
+  const structuredTerminalState = { captured: false };
+  const config = {
+    cwd: input.cwd,
+    ...input.runId ? { runId: input.runId } : {},
+    agent: input.childAgentName,
+    childIndex: input.childIndex,
+    fanoutChild: fanout,
+    ...input.sessionName?.trim() ? { sessionName: input.sessionName.trim() } : {},
+    ...input.intercomSessionName ? { intercomSessionName: input.intercomSessionName } : {},
+    ...input.orchestratorIntercomTarget ? { orchestratorTarget: input.orchestratorIntercomTarget } : {},
+    ...input.parentSessionId ? { orchestratorSessionId: input.parentSessionId, parentSessionId: input.parentSessionId } : {},
+    ...supervisorDir ? { supervisorChannelDir: supervisorDir } : {},
+    ...nestedRoute ? { nestedRoute } : {},
+    ...fanout && parentRunId ? { nestedParent: { parentRunId, parentChildIndex, depth: parentDepth, path: parentPath } } : {},
+    ...fanout && (input.runFanoutBudget ?? inherited?.runFanoutBudget) ? { runFanoutBudget: input.runFanoutBudget ?? inherited?.runFanoutBudget } : {},
+    depth: childDepth.depth,
+    maxDepth: childDepth.maxDepth,
+    ...toolPlan.capabilityCeiling ? { capabilityCeiling: toolPlan.capabilityCeiling } : {},
+    ...thinkingCeiling ? { thinkingCeiling } : {},
+    ...toolPlan.requiredExtensions.length > 0 ? { requiredExtensions: toolPlan.requiredExtensions } : {},
+    inheritProjectContext: input.inheritProjectContext,
+    inheritGlobalContext: input.inheritGlobalContext,
+    inheritSkills: input.inheritSkills,
+    ...input.forkCacheKey?.trim() ? { forkCacheKey: input.forkCacheKey.trim() } : {},
+    ...permissions ? { permissions } : {},
+    ...input.toolBudget ? { toolBudget: input.toolBudget } : {},
+    ...input.childWatchdog ? { childWatchdog: input.childWatchdog } : {},
+    ...input.watchdogStatus ? { watchdogStatus: input.watchdogStatus } : {},
+    waitTool: {
+      enabled: input.waitToolEnabled ?? true,
+      ...input.waitToolDefaultTimeoutMs !== undefined ? { defaultTimeoutMs: input.waitToolDefaultTimeoutMs } : {}
+    },
+    ...input.structuredOutput ? {
+      structuredOutput: {
+        schema: input.structuredOutput.schema,
+        terminalState: structuredTerminalState,
+        ...input.structuredOutput.acceptanceReportPath ? { acceptanceReport: input.structuredOutput.acceptanceReportRequired ? "required" : "optional" } : {},
+        capture: (value, acceptanceReport) => {
+          structuredCalled = true;
+          structuredValue = value;
+          structuredAcceptanceProvided = acceptanceReport !== undefined;
+          structuredAcceptanceReport = acceptanceReport;
+          structuredTerminalState.captured = true;
+        }
+      }
+    } : {},
+    ...toolPlan.requiredChildTools.length > 0 ? { requiredTools: toolPlan.requiredChildTools } : {},
+    ...toolPlan.effectiveMcpTools.length > 0 ? { mcpDirectTools: toolPlan.effectiveMcpTools } : {},
+    fast: input.fast === true
+  };
+  const capturedHooks = createCapturedChildHooks(config);
+  const extensionPaths = toolPlan.extensionArgs.filter((extensionPath) => !isSubagentRuntimeExtensionPath(extensionPath));
+  const ambientExtensions = input.host === "runner" && !toolPlan.disableAmbientExtensions;
+  const launchResolvedExtensions = projectLaunchResolvedChildExtensions({
+    runtimeExtensions: toolPlan.runtimeExtensions,
+    configuredExtensions: toolPlan.configuredExtensions,
+    extensionArgs: toolPlan.extensionArgs,
+    disableAmbientExtensions: !ambientExtensions,
+    requiredExtensions: toolPlan.requiredExtensions
+  });
+  const taggedPrompt = input.systemPrompt !== undefined && input.systemPrompt !== null ? `<active_agent name="${escapeXmlAttr(input.childAgentName)}"/>
+
+${input.systemPrompt}` : undefined;
+  const session = {
+    cwd: input.cwd,
+    ...input.machine ? { machine: input.machine } : {},
+    ...input.machine ? { remoteResources: { agent: input.childAgentName, ...input.remoteSkillNames ? { skills: input.remoteSkillNames } : {}, ...input.remoteReads !== undefined ? { reads: input.remoteReads } : {}, ...toolPlan.explicitToolAllowlist ? { toolCeiling: [...toolPlan.effectiveToolAllowlist] } : toolPlan.capabilityCeiling?.allowedTools ? { toolCeiling: [...toolPlan.capabilityCeiling.allowedTools] } : {} } } : {},
+    storage: childStorage(input),
+    ...input.model ? { model: input.model } : {},
+    ...toolPlan.explicitToolAllowlist ? { tools: toolPlan.effectiveToolAllowlist } : {},
+    ...!toolPlan.explicitToolAllowlist && toolPlan.excludeTools.length > 0 ? { excludeTools: toolPlan.excludeTools } : {},
+    extensionPaths,
+    requiredExtensions: toolPlan.requiredExtensions,
+    ambientExtensions,
+    hooks: capturedHooks.hooks,
+    ...input.host === "runner" ? { processEnv: childProcessEnv(input, toolPlan) } : {},
+    runtime: config,
+    noSkills: !input.inheritSkills,
+    noContextFiles: !input.inheritProjectContext,
+    ...taggedPrompt !== undefined ? input.systemPromptMode === "replace" ? { systemPrompt: taggedPrompt } : { appendSystemPrompt: taggedPrompt } : {}
+  };
+  return {
+    toolPlan,
+    config,
+    session,
+    capture: {
+      structuredOutput: () => ({ called: structuredCalled, value: structuredValue, acceptanceReport: structuredAcceptanceReport, acceptanceReportProvided: structuredAcceptanceProvided }),
+      toolDiagnostic: capturedHooks.toolDiagnostic,
+      runtimeAcknowledgedExtensions: capturedHooks.runtimeAcknowledgedExtensions,
+      finalDrainHeld: capturedHooks.finalDrainHeld
+    },
+    launchResolvedExtensions,
+    warnings: toolPlan.warnings,
+    ...toolPlan.capabilityAudit ? { capabilityAudit: toolPlan.capabilityAudit } : {}
+  };
+}

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

@@ -0,0 +1,22 @@
+export function projectChildLifecycle(event, terminalAssistantStop = false, state) {
+  if (event.type === "compaction_end") {
+    if (state)
+      state.compactionRetryActive = event.willRetry === true;
+    return event.willRetry === true ? "cancel-drain" : "none";
+  }
+  if (event.type === "agent_start" || event.type === "auto_retry_start" || event.type === "turn_start") {
+    if (state)
+      state.compactionRetryActive = false;
+    return "cancel-drain";
+  }
+  if (event.type === "agent_end") {
+    if (event.willRetry !== true && state)
+      state.compactionRetryActive = false;
+    return "cancel-drain";
+  }
+  if (event.type === "agent_settled")
+    return state?.compactionRetryActive ? "none" : "start-drain";
+  if (terminalAssistantStop)
+    return "start-drain";
+  return "none";
+}

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

@@ -0,0 +1,31 @@
+export const SUBAGENT_CHILD_ENV = "DM_SUBAGENT_CHILD";
+export const SUBAGENT_PARENT_SESSION_ENV = "DM_SUBAGENT_PARENT_SESSION";
+export function childSupervisorMetadata(config) {
+  if (!config.supervisorChannelDir || !config.runId || !config.agent || !config.orchestratorSessionId || config.childIndex === undefined)
+    return;
+  return {
+    channelDir: config.supervisorChannelDir,
+    runId: config.runId,
+    agent: config.agent,
+    childIndex: config.childIndex,
+    ...config.orchestratorTarget ? { orchestratorTarget: config.orchestratorTarget } : {},
+    orchestratorSessionId: config.orchestratorSessionId,
+    ...config.intercomSessionName ? { childTarget: config.intercomSessionName } : {}
+  };
+}
+export function evaluateChildToolDiagnostic(config, availableTools) {
+  if (!config.requiredTools)
+    return;
+  const available = new Set(availableTools);
+  const missing = config.requiredTools.filter((name) => !available.has(name));
+  if (missing.length === 0)
+    return;
+  const missingMcpDirectTools = config.mcpDirectTools?.length ? missing.filter((name) => config.mcpDirectTools.includes(name)) : [];
+  return {
+    ...config.agent ? { agent: config.agent } : {},
+    required: config.requiredTools,
+    available: availableTools,
+    missing,
+    ...missingMcpDirectTools.length > 0 ? { missingMcpDirectTools } : {}
+  };
+}

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

@@ -0,0 +1,378 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { pathToFileURL } from "node:url";
+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";
+import { resolvePackageSubpath } from "../background/runner-aliases.js";
+import { DM_CODING_AGENT_PACKAGE, resolveInstalledPiPackageRoot, resolvePiPackageRoot } from "./dm-spawn.js";
+export function projectChildSessionEventForJson(event) {
+  if (event.type !== "message_update")
+    return event;
+  const assistantMessageEvent = event.assistantMessageEvent;
+  if (!assistantMessageEvent || typeof assistantMessageEvent !== "object")
+    return event;
+  const { partial: _partial, ...delta } = assistantMessageEvent;
+  return { type: "message_update", usage: event.message?.usage, assistantMessageEvent: delta };
+}
+export function childSessionHasQueuedMessages(session) {
+  try {
+    return session?.hasQueuedMessages?.() === true;
+  } catch {
+    return false;
+  }
+}
+function childRegistry(dm, agentDir) {
+  return dm.ModelRegistry.create(dm.AuthStorage.create(path.join(agentDir, "auth.json")), path.join(agentDir, "models.json"));
+}
+function childRuntime(dm, agentDir) {
+  const legacy = dm.ModelRuntime;
+  if (legacy?.create)
+    return legacy.create().then((runtime) => ({ runtime }));
+  const registry = childRegistry(dm, agentDir);
+  return Promise.resolve({
+    registry,
+    runtime: {
+      registerProvider: (name, config) => registry.registerProvider(name, config),
+      registerNativeProvider: (provider) => {
+        throw new Error(`DM cannot inherit native provider '${provider.id}' without its registration config`);
+      },
+      refresh: () => registry.refresh()
+    }
+  });
+}
+function resolveChildModel(registry, reference) {
+  const { baseModel, thinkingSuffix } = splitKnownThinkingSuffix(reference);
+  const slash = baseModel.indexOf("/");
+  const model = slash > 0 ? registry.find(baseModel.slice(0, slash), baseModel.slice(slash + 1)) : registry.getAvailable().find((item) => item.id === baseModel);
+  if (!model)
+    throw new Error(`Model ${reference} not found in child registry`);
+  return { model, ...thinkingSuffix ? { thinkingLevel: thinkingSuffix.slice(1) } : {} };
+}
+function inheritParentProviders(modelRuntime, parentProviders, claimedProviderIds, onError) {
+  let providerIds;
+  const legacy = "getRegisteredProviderIds" in parentProviders ? parentProviders : undefined;
+  const configs = legacy ? undefined : parentProviders.registeredProviders;
+  try {
+    if (!legacy && !(configs instanceof Map))
+      throw new Error("parent model registry does not expose provider registrations");
+    providerIds = legacy ? legacy.getRegisteredProviderIds() : [...configs.keys()];
+  } catch (error) {
+    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;
+  for (const providerId of new Set(providerIds)) {
+    if (claimedProviderIds.has(providerId))
+      continue;
+    try {
+      const native = legacy?.getRegisteredNativeProvider(providerId);
+      const config = native ? undefined : legacy ? legacy.getRegisteredProviderConfig(providerId) : configs?.get(providerId);
+      if (native)
+        modelRuntime.registerNativeProvider(native);
+      else if (config)
+        modelRuntime.registerProvider(providerId, config);
+      else
+        throw new Error(`Parent provider '${providerId}' has no registered native provider or config.`);
+      registered = true;
+    } 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;
+}
+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)
+    return result;
+  const extensions = [...result.extensions];
+  const [promptRuntime] = extensions.splice(index, 1);
+  if (!promptRuntime)
+    return result;
+  extensions.unshift(promptRuntime);
+  return { ...result, extensions };
+}
+let loading = Promise.resolve();
+function resetExtensionCacheOnReload(loader) {
+  if (!("loaded" in loader))
+    return false;
+  loader.loaded = true;
+  return true;
+}
+function applyProcessEnv(values) {
+  if (!values)
+    return;
+  for (const [name, value] of Object.entries(values)) {
+    if (value === undefined)
+      delete process.env[name];
+    else
+      process.env[name] = value;
+  }
+}
+function flushQueuedProviderRegistrations(loader, modelRuntime, onError, requiredPaths) {
+  const claimedProviderIds = new Set;
+  if (!("getExtensions" in loader) || typeof loader.getExtensions !== "function")
+    return { claimedProviderIds, registered: false };
+  const { runtime: loadedRuntime } = loader.getExtensions();
+  const runtime = loadedRuntime;
+  let registered = false;
+  for (const { name, config, extensionPath } of runtime.pendingProviderRegistrations ?? []) {
+    claimedProviderIds.add(name);
+    try {
+      modelRuntime.registerProvider(name, config);
+      registered = true;
+    } catch (error) {
+      onError?.({ extensionPath, event: "register_provider", error });
+      if (requiredPaths.has(extensionPath))
+        throw new Error(`Required child extension provider registration failed for '${extensionPath}': ${error instanceof Error ? error.message : String(error)}`);
+    }
+  }
+  if (Array.isArray(runtime.pendingProviderRegistrations))
+    runtime.pendingProviderRegistrations = [];
+  for (const { provider, extensionPath } of runtime.pendingNativeProviderRegistrations ?? []) {
+    claimedProviderIds.add(provider.id);
+    try {
+      modelRuntime.registerNativeProvider(provider);
+      registered = true;
+    } catch (error) {
+      onError?.({ extensionPath, event: "register_provider", error });
+      if (requiredPaths.has(extensionPath))
+        throw new Error(`Required child extension provider registration failed for '${extensionPath}': ${error instanceof Error ? error.message : String(error)}`);
+    }
+  }
+  if (Array.isArray(runtime.pendingNativeProviderRegistrations))
+    runtime.pendingNativeProviderRegistrations = [];
+  return { claimedProviderIds, registered };
+}
+export async function loadHostPiCodingAgent() {
+  const overrideRoot = process.env[DM_CODING_AGENT_PACKAGE_ROOT_ENV]?.trim() || undefined;
+  const runningRoot = resolvePiPackageRoot();
+  const selectedOverride = runningRoot === undefined ? overrideRoot : undefined;
+  const root = runningRoot ?? selectedOverride ?? resolveInstalledPiPackageRoot();
+  if (root) {
+    const entry = fs.realpathSync(resolveHostPackageEntry(root, selectedOverride));
+    return import(pathToFileURL(entry).href);
+  }
+  return import(DM_CODING_AGENT_PACKAGE);
+}
+function resolveHostPackageEntry(root, overrideRoot) {
+  const packageJson = path.join(root, "package.json");
+  const source = fs.readFileSync(packageJson, "utf8");
+  let parsed;
+  try {
+    parsed = JSON.parse(source);
+  } catch (error) {
+    throw new Error(`invalid host SDK manifest at ${packageJson}: malformed JSON`, { cause: error });
+  }
+  if (!isUnknownRecord(parsed))
+    throw new Error(`invalid host SDK manifest at ${packageJson}: expected a JSON object`);
+  const pkg = parsed;
+  if (pkg.name !== DM_CODING_AGENT_PACKAGE) {
+    const source = overrideRoot !== undefined ? ` (${DM_CODING_AGENT_PACKAGE_ROOT_ENV} override)` : "";
+    throw new Error(`refusing to load the host SDK from ${root}${source}: package.json name is "${String(pkg.name ?? "(none)")}", expected "${DM_CODING_AGENT_PACKAGE}"`);
+  }
+  const entry = resolvePackageSubpath(root, ".");
+  if (!entry)
+    throw new Error(`host SDK manifest at ${packageJson} has no resolvable root export`);
+  return entry;
+}
+function isUnknownRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+export function createDefaultChildSessionFactory(options = {}) {
+  const loadPiCodingAgent = options.loadPiCodingAgent ?? loadHostPiCodingAgent;
+  const shutdownTimeoutMs = options.shutdownTimeoutMs ?? 5000;
+  let runtime;
+  const live = new Set;
+  const shutdowns = new Set;
+  const sharedRuntime = async (dm, agentDir) => {
+    runtime ??= childRuntime(dm, agentDir).catch((error) => {
+      runtime = undefined;
+      throw error;
+    });
+    return runtime;
+  };
+  return {
+    async create(launch) {
+      const dm = await loadPiCodingAgent();
+      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 themeKey = Symbol.for("@duckmind/dm-coding-agent:theme");
+      const themeInitialized = Boolean(globalThis[themeKey]);
+      if (!themeInitialized && typeof dm.initTheme === "function")
+        dm.initTheme(settingsManager.getTheme());
+      const loader = new dm.DefaultResourceLoader({
+        cwd: launch.cwd,
+        agentDir,
+        settingsManager,
+        noExtensions: !launch.ambientExtensions,
+        noSkills: launch.noSkills,
+        noPromptTemplates: true,
+        noThemes: true,
+        noContextFiles: launch.noContextFiles,
+        additionalExtensionPaths: launch.extensionPaths,
+        extensionFactories: launch.hooks.map(({ factory }) => factory),
+        extensionsOverride: prioritizeChildPromptRuntime,
+        ...launch.systemPrompt !== undefined ? { systemPrompt: launch.systemPrompt } : {},
+        ...launch.appendSystemPrompt !== undefined ? { appendSystemPrompt: [launch.appendSystemPrompt] } : {}
+      });
+      const open = async () => {
+        const requiredPaths = new Set((launch.requiredExtensions ?? []).map(({ path }) => path));
+        applyProcessEnv(launch.processEnv);
+        if (!resetExtensionCacheOnReload(loader) && (launch.ambientExtensions || launch.extensionPaths.length))
+          launch.onExtensionError?.({ extensionPath: "<loader>", event: "load", error: new Error("dm's extension cache reset is unavailable; extensions loaded into this child share module state with other sessions in this process.") });
+        await loader.reload();
+        const loadErrors = requiredPaths.size > 0 ? loader.getExtensions().errors.filter(({ path }) => requiredPaths.has(path)) : [];
+        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) {
+          try {
+            await modelRuntime.refresh({ allowNetwork: false });
+          } catch (error) {
+            launch.onExtensionError?.({ extensionPath: "<provider-refresh>", event: "refresh_providers", error });
+            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 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");
+        if (resolvedModel && "error" in resolvedModel && resolvedModel.error)
+          throw new Error(resolvedModel.error);
+        const { session } = await dm.createAgentSession({
+          cwd: launch.cwd,
+          agentDir,
+          ...modelRegistry ? { modelRegistry } : {},
+          ...resolvedModel?.model ? { model: resolvedModel.model } : {},
+          ...resolvedModel?.thinkingLevel ? { thinkingLevel: resolvedModel.thinkingLevel } : {},
+          ...launch.tools ? { tools: launch.tools } : {},
+          ...launch.excludeTools?.length ? { excludeTools: launch.excludeTools } : {},
+          resourceLoader: loader,
+          sessionManager,
+          settingsManager,
+          sessionStartEvent: { type: "session_start", reason: "startup" }
+        });
+        pinChildCacheRetention(session.agent);
+        try {
+          await session.bindExtensions({
+            mode: "print",
+            onError: (error) => launch.onExtensionError?.({ extensionPath: error.extensionPath, event: error.event, error: error.error })
+          });
+        } catch (error) {
+          session.dispose();
+          throw error;
+        }
+        return session;
+      };
+      const opened = loading.catch(() => {}).then(open);
+      loading = opened;
+      const session = await opened;
+      let pending;
+      const shutdown = async () => {
+        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 });
+        } finally {
+          session.dispose();
+        }
+      };
+      const child = {
+        subscribe: (listener) => session.subscribe((event) => listener(event)),
+        prompt: (text) => session.prompt(text),
+        steer: (text) => session.steer(text),
+        followUp: (text) => session.followUp(text),
+        abort: () => session.abort(),
+        hasQueuedMessages: () => session.agent?.hasQueuedMessages?.() === true,
+        dispose: () => {
+          if (!pending) {
+            live.delete(child);
+            const shutdownDone = shutdown();
+            pending = shutdownDone;
+            shutdowns.add(shutdownDone);
+            shutdownDone.finally(() => shutdowns.delete(shutdownDone));
+          }
+          return pending;
+        },
+        get messages() {
+          return session.messages;
+        },
+        get sessionFile() {
+          return session.sessionFile;
+        },
+        get sessionId() {
+          return session.sessionId;
+        },
+        get modelId() {
+          return session.model ? `${session.model.provider}/${session.model.id}` : undefined;
+        },
+        get contextWindow() {
+          return session.model?.contextWindow;
+        }
+      };
+      live.add(child);
+      return child;
+    },
+    async dispose() {
+      const children = [...live].filter((child) => !child.detached);
+      for (const child of children)
+        child.shutDown = true;
+      await Promise.allSettled(children.map((child) => child.abort()));
+      for (const child of children) {
+        try {
+          child.dispose();
+        } catch {}
+      }
+      await Promise.allSettled([...shutdowns]);
+      if (live.size === 0)
+        runtime = undefined;
+    }
+  };
+}
+let activeFactory;
+let activeFactoryModule;
+export function childSessionFactory() {
+  activeFactory ??= createLazyPlacementFactory(createDefaultChildSessionFactory());
+  return activeFactory;
+}
+function createLazyPlacementFactory(local) {
+  let placed;
+  const factory = async () => placed ??= (await import("./herdr-placed-run.js")).createPlacementAwareChildSessionFactory(local);
+  return {
+    async create(launch) {
+      return launch.machine ? (await factory()).create(launch) : local.create(launch);
+    },
+    async dispose() {
+      if (placed)
+        await placed.dispose();
+      else
+        await local.dispose();
+    }
+  };
+}
+export function createPlacementChildSessionFactory(options = {}) {
+  return createLazyPlacementFactory(createDefaultChildSessionFactory(options));
+}
+export function setChildSessionFactory(factory) {
+  activeFactory = factory;
+}
+export function childSessionFactoryModule() {
+  return activeFactoryModule;
+}
+export function setChildSessionFactoryModule(modulePath) {
+  activeFactoryModule = modulePath;
+}
+export async function disposeChildSessions() {
+  const factory = activeFactory;
+  if (!factory)
+    return;
+  await factory.dispose();
+}