@duckmind/dm-linux-x64 0.65.5 → 0.65.7

package/extensions/dm-subagents/src/inspectors/herdr/actions.js

@@ -1,218 +1,133 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
-import { fileURLToPath } from "node:url";
-import { readMissionBinding } from "../../missions/lifecycle.js";
-import { listMissions, missionRecordPath, resolveMissionStoreLocation } from "../../missions/store.js";
-import { resolveAuthorityDecision } from "../../policy/authority.js";
 import { writeAtomicJson } from "../../shared/atomic-json.js";
-import { DIRS } from "../../shared/types.js";
-import { readStatus } from "../../shared/utils.js";
-import { resolveSubagentRunId } from "../../runs/background/run-id-resolver.js";
-import { resolveNodeExecutable } from "../../shared/node-executable.js";
-import { createHerdrClient, detectHerdr } from "./client.js";
-import { encodeSessionRoots } from "./session-roots-codec.js";
-import { formatShellCommand } from "./shell-command.js";
-export const HERDR_INSPECTOR_ACTIONS = ["inspector.open", "inspector.status", "inspector.close"];
-function result(text, isError = false) {
-  return { content: [{ type: "text", text }], ...isError ? { isError: true } : {}, details: { mode: "management", results: [] } };
-}
-function formatHerdrError(input) {
-  return `Herdr inspector error (${input.code}): ${input.message}`;
-}
-function bindingPath(asyncDir, index) {
+import { detectHerdr } from "./client.js";
+export function bindingPath(asyncDir, index) {
   return path.join(asyncDir, "inspectors", `herdr${index === undefined ? "" : `-${index}`}.json`);
 }
-function parseBinding(value) {
+function parse(value) {
   if (!value || typeof value !== "object" || Array.isArray(value))
     return;
-  const input = value;
-  if (input.schemaVersion !== 1 || input.kind !== "herdr-inspector")
-    return;
-  if (typeof input.runId !== "string" || typeof input.asyncDir !== "string" || typeof input.paneId !== "string" || typeof input.openedAt !== "string" || typeof input.command !== "string")
+  const binding = value;
+  if (binding.schemaVersion !== 1 || binding.kind !== "herdr-inspector" || binding.childIndex !== undefined && (!Number.isInteger(binding.childIndex) || binding.childIndex < 0) || typeof binding.runId !== "string" || typeof binding.asyncDir !== "string" || typeof binding.paneId !== "string" || typeof binding.openedAt !== "string" || typeof binding.command !== "string")
     return;
-  if (input.childIndex !== undefined && (!Number.isInteger(input.childIndex) || input.childIndex < 0))
-    return;
-  return input;
+  return binding;
 }
 export function readHerdrInspectorBinding(asyncDir, index) {
   try {
-    return parseBinding(JSON.parse(fs.readFileSync(bindingPath(asyncDir, index), "utf-8")));
+    return parse(JSON.parse(fs.readFileSync(bindingPath(asyncDir, index), "utf8")));
   } catch {
     return;
   }
 }
-function extractPaneId(value) {
-  if (!value || typeof value !== "object" || Array.isArray(value))
+export function readHerdrInspectorBindingForTarget(target) {
+  const binding = readHerdrInspectorBinding(target.asyncDir, target.index);
+  if (!binding || binding.runId !== target.runId || binding.childIndex !== target.index)
     return;
-  const record = value;
-  const pane = record.pane && typeof record.pane === "object" && !Array.isArray(record.pane) ? record.pane : record;
-  for (const key of ["pane_id", "paneId", "id"])
-    if (typeof pane[key] === "string")
-      return pane[key];
-  return;
-}
-function inspectorCommand(input) {
-  const args = [input.runnerPath, "--async-dir", input.asyncDir, "--run-id", input.runId, "--allow-steer", String(input.allowSteer), "--allow-stop", String(input.allowStop), "--session-roots", encodeSessionRoots(input.sessionRoots)];
-  if (input.index !== undefined)
-    args.push("--index", String(input.index));
-  if (input.missionPath)
-    args.push("--mission-path", input.missionPath);
-  return formatShellCommand(resolveNodeExecutable(), args);
-}
-function missionForRun(asyncDir, cwd, config, runId) {
   try {
-    const binding = readMissionBinding(asyncDir);
-    if (binding)
-      return { id: binding.missionId, path: missionRecordPath(binding.location, binding.missionId) };
-    const location = resolveMissionStoreLocation({ projectRoot: cwd, ...config ? { config } : {} });
-    const mission = listMissions(location).records.find((record) => record.runs.some((run) => run.runId === runId));
-    return mission ? { id: mission.id, path: missionRecordPath(location, mission.id) } : undefined;
+    if (fs.realpathSync(binding.asyncDir) !== fs.realpathSync(target.asyncDir))
+      return;
   } catch {
     return;
   }
+  return binding;
 }
-function pathWithin(base, candidate) {
-  const resolvedBase = path.resolve(base);
-  const resolvedCandidate = path.resolve(candidate);
-  return resolvedCandidate === resolvedBase || resolvedCandidate.startsWith(`${resolvedBase}${path.sep}`);
-}
-function herdrSessionRoots(target, deps) {
-  const roots = deps.sessionRoots ?? deps.state?.trustedSessionRoots ?? [];
-  const job = deps.state?.asyncJobs.get(target.runId) ?? deps.state?.fleetJobs?.get(target.runId);
-  return [...new Set([...roots, ...job?.sessionRoot ? [job.sessionRoot] : []])];
+function result(text, isError = false) {
+  return {
+    content: [{ type: "text", text }],
+    ...isError ? { isError: true } : {},
+    details: { mode: "management", results: [] }
+  };
 }
-function isTrustedAsyncDir(asyncDir, deps) {
-  try {
-    if (fs.lstatSync(asyncDir).isSymbolicLink() || !fs.statSync(asyncDir).isDirectory())
-      return false;
-    const realDir = fs.realpathSync(asyncDir);
-    const registered = [...deps.state?.asyncJobs.values() ?? []].some((job) => {
-      try {
-        return fs.realpathSync(job.asyncDir) === realDir;
-      } catch {
-        return false;
-      }
-    });
-    if (registered)
-      return true;
-    const root = deps.asyncDirRoot ?? DIRS.async;
-    if (!fs.existsSync(root) || !pathWithin(root, asyncDir))
-      return false;
-    return pathWithin(fs.realpathSync(root), realDir);
-  } catch {
-    return false;
-  }
+function errorText(input) {
+  return `Herdr inspector error (${input.code}): ${input.message}`;
 }
-function resolveAsyncTarget(params, deps) {
-  const requestedId = params.id ?? params.runId;
-  if (params.dir) {
-    const asyncDir = path.resolve(params.dir);
-    if (!isTrustedAsyncDir(asyncDir, deps))
-      return { error: `Async run directory '${asyncDir}' is outside trusted run roots.` };
-    const status = readStatus(asyncDir);
-    if (!status)
-      return { error: `No async run status found in '${asyncDir}'.` };
-    if (requestedId && requestedId !== status.runId && !status.runId.startsWith(requestedId))
-      return { error: `Run '${requestedId}' does not match status run '${status.runId}'.` };
-    return { runId: status.runId, asyncDir };
-  }
-  if (!requestedId)
-    return { error: "Herdr inspector actions require id or dir." };
-  try {
-    const resolved = resolveSubagentRunId(requestedId, { state: deps.state, asyncDirRoot: deps.asyncDirRoot ?? DIRS.async, resultsDir: deps.resultsDir ?? DIRS.results });
-    if (!resolved)
-      return { error: `No subagent run found for '${requestedId}'.` };
-    if (resolved.kind !== "async" || !resolved.location.asyncDir)
-      return { error: `Run '${resolved.id}' is not an inspectable async run with lifecycle artifacts.` };
-    return { runId: resolved.id, asyncDir: resolved.location.asyncDir };
-  } catch (cause) {
-    return { error: cause instanceof Error ? cause.message : String(cause) };
+function paneId(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value))
+    return;
+  const record = value;
+  const pane = record.pane && typeof record.pane === "object" ? record.pane : record;
+  for (const key of ["pane_id", "paneId", "id"]) {
+    if (typeof pane[key] === "string")
+      return pane[key];
   }
+  return;
 }
-async function paneExists(client, paneId, signal) {
-  return client.run(["pane", "get", paneId], { timeoutMs: 5000, signal });
+async function pane(client, id, signal) {
+  return client.run(["pane", "get", id], { timeoutMs: 5000, signal });
 }
-export async function handleHerdrInspectorAction(action, params, deps) {
-  const target = resolveAsyncTarget(params, deps);
-  if ("error" in target)
-    return result(target.error, true);
-  const status = readStatus(target.asyncDir);
-  if (!status)
-    return result(`No lifecycle status exists for async run '${target.runId}'.`, true);
-  if (params.index !== undefined && (params.index < 0 || params.index >= (status.steps?.length ?? 0))) {
-    return result(`Async run '${target.runId}' has ${status.steps?.length ?? 0} children. Index ${params.index} is out of range.`, true);
-  }
-  const existing = readHerdrInspectorBinding(target.asyncDir, params.index);
-  const client = deps.client ?? createHerdrClient();
-  if (action === "inspector.status") {
-    if (!existing)
-      return result(`No Herdr inspector binding exists for async run ${target.runId}${params.index === undefined ? "" : ` child ${params.index}`}.`);
-    const live = await paneExists(client, existing.paneId, deps.signal);
-    if (live.ok === false)
-      return result(`${formatHerdrError(live.error)}
-Binding: ${bindingPath(target.asyncDir, params.index)}
-Run state remains authoritative: ${status.state}.`, true);
-    return result(`Herdr inspector ${existing.paneId} is open for async run ${target.runId}.
-Run state: ${status.state}
-Binding: ${bindingPath(target.asyncDir, params.index)}`);
-  }
-  if (action === "inspector.close") {
-    if (!existing)
-      return result(`No Herdr inspector binding exists for async run ${target.runId}.`);
-    const closed = await client.run(["pane", "close", existing.paneId], { timeoutMs: 1e4, signal: deps.signal });
-    if (closed.ok === false && closed.error.code !== "NOT_FOUND" && closed.error.code !== "PANE_GONE")
-      return result(formatHerdrError(closed.error), true);
-    fs.rmSync(bindingPath(target.asyncDir, params.index), { force: true });
-    return result(`Closed Herdr inspector pane ${existing.paneId} for async run ${target.runId}. The subagent run was not stopped.`);
-  }
-  const detected = await detectHerdr(client, deps.signal);
-  if (detected.ok === false)
-    return result(formatHerdrError(detected.error), true);
+export async function openHerdrInspector(context, launch, params, client) {
+  const detected = await detectHerdr(client, context.signal);
+  if (!detected.ok)
+    return result(errorText(detected.error), true);
+  const existing = readHerdrInspectorBindingForTarget(context.target);
   if (existing) {
-    const live = await paneExists(client, existing.paneId, deps.signal);
-    if (live.ok)
-      return result(`Herdr inspector pane ${existing.paneId} is already open for async run ${target.runId}.${params.focus ? " Herdr cannot refocus an arbitrary raw pane id; select it in the Herdr UI." : ""}`);
+    const current = await pane(client, existing.paneId, context.signal);
+    if (current.ok && paneId(current.data) === existing.paneId) {
+      return result(`Herdr inspector pane ${existing.paneId} is already open for async run ${context.target.runId}.${params.focus ? " Herdr cannot refocus an arbitrary raw pane id; select it in the Herdr UI." : ""}`);
+    }
   }
-  const splitArgs = ["pane", "split", "--current", "--direction", "right", "--cwd", status.cwd ?? deps.cwd];
-  splitArgs.push(params.focus === true ? "--focus" : "--no-focus");
-  const split = await client.run(splitArgs, { timeoutMs: 15000, signal: deps.signal });
-  if (split.ok === false)
-    return result(formatHerdrError(split.error), true);
-  const paneId = extractPaneId(split.data);
-  if (!paneId)
+  const split = await client.run([
+    "pane",
+    "split",
+    "--current",
+    "--direction",
+    "right",
+    "--cwd",
+    context.target.status.cwd ?? context.cwd,
+    params.focus === true ? "--focus" : "--no-focus"
+  ], { timeoutMs: 15000, signal: context.signal });
+  if (!split.ok)
+    return result(errorText(split.error), true);
+  const id = paneId(split.data);
+  if (!id)
     return result("Herdr inspector error (PANE_GONE): pane split returned no pane id.", true);
-  const mission = missionForRun(target.asyncDir, deps.cwd, deps.missions, target.runId);
-  const runnerPath = deps.runnerPath ?? fileURLToPath(new URL("../../../inspector-runner.mjs", import.meta.url));
-  const command = inspectorCommand({
-    runnerPath,
-    asyncDir: target.asyncDir,
-    runId: target.runId,
-    index: params.index,
-    missionPath: mission?.path,
-    allowSteer: resolveAuthorityDecision({ action: "steerRun", policy: deps.authorityPolicy }) === "auto",
-    allowStop: resolveAuthorityDecision({ action: "stopRun", policy: deps.authorityPolicy }) === "auto",
-    sessionRoots: herdrSessionRoots(target, deps)
-  });
-  const started = await client.run(["pane", "run", paneId, command], { timeoutMs: 15000, signal: deps.signal });
-  if (started.ok === false) {
-    await client.run(["pane", "close", paneId], { timeoutMs: 5000 });
-    return result(formatHerdrError(started.error), true);
+  const started = await client.run(["pane", "run", id, launch.displayCommand], { timeoutMs: 15000, signal: context.signal });
+  if (!started.ok) {
+    await client.run(["pane", "close", id], { timeoutMs: 5000 });
+    return result(errorText(started.error), true);
   }
-  const now = (deps.now?.() ?? new Date).toISOString();
+  const now = (context.now?.() ?? new Date).toISOString();
   const binding = {
     schemaVersion: 1,
     kind: "herdr-inspector",
-    runId: target.runId,
-    asyncDir: target.asyncDir,
-    ...params.index !== undefined ? { childIndex: params.index } : {},
-    ...mission ? { missionId: mission.id, missionPath: mission.path } : {},
-    paneId,
+    runId: context.target.runId,
+    asyncDir: context.target.asyncDir,
+    ...context.target.index === undefined ? {} : { childIndex: context.target.index },
+    ...launch.mission ? { missionId: launch.mission.id, missionPath: launch.mission.path } : {},
+    paneId: id,
     openedAt: now,
     ...params.focus === true ? { lastFocusedAt: now } : {},
     herdrVersion: detected.data.versionText,
-    command
+    command: launch.displayCommand
   };
-  writeAtomicJson(bindingPath(target.asyncDir, params.index), binding);
-  return result(`Opened read-only Herdr inspector pane ${paneId} for async run ${target.runId}. Closing the pane does not stop the run.
+  writeAtomicJson(bindingPath(context.target.asyncDir, context.target.index), binding);
+  return result(`Opened read-only Herdr inspector pane ${id} for async run ${context.target.runId}. Closing the pane does not stop the run.
 Controls inside the pane: steer <message>, stop, status.`);
 }
+export async function statusHerdrInspector(context, client) {
+  const binding = readHerdrInspectorBindingForTarget(context.target);
+  if (!binding) {
+    return result(`No Herdr inspector binding exists for async run ${context.target.runId}${context.target.index === undefined ? "" : ` child ${context.target.index}`}.`);
+  }
+  const live = await pane(client, binding.paneId, context.signal);
+  if (!live.ok) {
+    return result(`${errorText(live.error)}
+Binding: ${bindingPath(context.target.asyncDir, context.target.index)}
+Run state remains authoritative: ${context.target.status.state}.`, true);
+  }
+  return result(`Herdr inspector ${binding.paneId} is open for async run ${context.target.runId}.
+Run state: ${context.target.status.state}
+Binding: ${bindingPath(context.target.asyncDir, context.target.index)}`);
+}
+export async function closeHerdrInspector(context, client) {
+  const binding = readHerdrInspectorBindingForTarget(context.target);
+  if (!binding)
+    return result(`No Herdr inspector binding exists for async run ${context.target.runId}.`);
+  const closed = await client.run(["pane", "close", binding.paneId], { timeoutMs: 1e4, signal: context.signal });
+  if (!closed.ok && closed.error.code !== "NOT_FOUND" && closed.error.code !== "PANE_GONE") {
+    return result(errorText(closed.error), true);
+  }
+  fs.rmSync(bindingPath(context.target.asyncDir, context.target.index), { force: true });
+  return result(`Closed Herdr inspector pane ${binding.paneId} for async run ${context.target.runId}. The subagent run was not stopped.`);
+}

package/extensions/dm-subagents/src/inspectors/herdr/plugin.js

@@ -0,0 +1,13 @@
+import { createHerdrClient } from "./client.js";
+import { closeHerdrInspector, openHerdrInspector, readHerdrInspectorBindingForTarget, statusHerdrInspector } from "./actions.js";
+export function createHerdrInspectorPlugin(deps = {}) {
+  const client = deps.client ?? createHerdrClient();
+  return {
+    name: "herdr",
+    available: async (context) => context.env.HERDR_ENV === "1" && Boolean(context.env.HERDR_PANE_ID?.trim()),
+    owns: (context) => readHerdrInspectorBindingForTarget(context.target) !== undefined,
+    open: (context, launch, params) => openHerdrInspector(context, launch, params, client),
+    status: (context) => statusHerdrInspector(context, client),
+    close: (context) => closeHerdrInspector(context, client)
+  };
+}

package/extensions/dm-subagents/src/inspectors/herdr/project-panes.js

@@ -5,7 +5,7 @@ import { getProjectSubagentsDir } from "../../shared/artifacts.js";
 import { writeAtomicJson } from "../../shared/atomic-json.js";
 import { createHerdrClient, detectHerdr } from "./client.js";
 import { focusHerdrPane, herdrPaneFocusTarget, herdrPaneRecord } from "./focus.js";
-import { formatShellCommand } from "./shell-command.js";
+import { formatShellCommand } from "../shell-command.js";
 export const HERDR_PROJECT_PANE_ACTIONS = ["project.open", "project.status", "project.close"];
 export const PROJECT_PANES_API_VERSION = 1;
 export const PROJECT_PANE_TRUST_STATUS = "human-verification-required";

package/extensions/dm-subagents/src/inspectors/{herdr/inspector-runner.js → inspector-runner.js}

@@ -2,11 +2,11 @@ import * as fs from "node:fs";
 import * as path from "node:path";
 import * as readline from "node:readline";
 import { fileURLToPath } from "node:url";
-import { parseMissionRecord } from "../../missions/store.js";
-import { requestAsyncSteer, requestAsyncStop } from "../../runs/background/control-channel.js";
-import { formatAsyncRunTranscript } from "../../runs/background/fleet-view.js";
-import { steeringReceipt } from "../../runs/background/steering.js";
-import { readStatus } from "../../shared/utils.js";
+import { parseMissionRecord } from "../missions/store.js";
+import { requestAsyncSteer, requestAsyncStop } from "../runs/background/control-channel.js";
+import { formatAsyncRunTranscript } from "../runs/background/fleet-view.js";
+import { steeringReceipt } from "../runs/background/steering.js";
+import { readStatus } from "../shared/utils.js";
 import { decodeSessionRoots } from "./session-roots-codec.js";
 function readMission(filePath) {
   if (!filePath)
@@ -21,7 +21,7 @@ export function formatInspectorDashboard(input) {
   const { status, asyncDir, mission } = input;
   const lines = [
     `dm-subagents inspector for ${status.runId}`,
-    "This pane mirrors lifecycle artifacts; closing it does not stop the run.",
+    "This inspector mirrors lifecycle artifacts; closing it does not stop the run.",
     ""
   ];
   if (mission) {
@@ -32,8 +32,9 @@ export function formatInspectorDashboard(input) {
     lines.push("");
   }
   lines.push(formatAsyncRunTranscript(status, asyncDir, { index: input.index, lines: 60, sessionRoots: input.sessionRoots }));
-  const controls = [input.allowSteer === false ? undefined : "steer <message>", input.allowStop === false ? undefined : "stop", "status"].filter(Boolean);
-  lines.push("", `Controls: ${controls.join(" | ")}`, "Supervisor replies remain in the parent DM session (subagent_supervisor/intercom).");
+  const acceptsPlainGuidance = input.index !== undefined || status.mode === "single";
+  const controls = [input.allowSteer === false || !acceptsPlainGuidance ? undefined : "type guidance", input.allowSteer === false ? undefined : "steer <message>", input.allowStop === false ? undefined : "stop", "status"].filter(Boolean);
+  lines.push("", `Controls: ${controls.join(" | ")}`, "Supervisor replies remain in the parent DM session (subagent_supervisor/intercom); this inspector is read-only.");
   return lines.join(`
 `);
 }
@@ -74,6 +75,22 @@ function parseArgs(argv) {
 function isTerminal(status) {
   return status.state !== "queued" && status.state !== "running";
 }
+function queueInspectorSteer(options, status, message) {
+  if (options.allowSteer === false)
+    throw new Error("Authority policy does not allow steer from this inspector.");
+  if (isTerminal(status))
+    throw new Error(`Run '${options.runId}' is ${status.state} and cannot be steered.`);
+  const runningIndexes = (status.steps ?? []).map((step, index) => step.status === "running" ? index : undefined).filter((index) => index !== undefined);
+  const targetIndex = options.index ?? (status.mode === "single" ? 0 : undefined);
+  if (targetIndex === undefined && runningIndexes.length === 0)
+    throw new Error("No running child is available to steer. Open a child-specific inspector for a pending child.");
+  requestAsyncSteer(options.asyncDir, {
+    message,
+    ...targetIndex !== undefined ? { targetIndex } : { targetIndexes: runningIndexes },
+    source: "inspector-runner"
+  });
+  return steeringReceipt(message, `Steering queued for run ${options.runId}.`);
+}
 export function submitInspectorControl(options, line) {
   const command = line.trim();
   if (!command || command === "status")
@@ -86,31 +103,20 @@ export function submitInspectorControl(options, line) {
       throw new Error("Authority policy does not allow stop from this inspector.");
     if (isTerminal(status))
       throw new Error(`Run '${options.runId}' is ${status.state} and cannot be stopped.`);
-    requestAsyncStop(options.asyncDir, { source: "herdr-inspector" });
+    requestAsyncStop(options.asyncDir, { source: "inspector-runner" });
     return `Stop requested for run ${options.runId}.`;
   }
   if (command.startsWith("steer ")) {
-    if (options.allowSteer === false)
-      throw new Error("Authority policy does not allow steer from this inspector.");
     const message = command.slice("steer ".length).trim();
     if (!message)
       throw new Error("steer requires a message.");
-    if (isTerminal(status))
-      throw new Error(`Run '${options.runId}' is ${status.state} and cannot be steered.`);
-    const runningIndexes = (status.steps ?? []).map((step, index) => step.status === "running" ? index : undefined).filter((index) => index !== undefined);
-    const targetIndex = options.index ?? (status.mode === "single" ? 0 : undefined);
-    if (targetIndex === undefined && runningIndexes.length === 0)
-      throw new Error("No running child is available to steer. Open a child-specific inspector for a pending child.");
-    requestAsyncSteer(options.asyncDir, {
-      message,
-      ...targetIndex !== undefined ? { targetIndex } : { targetIndexes: runningIndexes },
-      source: "herdr-inspector"
-    });
-    return steeringReceipt(message, `Steering queued for run ${options.runId}.`);
+    return queueInspectorSteer(options, status, message);
   }
   if (command.startsWith("reply "))
     throw new Error("Supervisor replies are owned by the parent DM session; use subagent_supervisor/intercom there.");
-  throw new Error("Unknown control. Use steer <message>, stop, or status.");
+  if (options.index === undefined && status.mode !== "single")
+    throw new Error("Plain guidance requires a child-specific inspector. Use steer <message> to target all running children from the aggregate inspector.");
+  return queueInspectorSteer(options, status, command);
 }
 export function runInspector(argv = process.argv.slice(2)) {
   const options = parseArgs(argv);
@@ -153,7 +159,7 @@ if (process.argv[1] && path.resolve(process.argv[1]) === path.resolve(fileURLToP
   try {
     runInspector();
   } catch (cause) {
-    process.stderr.write(`Herdr inspector failed: ${cause instanceof Error ? cause.message : String(cause)}
+    process.stderr.write(`Inspector failed: ${cause instanceof Error ? cause.message : String(cause)}
 `);
     process.exitCode = 1;
   }

package/extensions/dm-subagents/src/inspectors/plugins.js

@@ -0,0 +1,5 @@
+import { createHerdrInspectorPlugin } from "./herdr/plugin.js";
+import { createGhosttyInspectorPlugin } from "./ghostty/plugin.js";
+export function createBuiltinInspectorPlugins() {
+  return [createHerdrInspectorPlugin(), createGhosttyInspectorPlugin()];
+}

package/extensions/dm-subagents/src/inspectors/{herdr/session-roots-codec.js → session-roots-codec.js}

@@ -12,10 +12,5 @@ export function decodeSessionRoots(raw) {
     if (decoded)
       return decoded;
   } catch {}
-  try {
-    const parsed = parseStringArray(JSON.parse(raw));
-    if (parsed)
-      return parsed;
-  } catch {}
-  throw new Error("--session-roots must be a base64-encoded or raw JSON array of strings.");
+  throw new Error("--session-roots must be a base64-encoded JSON array of strings.");
 }

package/extensions/dm-subagents/src/inspectors/types.js

@@ -0,0 +1 @@
+export const INSPECTOR_ACTIONS = ["inspector.open", "inspector.command", "inspector.status", "inspector.close"];

package/extensions/dm-subagents/src/integrations/dm-web-session-liveness.js

@@ -0,0 +1,50 @@
+import { hasLiveNestedDescendants, projectNestedEvents } from "../runs/shared/nested-events.js";
+export const PI_WEB_SESSION_LIVENESS_REGISTRY_KEY = "@agegr/dm-web/session-liveness/v1";
+const PI_WEB_SESSION_LIVENESS_PROTOCOL_VERSION = 1;
+function resolveRegistry() {
+  const value = globalThis[Symbol.for(PI_WEB_SESSION_LIVENESS_REGISTRY_KEY)];
+  if (!value || typeof value !== "object")
+    return null;
+  const registry = value;
+  if (registry.version !== PI_WEB_SESSION_LIVENESS_PROTOCOL_VERSION || typeof registry.register !== "function")
+    return null;
+  return registry;
+}
+export function retainLiveForegroundNestedRoute(state, route) {
+  const nested = projectNestedEvents(route);
+  if (!hasLiveNestedDescendants(nested.children))
+    return false;
+  state.retainedForegroundNestedRoutes ??= new Map;
+  state.retainedForegroundNestedRoutes.set(route.rootRunId, route);
+  return true;
+}
+export function hasLiveSubagentWork(state) {
+  for (const job of state.asyncJobs.values()) {
+    if (job.status === "queued" || job.status === "running" || hasLiveNestedDescendants(job.nestedChildren))
+      return true;
+  }
+  for (const control of state.foregroundControls.values()) {
+    if ((control.schedulingOwners ?? 0) > 0 || (control.activeChildren?.size ?? 0) > 0 || hasLiveNestedDescendants(control.nestedChildren))
+      return true;
+  }
+  return (state.retainedForegroundNestedRoutes?.size ?? 0) > 0;
+}
+export function registerPiWebSessionLiveness(registration) {
+  const registry = resolveRegistry();
+  if (!registry)
+    return { registered: false, release: () => {} };
+  try {
+    const release = registry.register({
+      name: "dm-subagents",
+      sessionId: registration.sessionId,
+      ...registration.sessionFile ? { sessionFile: registration.sessionFile } : {},
+      isActive: registration.isActive
+    });
+    if (typeof release === "function")
+      return { registered: true, release };
+    console.error("Failed to register dm-web session liveness: host registry returned no release function.");
+  } catch (error) {
+    console.error("Failed to register dm-web session liveness:", error);
+  }
+  return { registered: false, release: () => {} };
+}

package/extensions/dm-subagents/src/intercom/intercom-bridge.js

@@ -1,6 +1,7 @@
 import * as fs from "node:fs";
 import * as os from "node:os";
 import * as path from "node:path";
+import { agentDefinitionDigest } from "../shared/launch-contract.js";
 import { getAgentDir } from "../shared/utils.js";
 export const NATIVE_INTERCOM_EXTENSION_DIR = "native:dm-subagents-supervisor-channel";
 function defaultAgentDir() {
@@ -12,9 +13,10 @@ function defaultSubagentConfigDir(agentDir = defaultAgentDir()) {
 const DEFAULT_INTERCOM_TARGET_PREFIX = "subagent-chat";
 export const PI_INTERCOM_SESSION_ID_ENV = "PI_INTERCOM_SESSION_ID";
 export const INTERCOM_BRIDGE_MARKER = "Intercom orchestration channel:";
+const ORCHESTRATOR_TARGET_PLACEHOLDER = "{orchestratorTarget}";
 const DEFAULT_INTERCOM_BRIDGE_TEMPLATE = `The inherited thread is reference-only. Do not continue that conversation or send questions, status updates, or completion handoffs to the supervisor in normal assistant text.
 
-Use contact_supervisor first. It resolves the supervisor session "{orchestratorTarget}" and run metadata automatically.
+Use contact_supervisor first. It resolves the supervisor session and run metadata automatically.
 - Need a decision, blocked, approval, or product/API/scope ambiguity: contact_supervisor({ reason: "need_decision", message: "<question>" })
 - Need structured supervisor input rather than a freeform reply: contact_supervisor({ reason: "interview_request", message: "<what input is needed>", interview: { title: "...", questions: [] } })
 - After contact_supervisor with reason "need_decision" or "interview_request", stay alive and continue only after the reply arrives. Do not finish your final response with a choose-one question.
@@ -22,6 +24,29 @@ Use contact_supervisor first. It resolves the supervisor session "{orchestratorT
 - Meaningful progress or unexpected discoveries that change the plan: contact_supervisor({ reason: "progress_update", message: "UPDATE: <summary>" })
 
 Do not use contact_supervisor for routine completion handoffs. If no coordination is needed, return a focused task result.`;
+export function validateIntercomBridgeConfig({ value, label }) {
+  if (!value || typeof value !== "object" || Array.isArray(value))
+    return { ok: false, error: `${label} must be an object.` };
+  const bridge = value;
+  for (const field of Object.keys(bridge)) {
+    if (field !== "mode" && field !== "instructionFile" && field !== "resultDelivery")
+      return { ok: false, error: `${label}.${field} is not supported.` };
+  }
+  if (bridge.mode !== undefined && bridge.mode !== "off" && bridge.mode !== "fork-only" && bridge.mode !== "always")
+    return { ok: false, error: `${label}.mode is invalid.` };
+  if (bridge.instructionFile !== undefined && typeof bridge.instructionFile !== "string")
+    return { ok: false, error: `${label}.instructionFile must be a string.` };
+  if (bridge.resultDelivery !== undefined && typeof bridge.resultDelivery !== "boolean")
+    return { ok: false, error: `${label}.resultDelivery must be a boolean.` };
+  return {
+    ok: true,
+    value: {
+      ...bridge.mode !== undefined ? { mode: bridge.mode } : {},
+      ...bridge.instructionFile !== undefined ? { instructionFile: bridge.instructionFile } : {},
+      ...bridge.resultDelivery !== undefined ? { resultDelivery: bridge.resultDelivery } : {}
+    }
+  };
+}
 export function resolveIntercomSessionTarget(sessionName, sessionId, intercomSessionId = process.env[PI_INTERCOM_SESSION_ID_ENV]) {
   const trimmedName = sessionName?.trim();
   if (trimmedName)
@@ -68,7 +93,7 @@ function resolveInstructionTemplate(instructionFile, settingsDir) {
   }
 }
 function buildIntercomBridgeInstruction(orchestratorTarget, template) {
-  const instruction = template.replaceAll("{orchestratorTarget}", orchestratorTarget).trim();
+  const instruction = template.replaceAll(ORCHESTRATOR_TARGET_PLACEHOLDER, orchestratorTarget).trim();
   if (instruction.startsWith(INTERCOM_BRIDGE_MARKER))
     return instruction;
   return `${INTERCOM_BRIDGE_MARKER}
@@ -105,18 +130,26 @@ export function resolveIntercomBridge(input) {
   const orchestratorTarget = input.orchestratorTarget?.trim();
   const agentDir = path.resolve(input.agentDir ?? defaultAgentDir());
   const settingsDir = path.resolve(input.settingsDir ?? defaultSubagentConfigDir(agentDir));
-  const defaultInstruction = buildIntercomBridgeInstruction(orchestratorTarget || "{orchestratorTarget}", DEFAULT_INTERCOM_BRIDGE_TEMPLATE);
   const reason = inactiveReason(mode, input.context, orchestratorTarget);
   if (reason || !orchestratorTarget) {
-    return { active: false, mode, resultDelivery: config.resultDelivery, extensionDir: NATIVE_INTERCOM_EXTENSION_DIR, instruction: defaultInstruction };
+    return {
+      active: false,
+      mode,
+      resultDelivery: config.resultDelivery,
+      extensionDir: NATIVE_INTERCOM_EXTENSION_DIR,
+      instruction: buildIntercomBridgeInstruction(ORCHESTRATOR_TARGET_PLACEHOLDER, DEFAULT_INTERCOM_BRIDGE_TEMPLATE),
+      interpolatesOrchestratorTarget: false
+    };
   }
+  const template = resolveInstructionTemplate(config.instructionFile, settingsDir);
   return {
     active: true,
     mode,
     resultDelivery: config.resultDelivery,
     orchestratorTarget,
     extensionDir: NATIVE_INTERCOM_EXTENSION_DIR,
-    instruction: buildIntercomBridgeInstruction(orchestratorTarget, resolveInstructionTemplate(config.instructionFile, settingsDir))
+    instruction: buildIntercomBridgeInstruction(orchestratorTarget, template),
+    interpolatesOrchestratorTarget: template.includes(ORCHESTRATOR_TARGET_PLACEHOLDER)
   };
 }
 export function applyIntercomBridgeToAgent(agent, bridge) {
@@ -133,6 +166,7 @@ ${instruction}` : instruction;
     return agent;
   return {
     ...agent,
+    definitionDigest: agentDefinitionDigest(agent),
     tools,
     systemPrompt
   };