@duckmind/dm-linux-x64 0.65.4 → 0.65.6

package/extensions/dm-subagents/src/extension/config.js

@@ -6,9 +6,10 @@ import { FLEET_KEYBINDING_ACTIONS } from "../shared/types.js";
 import { validateMissionStoreConfig } from "../missions/store.js";
 import { validateAuthorityPolicy } from "../policy/authority.js";
 import { getAgentDir } from "../shared/utils.js";
-import { DEFAULT_MODEL_EXCLUSION_TTL_MS, MAX_MODEL_EXCLUSION_TTL_MS, setDefaultTTL } from "../runs/shared/model-exclusions.js";
 import { validatePermissionConfig } from "../runs/shared/permissions.js";
 import { MAX_ABANDONED_SLOT_RELEASE_AFTER_MS, MIN_ABANDONED_SLOT_RELEASE_AFTER_MS } from "../runs/background/active-async-capacity.js";
+import { normalizeWorktreeBranchPrefix } from "../runs/shared/worktree.js";
+import { validateModelResponseAliases } from "../shared/model-response-aliases.js";
 const ARTIFACT_DIR_PREFERENCES = new Set(["project", "session", "temp"]);
 const FLEET_KEYBINDING_ACTION_SET = new Set(FLEET_KEYBINDING_ACTIONS);
 const KEY_MODIFIERS = new Set(["ctrl", "shift", "alt", "super"]);
@@ -98,16 +99,6 @@ function validateCapacityConfig(value) {
     throw new Error(`config.capacity.abandonedSlotReleaseAfterMs must be false or an integer from ${MIN_ABANDONED_SLOT_RELEASE_AFTER_MS} to ${MAX_ABANDONED_SLOT_RELEASE_AFTER_MS}`);
   }
 }
-function validateModelExclusionsConfig(value) {
-  if (value === undefined)
-    return;
-  if (!value || typeof value !== "object" || Array.isArray(value))
-    throw new Error("config.modelExclusions must be a JSON object");
-  const defaultTtlMs = value.defaultTtlMs;
-  if (defaultTtlMs !== undefined && (typeof defaultTtlMs !== "number" || !Number.isFinite(defaultTtlMs) || defaultTtlMs <= 0 || defaultTtlMs > MAX_MODEL_EXCLUSION_TTL_MS)) {
-    throw new Error(`config.modelExclusions.defaultTtlMs must be a finite positive number no greater than ${MAX_MODEL_EXCLUSION_TTL_MS}`);
-  }
-}
 function validateOrcaProgressTabsConfig(value) {
   if (value === undefined)
     return;
@@ -136,10 +127,24 @@ function validateMainWindowRendererConfig(value) {
   }
 }
 function validateConfig(config) {
+  if (config.worktree !== undefined && typeof config.worktree !== "boolean") {
+    throw new Error("config.worktree must be a boolean");
+  }
+  if (config.worktreeProvider !== undefined && config.worktreeProvider !== "auto" && config.worktreeProvider !== "native" && config.worktreeProvider !== "worktrunk") {
+    throw new Error('config.worktreeProvider must be "auto", "native", or "worktrunk"');
+  }
+  if (config.worktreeBranchPrefix !== undefined) {
+    if (typeof config.worktreeBranchPrefix !== "string")
+      throw new Error("config.worktreeBranchPrefix must be a string");
+    normalizeWorktreeBranchPrefix(config.worktreeBranchPrefix);
+  }
   if (config.defaultSubagentContext !== undefined && config.defaultSubagentContext !== "fresh" && config.defaultSubagentContext !== "fork") {
     throw new Error('config.defaultSubagentContext must be "fresh" or "fork"');
   }
   validateForkContextConfig(config.forkContext);
+  if (config.checkpointBeforeDeadlineMs !== undefined && (typeof config.checkpointBeforeDeadlineMs !== "number" || !Number.isInteger(config.checkpointBeforeDeadlineMs) || config.checkpointBeforeDeadlineMs <= 0 || config.checkpointBeforeDeadlineMs > 2147483647)) {
+    throw new Error("config.checkpointBeforeDeadlineMs must be a positive integer no larger than 2147483647");
+  }
   if (config.foregroundDetachShortcut !== undefined && (typeof config.foregroundDetachShortcut !== "string" || !isValidKeyId(config.foregroundDetachShortcut))) {
     throw new Error('config.foregroundDetachShortcut must be a valid keybinding string such as "ctrl+b"');
   }
@@ -159,7 +164,9 @@ function validateConfig(config) {
   validateFleetKeybindingsConfig(config.fleetKeybindings);
   validateArtifactConfig(config.artifactConfig);
   validateCapacityConfig(config.capacity);
-  validateModelExclusionsConfig(config.modelExclusions);
+  if (config.modelExclusions !== undefined)
+    throw new Error("config.modelExclusions was removed; model failures are no longer persisted or used for automatic switching");
+  validateModelResponseAliases(config.modelResponseAliases);
   validateMainWindowRendererConfig(config.mainWindowRenderer);
   validateOrcaProgressTabsConfig(config.orcaProgressTabs);
 }
@@ -188,12 +195,6 @@ export function updateConfig(updater) {
   saveConfig(next, configPath);
   return next;
 }
-export function resolveModelExclusionTTL(config) {
-  return config.modelExclusions?.defaultTtlMs ?? DEFAULT_MODEL_EXCLUSION_TTL_MS;
-}
-export function applyModelExclusionsConfig(config) {
-  setDefaultTTL(resolveModelExclusionTTL(config), { shortenExisting: config.modelExclusions?.defaultTtlMs !== undefined });
-}
 export function resolveAsyncByDefault(config) {
   return config.asyncByDefault !== false;
 }
@@ -204,6 +205,14 @@ export function loadConfig() {
   } catch (error) {
     if (error instanceof PrunedForkConfigError)
       throw error;
+    try {
+      const raw = JSON.parse(fs.readFileSync(configPath, "utf-8"));
+      if (raw && typeof raw === "object" && !Array.isArray(raw) && (Object.hasOwn(raw, "worktreeProvider") || Object.hasOwn(raw, "worktreeBranchPrefix") || Object.hasOwn(raw, "modelResponseAliases") || Object.hasOwn(raw, "modelExclusions") || Object.hasOwn(raw, "checkpointBeforeDeadlineMs")))
+        throw error;
+    } catch (readError) {
+      if (readError === error)
+        throw error;
+    }
     console.error(`Failed to load subagent config from '${configPath}':`, error);
   }
   return {};

package/extensions/dm-subagents/src/extension/doctor.js

@@ -4,7 +4,6 @@ import { discoverAgentsAll } from "../agents/agents.js";
 import { isAsyncAvailable } from "../runs/background/async-execution.js";
 import { formatSpawnBudgetSummary, getSpawnBudgetSnapshot } from "../runs/shared/spawn-budget.js";
 import { getActiveAsyncCapacitySnapshot, resolveAbandonedSlotReleaseAfterMs, resolveMaxActiveAsyncRunsPerSession } from "../runs/background/active-async-capacity.js";
-import { decodeRunFanoutBudgetDescriptor, formatRunFanoutBudget, getRunFanoutBudgetSnapshot, RUN_FANOUT_BUDGET_ENV } from "../runs/shared/run-fanout-budget.js";
 import { diagnoseIntercomBridge } from "../intercom/intercom-bridge.js";
 import { discoverAvailableSkills } from "../agents/skills.js";
 import {
@@ -135,14 +134,6 @@ function formatSpawnBudgetSection(input) {
   ];
 }
 function formatRunFanoutSection(input) {
-  try {
-    const inherited = decodeRunFanoutBudgetDescriptor(process.env[RUN_FANOUT_BUDGET_ENV]);
-    if (inherited) {
-      return [`- usage: ${formatRunFanoutBudget(getRunFanoutBudgetSnapshot(inherited)).replace(/^Run fan-out: /, "")}`, `- root run: ${inherited.rootRunId}`, "- reset boundary: cumulative claims are never released; a new top-level run creates a new budget"];
-    }
-  } catch (error) {
-    return [`- inherited budget: invalid — ${errorText(error)}`];
-  }
   const configured = resolveMaxSubagentSpawnsPerRun(input.config.maxSubagentSpawnsPerRun);
   const source = normalizeMaxSubagentSpawnsPerRun(process.env.DM_SUBAGENT_MAX_SPAWNS_PER_RUN) !== undefined ? "environment" : normalizeMaxSubagentSpawnsPerRun(input.config.maxSubagentSpawnsPerRun) !== undefined ? "config" : "default";
   return [`- configured limit: ${configured} (${source})`, "- usage: available after a run starts", "- reset boundary: cumulative claims are never released; a new top-level run creates a new budget"];
@@ -162,12 +153,18 @@ function formatPermissionSystemSection() {
   const lines = [];
   const parentSession = process.env["DM_SUBAGENT_PARENT_SESSION"] ?? "";
   const trimmed = parentSession.trim();
-  if (trimmed) {
-    lines.push(`- parent session: set (${trimmed})`);
+  const isChild = process.env["DM_SUBAGENT_CHILD"] === "1";
+  if (isChild && trimmed) {
+    lines.push(`- runner parent session: set (${trimmed}) — explicit target for this dedicated child process`);
+  } else if (isChild) {
+    lines.push("- runner parent session: not set — this child process has no forwarding target");
+  } else if (trimmed) {
+    lines.push("- root parent session: ignored legacy process-global value — root sessions do not use it for routing");
   } else {
-    lines.push("- parent session: not set — ask forwarding from subprocess children will not reach a parent UI");
+    lines.push("- root parent session: not set (healthy) — detached forwarding is attached at runner launch");
   }
-  const isChild = process.env["DM_SUBAGENT_CHILD"] === "1";
+  if (!isChild)
+    lines.push("- foreground external ask forwarding: unavailable until the permission extension supports a session-scoped target");
   lines.push(`- subagent process: ${isChild ? "yes (DM_SUBAGENT_CHILD=1)" : "no"}`);
   return lines;
 }

package/extensions/dm-subagents/src/extension/fanout-child.js

@@ -5,13 +5,16 @@ import { discoverAgents } from "../agents/agents.js";
 import { getArtifactsDir } from "../shared/artifacts.js";
 import { createSubagentExecutor } from "../runs/foreground/subagent-executor.js";
 import { resolveWaitToolConfig } from "../runs/background/wait-config.js";
-import { SUBAGENT_CHILD_ENV, SUBAGENT_FANOUT_CHILD_ENV } from "../runs/shared/dm-args.js";
-import { readNestedControlRequests, resolveNestedRouteFromEnv, writeNestedControlResult } from "../runs/shared/nested-events.js";
+import { readNestedControlRequests, resolveInheritedNestedRoute, writeNestedControlResult } from "../runs/shared/nested-events.js";
 import { deliverSubagentIntercomMessageEvent } from "../intercom/result-intercom.js";
+import { createNativeSupervisorChannel, NATIVE_SUPERVISOR_TOOL_NAME, resolveSupervisorChannelDir } from "../intercom/native-supervisor-channel.js";
+import { readStatus } from "../shared/utils.js";
 import { resolveSubagentIntercomTarget } from "../intercom/intercom-bridge.js";
 import { createSubagentParamsSchema } from "./schemas.js";
 import { finalizeToolResult } from "./tool-result.js";
 import { loadConfig, resolveAsyncByDefault } from "./config.js";
+import { SUBAGENT_ASYNC_STARTED_EVENT } from "../shared/types.js";
+import { createChildExternalJobBridgeSweeper } from "../runs/shared/external-job-bridge.js";
 function getSubagentSessionRoot(parentSessionFile) {
   if (parentSessionFile) {
     const baseName = path.basename(parentSessionFile, ".jsonl");
@@ -23,7 +26,7 @@ function getSubagentSessionRoot(parentSessionFile) {
 function expandTilde(p) {
   return p.startsWith("~/") ? path.join(os.homedir(), p.slice(2)) : p;
 }
-function createChildSafeState() {
+export function createChildSafeState() {
   return {
     baseCwd: "",
     currentSessionId: null,
@@ -45,12 +48,8 @@ function createChildSafeState() {
     }
   };
 }
-function resolveNestedControlRoute() {
-  try {
-    return resolveNestedRouteFromEnv();
-  } catch {
-    return;
-  }
+function resolveNestedControlRoute(config) {
+  return config.nestedRoute ? resolveInheritedNestedRoute(config.nestedRoute) : undefined;
 }
 function nestedControlRouteKey(route) {
   return route.controlInbox;
@@ -119,8 +118,8 @@ ${request.message.trim()}`, 500, { source: "nested-resume", runId: request.targe
   timer.unref?.();
   return () => clearInterval(timer);
 }
-export default function registerFanoutChildSubagentExtension(dm) {
-  if (process.env[SUBAGENT_CHILD_ENV] !== "1" || process.env[SUBAGENT_FANOUT_CHILD_ENV] !== "1")
+export default function registerFanoutChildSubagentExtension(dm, childConfig) {
+  if (!childConfig.fanoutChild)
     return;
   const globalStore = globalThis;
   const registeredKey = "__piSubagentFanoutChildRegisteredApis";
@@ -131,7 +130,48 @@ export default function registerFanoutChildSubagentExtension(dm) {
   registeredApis.add(dm);
   const config = loadConfig();
   const waitToolConfig = resolveWaitToolConfig(config.waitTool);
-  const state = createChildSafeState();
+  const state = childConfig.runtimeState ?? createChildSafeState();
+  const asyncChildren = new Map;
+  const foregroundChannels = new Set;
+  const supervisorChannel = createNativeSupervisorChannel(dm, state, {
+    getChannelDirs: () => {
+      const dirs = new Set;
+      for (const run of state.foregroundControls.values()) {
+        for (const child of run.activeChildren?.values() ?? [])
+          dirs.add(resolveSupervisorChannelDir(run.runId, child.agent, child.index));
+      }
+      for (const run of state.foregroundRuns?.values() ?? []) {
+        for (const child of run.children) {
+          if (child.status === "detached")
+            dirs.add(resolveSupervisorChannelDir(run.runId, child.agent, child.index));
+        }
+      }
+      const retiringForeground = [...foregroundChannels].filter((dir) => !dirs.has(dir));
+      for (const dir of dirs)
+        foregroundChannels.add(dir);
+      for (const dir of retiringForeground)
+        dirs.add(dir);
+      const retiringAsync = [];
+      for (const [id, child] of asyncChildren) {
+        const status = readStatus(child.dir);
+        if (status && status.state !== "queued" && status.state !== "running")
+          retiringAsync.push(id);
+        for (const [index, agent] of child.agents.entries())
+          dirs.add(resolveSupervisorChannelDir(id, agent, index));
+      }
+      return {
+        dirs: [...dirs],
+        retire: () => {
+          for (const dir of retiringForeground)
+            foregroundChannels.delete(dir);
+          for (const id of retiringAsync)
+            asyncChildren.delete(id);
+        }
+      };
+    }
+  });
+  const hasPendingSupervisorRequest = supervisorChannel.hasPendingRequests;
+  childConfig.hasPendingSupervisorRequest = hasPendingSupervisorRequest;
   const executor = createSubagentExecutor({
     dm,
     state,
@@ -143,7 +183,10 @@ export default function registerFanoutChildSubagentExtension(dm) {
     getSubagentSessionRoot,
     expandTilde,
     discoverAgents,
-    allowMutatingManagementActions: false
+    allowMutatingManagementActions: false,
+    childRuntime: childConfig,
+    activateSupervisorTransport: supervisorChannel.activateTransport,
+    findPendingAsks: supervisorChannel.findPendingAsks
   });
   const params = createSubagentParamsSchema();
   const tool = {
@@ -161,7 +204,41 @@ export default function registerFanoutChildSubagentExtension(dm) {
     }
   };
   dm.registerTool(tool);
-  const route = resolveNestedControlRoute();
+  const bridgeSweeper = createChildExternalJobBridgeSweeper();
+  const unsubscribeBridgeStarted = dm.events.on(SUBAGENT_ASYNC_STARTED_EVENT, (payload) => {
+    const info = payload;
+    if (info.id && info.asyncDir && info.sessionId === state.currentSessionId)
+      bridgeSweeper.track(info.id, info.asyncDir);
+  });
+  let unsubscribeAsyncStarted;
+  dm.on("session_start", (_event, ctx) => {
+    supervisorChannel.registerTools();
+    if (!dm.getAllTools().some((tool) => tool.name === NATIVE_SUPERVISOR_TOOL_NAME))
+      return;
+    state.supervisorOwnerSessionId = ctx.sessionManager.getSessionId() || null;
+    unsubscribeAsyncStarted = dm.events.on(SUBAGENT_ASYNC_STARTED_EVENT, (payload) => {
+      const info = payload;
+      if (!info.id || !info.asyncDir || info.sessionId !== state.currentSessionId)
+        return;
+      const agents = info.agents ?? (info.agent ? [info.agent] : []);
+      asyncChildren.set(info.id, { dir: info.asyncDir, agents });
+      supervisorChannel.activateTransport();
+    });
+    supervisorChannel.start();
+    supervisorChannel.activateTransport();
+  });
+  dm.on("session_shutdown", () => {
+    unsubscribeAsyncStarted?.();
+    unsubscribeBridgeStarted?.();
+    bridgeSweeper.dispose();
+    asyncChildren.clear();
+    foregroundChannels.clear();
+    supervisorChannel.dispose();
+    if (childConfig.hasPendingSupervisorRequest === hasPendingSupervisorRequest)
+      childConfig.hasPendingSupervisorRequest = undefined;
+    state.supervisorOwnerSessionId = null;
+  });
+  const route = resolveNestedControlRoute(childConfig);
   if (!route)
     return;
   const listenerCleanupKey = "__piSubagentFanoutChildNestedControlInboxCleanups";

package/extensions/dm-subagents/src/extension/herdr-dm-bridge.js

@@ -0,0 +1,258 @@
+import { spawnSync } from "node:child_process";
+import * as fs from "node:fs";
+import * as net from "node:net";
+import * as path from "node:path";
+import { Type } from "typebox";
+import packageJson from "../../package.json";
+import { encodeHerdrPiFrame, HERDR_PI_MAX_FRAME_BYTES, HERDR_PI_PROTOCOL, HERDR_PI_RUN_ENV, HERDR_PI_RUNTIME_DIR_ENV, HerdrPiFrameDecoder, validateHerdrPiRunId } from "../runs/shared/herdr-dm-protocol.js";
+import { discoverAgents } from "../agents/agents.js";
+import { buildSkillInjection, resolveSkills } from "../agents/skills.js";
+import { buildAgentMemoryInjection } from "../agents/agent-memory.js";
+import { appendAgentRefinementOverlay } from "../agents/agent-refinements.js";
+import { rewriteSubagentPrompt } from "../runs/shared/subagent-prompt-runtime.js";
+import { resolveExistingReadPaths } from "../shared/settings.js";
+function gitEvidence(cwd) {
+  const run = (args) => spawnSync("git", args, { cwd, encoding: "utf8", timeout: 5000, maxBuffer: 128 * 1024 });
+  const inside = run(["rev-parse", "--is-inside-work-tree"]);
+  if (inside.status !== 0)
+    return;
+  const head = run(["rev-parse", "HEAD"]);
+  const branch = run(["symbolic-ref", "--quiet", "--short", "HEAD"]);
+  const dirty = run(["status", "--porcelain"]);
+  return { ...head.status === 0 ? { head: head.stdout.trim() } : {}, ...branch.status === 0 ? { branch: branch.stdout.trim() } : {}, dirty: Boolean(dirty.stdout.trim()) };
+}
+export function resolveRemoteHerdrResources(cwd, resources, remoteDefaultTools = []) {
+  if (!/^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/u.test(resources.agent) || resources.skills?.some((name) => !/^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/u.test(name)) || resources.toolCeiling?.some((name) => !/^[A-Za-z0-9_-]{1,64}$/u.test(name)) || resources.reads !== undefined && resources.reads !== false && (!Array.isArray(resources.reads) || resources.reads.some((name) => typeof name !== "string")))
+    throw new Error("Remote logical resource names are invalid.");
+  const discovered = discoverAgents(cwd, "both").agents.filter((agent) => agent.name === resources.agent || agent.aliases?.includes(resources.agent));
+  if (discovered.length !== 1)
+    throw new Error(`Remote agent '${resources.agent}' was not found unambiguously in ${cwd}.`);
+  const agent = discovered[0];
+  const names = resources.skills ?? agent.skills ?? [];
+  const skills = resolveSkills(names, cwd);
+  if (skills.missing.length)
+    throw new Error(`Remote DM skills not found: ${skills.missing.join(", ")}. Configure them on the saved machine.`);
+  const skillPrompt = buildSkillInjection(skills.resolved);
+  const reads = resources.reads === undefined ? agent.defaultReads ?? false : resources.reads;
+  const readPaths = Array.isArray(reads) ? resolveExistingReadPaths(reads, cwd) : [];
+  const systemPrompt = appendAgentRefinementOverlay(`${agent.systemPrompt}${buildAgentMemoryInjection(agent, cwd)}${skillPrompt ? `
+
+${skillPrompt}` : ""}${readPaths.length ? `
+
+[Read from: ${readPaths.join(", ")}]` : ""}`, { cwd, agentName: agent.name });
+  const denied = new Set(agent.excludeTools ?? []);
+  const tools = (agent.tools === undefined ? remoteDefaultTools : agent.tools).filter((tool) => !denied.has(tool) && (!resources.toolCeiling || resources.toolCeiling.includes(tool)));
+  if (agent.tools === undefined && !tools.length)
+    throw new Error(`Remote agent '${agent.name}' resolved no default active tools within the inherited ceiling.`);
+  return { agent: agent.name, skills: names, tools, systemPrompt, inheritProjectContext: agent.inheritProjectContext, inheritGlobalContext: agent.inheritGlobalContext, inheritSkills: agent.inheritSkills };
+}
+export default function registerHerdrPiBridge(dm) {
+  const runId = validateHerdrPiRunId(process.env[HERDR_PI_RUN_ENV]);
+  const runDir = process.env[HERDR_PI_RUNTIME_DIR_ENV];
+  if (!runDir || !path.isAbsolute(runDir) || fs.lstatSync(runDir).isSymbolicLink())
+    throw new Error("Herdr bridge runtime directory was not authoritatively provisioned.");
+  fs.chmodSync(runDir, 448);
+  const socketPath = path.join(runDir, "bridge.sock");
+  const manifestPath = path.join(runDir, "manifest.json");
+  for (const candidate of [socketPath, manifestPath]) {
+    try {
+      const stat = fs.lstatSync(candidate);
+      if (stat.isSymbolicLink())
+        throw new Error(`Refusing symlink at '${candidate}'.`);
+      fs.rmSync(candidate, { force: true });
+    } catch (error) {
+      if (error.code !== "ENOENT")
+        throw error;
+    }
+  }
+  let client;
+  let context;
+  let nativeSessionId;
+  let finalAssistant;
+  let activeRequestId;
+  let resolvedSystemPrompt;
+  let resolvedContextPolicy;
+  let configured = false;
+  const pending = new Map;
+  const supervisor = new Map;
+  let evidenceCursor = 0;
+  let journalBytes = 0;
+  const journal = [];
+  const send = (frame) => {
+    const record = { protocol: HERDR_PI_PROTOCOL, runId, ...frame, cursor: ++evidenceCursor };
+    const size = Buffer.byteLength(JSON.stringify(record));
+    journal.push(record);
+    journalBytes += size;
+    while (journal.length > 512 || journalBytes > 8 * 1024 * 1024) {
+      const removed = journal.shift();
+      if (removed)
+        journalBytes -= Buffer.byteLength(JSON.stringify(removed));
+    }
+    if (!client || client.destroyed)
+      return;
+    client.write(encodeHerdrPiFrame(record));
+  };
+  const sessionId = (ctx) => ctx.sessionManager?.getSessionId?.();
+  const activeTools = (ctx) => ctx.getActiveTools?.() ?? [];
+  dm.registerTool({
+    name: "contact_supervisor",
+    label: "Contact supervisor",
+    description: "Contact the parent/supervisor session for a blocking decision, structured interview, or progress update.",
+    parameters: Type.Object({ reason: Type.Union([Type.Literal("need_decision"), Type.Literal("interview_request"), Type.Literal("progress_update")]), message: Type.Optional(Type.String({ maxLength: 65536 })), interview: Type.Optional(Type.Unknown()) }, { additionalProperties: false }),
+    execute: async (_toolCallId, input) => {
+      if (input.reason !== "interview_request" && !input.message?.trim())
+        throw new Error("message is required for supervisor decisions and progress updates.");
+      const id = `sup_${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 8)}`;
+      send({ type: "supervisor-request", requestId: id, reason: input.reason, message: input.message?.slice(0, 65536) ?? "", ...input.interview !== undefined ? { interview: input.interview } : {}, expectsReply: input.reason !== "progress_update", nativeSessionId });
+      if (input.reason === "progress_update") {
+        await new Promise((resolve) => supervisor.set(id, { reason: input.reason, resolve }));
+        return { content: [{ type: "text", text: "Supervisor progress update queued." }], details: { delivered: true, requestId: id, reason: input.reason } };
+      }
+      const reason = input.reason;
+      const answer = await new Promise((resolve) => supervisor.set(id, { reason, resolve }));
+      const details = { requestId: id, reason };
+      if (reason === "interview_request")
+        try {
+          details.structuredReply = JSON.parse(answer.replace(/^```(?:json)?\s*|\s*```$/giu, ""));
+        } catch {
+          details.structuredReplyParseError = "Supervisor interview reply was not valid JSON.";
+        }
+      return { content: [{ type: "text", text: `**Reply from supervisor:**
+${answer}` }], details };
+    }
+  });
+  const execute = async (requestId, ctx) => {
+    const request = pending.get(requestId);
+    if (!request)
+      throw new Error(`Unknown or already consumed bridge request '${requestId}'.`);
+    pending.delete(requestId);
+    if (sessionId(ctx) !== nativeSessionId)
+      throw new Error("Native DM session identity changed.");
+    send({ type: "accepted", requestId, operation: request.operation, nativeSessionId });
+    const api = dm;
+    if (request.operation === "prompt") {
+      activeRequestId = requestId;
+      finalAssistant = undefined;
+      api.sendUserMessage(request.text ?? "");
+    } else if (request.operation === "steer")
+      api.sendUserMessage(request.text ?? "", { deliverAs: "steer" });
+    else if (request.operation === "follow-up")
+      api.sendUserMessage(request.text ?? "", { deliverAs: "followUp" });
+    else if (request.operation === "abort")
+      api.abort();
+    else {
+      const entry = request.supervisorId ? supervisor.get(request.supervisorId) : undefined;
+      if (!entry)
+        throw new Error("Unknown supervisor request.");
+      supervisor.delete(request.supervisorId);
+      entry.resolve(request.text ?? "");
+    }
+    send({ type: "control-ack", requestId, operation: request.operation, nativeSessionId });
+  };
+  dm.registerCommand("dm-subagents-bridge", { description: "Internal pane-native request dispatch", handler: (args, ctx) => execute(args.trim(), ctx) });
+  const on = dm.on;
+  on("before_agent_start", (event) => resolvedSystemPrompt && resolvedContextPolicy ? { systemPrompt: `${rewriteSubagentPrompt(typeof event.systemPrompt === "string" ? event.systemPrompt : "", { inheritProjectContext: resolvedContextPolicy.inheritProjectContext, inheritGlobalContext: resolvedContextPolicy.inheritGlobalContext, inheritSkills: resolvedContextPolicy.inheritSkills })}
+
+<active_agent name=${JSON.stringify(resolvedContextPolicy.agent)}/>
+
+${resolvedSystemPrompt}` } : undefined);
+  on("session_start", (_event, ctx) => {
+    context = ctx;
+    nativeSessionId = sessionId(ctx);
+    if (!nativeSessionId)
+      throw new Error("Pane-native DM bridge requires a persisted native session identity.");
+    fs.writeFileSync(manifestPath, JSON.stringify({ protocol: HERDR_PI_PROTOCOL, packageVersion: packageJson.version, runId, socketPath, nativeSessionId, pid: process.pid }), { mode: 384, flag: "wx" });
+    send({ type: "ready", packageVersion: packageJson.version, nativeSessionId, sessionFile: ctx.sessionManager?.getSessionFile?.(), cwd: process.cwd(), tools: activeTools(ctx), model: ctx.model?.provider && ctx.model.id ? `${ctx.model.provider}/${ctx.model.id}` : undefined, configured, activeRequestId, evidenceCursor, evidenceFloor: journal[0]?.cursor ?? evidenceCursor + 1, initialGit: gitEvidence(process.cwd()) });
+  });
+  on("message_end", (event) => {
+    const message = event.message;
+    if (message?.role === "assistant")
+      finalAssistant = message;
+    send({ type: "event", requestId: activeRequestId, event: { ...event, message }, nativeSessionId });
+  });
+  on("agent_settled", (_event, ctx) => {
+    const requestId = activeRequestId;
+    send({ type: "settled", requestId, nativeSessionId, idle: ctx.isIdle(), pending: ctx.hasPendingMessages(), finalAssistant, finalGit: gitEvidence(process.cwd()) });
+    if (ctx.isIdle() && !ctx.hasPendingMessages())
+      activeRequestId = undefined;
+  });
+  on("session_shutdown", () => {
+    server.close();
+    client?.destroy();
+    try {
+      fs.rmSync(runDir, { recursive: true, force: true });
+    } catch {}
+  });
+  const server = net.createServer((socket) => {
+    if (client && !client.destroyed) {
+      socket.destroy();
+      return;
+    }
+    client = socket;
+    const decoder = new HerdrPiFrameDecoder;
+    let total = 0;
+    for (const record of journal)
+      socket.write(encodeHerdrPiFrame(record));
+    socket.on("data", (chunk) => {
+      total += chunk.byteLength;
+      if (total > HERDR_PI_MAX_FRAME_BYTES * 32) {
+        socket.destroy(new Error("Bridge byte budget exceeded."));
+        return;
+      }
+      try {
+        for (const frame of decoder.push(chunk)) {
+          if (frame.runId !== runId)
+            throw new Error("Bridge run identity mismatch.");
+          if (frame.type === "supervisor-delivered" && typeof frame.requestId === "string") {
+            const entry = supervisor.get(frame.requestId);
+            if (!entry || entry.reason !== "progress_update")
+              throw new Error("Unknown supervisor delivery acknowledgement.");
+            supervisor.delete(frame.requestId);
+            entry.resolve("delivered");
+            continue;
+          }
+          if (frame.type === "configure") {
+            if (configured || typeof frame.requestId !== "string" || !frame.resources || typeof frame.resources !== "object")
+              throw new Error("Invalid or duplicate bridge configuration.");
+            const resources = frame.resources;
+            const invalidSkills = resources.skills !== undefined && (!Array.isArray(resources.skills) || resources.skills.some((name) => typeof name !== "string" || !/^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/u.test(name)));
+            const invalidReads = resources.reads !== undefined && resources.reads !== false && (!Array.isArray(resources.reads) || resources.reads.some((name) => typeof name !== "string"));
+            if (typeof resources.agent !== "string" || !/^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/u.test(resources.agent) || invalidSkills || invalidReads)
+              throw new Error("Remote logical resource names are invalid.");
+            const resolved = resolveRemoteHerdrResources(process.cwd(), { agent: resources.agent, ...resources.skills ? { skills: resources.skills } : {}, ...resources.toolCeiling ? { toolCeiling: resources.toolCeiling } : {}, ...resources.reads !== undefined ? { reads: resources.reads } : {} }, context ? activeTools(context) : []);
+            resolvedSystemPrompt = resolved.systemPrompt;
+            resolvedContextPolicy = resolved;
+            dm.setActiveTools?.(resolved.tools);
+            const acknowledged = context ? activeTools(context) : [];
+            if (acknowledged.some((tool) => !resolved.tools.includes(tool)) || resolved.tools.some((tool) => !acknowledged.includes(tool)))
+              throw new Error("Remote DM did not apply the resolved active-tool set exactly.");
+            configured = true;
+            send({ type: "configured", requestId: frame.requestId, nativeSessionId, agent: resolved.agent, skills: resolved.skills, model: context?.model?.provider && context.model.id ? `${context.model.provider}/${context.model.id}` : undefined, tools: acknowledged });
+            continue;
+          }
+          if (frame.type !== "prepare" || typeof frame.requestId !== "string" || pending.has(frame.requestId) || !configured)
+            throw new Error("Invalid, duplicate, or unconfigured bridge request.");
+          const operation = frame.operation;
+          if (!["prompt", "steer", "follow-up", "abort", "supervisor-reply"].includes(operation))
+            throw new Error("Unsupported bridge operation.");
+          const text = frame.text;
+          if (text !== undefined && (typeof text !== "string" || Buffer.byteLength(text) > 256 * 1024))
+            throw new Error("Bridge request text is invalid or too large.");
+          pending.set(frame.requestId, { operation, ...text !== undefined ? { text } : {}, ...typeof frame.supervisorId === "string" ? { supervisorId: frame.supervisorId } : {} });
+          send({ type: "prepared", requestId: frame.requestId, nativeSessionId });
+        }
+      } catch (error) {
+        socket.destroy(error);
+      }
+    });
+    socket.on("close", () => {
+      if (client === socket)
+        client = undefined;
+    });
+    if (context && nativeSessionId)
+      send({ type: "ready", packageVersion: packageJson.version, nativeSessionId, sessionFile: context.sessionManager?.getSessionFile?.(), cwd: process.cwd(), tools: activeTools(context), model: context.model?.provider && context.model.id ? `${context.model.provider}/${context.model.id}` : undefined, configured, activeRequestId, evidenceCursor, evidenceFloor: journal[0]?.cursor ?? evidenceCursor + 1, initialGit: gitEvidence(process.cwd()) });
+  });
+  server.listen(socketPath, () => {
+    fs.chmodSync(socketPath, 384);
+  });
+}