@duckmind/dm-darwin-x64 0.66.5 → 0.66.6

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

@@ -0,0 +1,173 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { writeAtomicJson } from "../../shared/atomic-json.js";
+export function bindingPath(asyncDir, index) {
+  return path.join(asyncDir, "inspectors", `tmux${index === undefined ? "" : `-${index}`}.json`);
+}
+function parse(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value))
+    return;
+  const binding = value;
+  if (binding.schemaVersion !== 1 || binding.kind !== "tmux-inspector" || binding.childIndex !== undefined && (!Number.isInteger(binding.childIndex) || binding.childIndex < 0) || typeof binding.runId !== "string" || typeof binding.asyncDir !== "string" || typeof binding.paneId !== "string" || binding.serverPid !== undefined && typeof binding.serverPid !== "string" || typeof binding.openedAt !== "string" || typeof binding.command !== "string")
+    return;
+  return binding;
+}
+export function readTmuxInspectorBinding(asyncDir, index) {
+  try {
+    return parse(JSON.parse(fs.readFileSync(bindingPath(asyncDir, index), "utf8")));
+  } catch {
+    return;
+  }
+}
+export function readTmuxInspectorBindingForTarget(target) {
+  const binding = readTmuxInspectorBinding(target.asyncDir, target.index);
+  if (!binding || binding.runId !== target.runId || binding.childIndex !== target.index)
+    return;
+  try {
+    if (fs.realpathSync(binding.asyncDir) !== fs.realpathSync(target.asyncDir))
+      return;
+  } catch {
+    return;
+  }
+  return binding;
+}
+function result(text, isError = false) {
+  return {
+    content: [{ type: "text", text }],
+    ...isError ? { isError: true } : {},
+    details: { mode: "management", results: [] }
+  };
+}
+function errorText(input) {
+  return `tmux inspector error (${input.code}): ${input.message}`;
+}
+const OWNER_OPTION = "@dm-subagents-inspector";
+function ownerTag(runId, index) {
+  return `dm-subagents:${runId}:${index ?? "-"}`;
+}
+async function probePane(client, binding, signal) {
+  const probe = await client.run(["list-panes", "-t", binding.paneId, "-F", `#{pane_id}|#{${OWNER_OPTION}}|#{pid}`], { timeoutMs: 5000, signal });
+  if (!probe.ok)
+    return probe.error.code === "PANE_GONE" ? { state: "gone" } : { state: "error", error: probe.error };
+  const line = probe.data.split(/\r?\n/).map((entry) => entry.trim()).find((entry) => entry.startsWith(`${binding.paneId}|`));
+  if (!line)
+    return { state: "gone" };
+  const [tag, serverPid] = line.split("|").slice(1);
+  if (tag !== ownerTag(binding.runId, binding.childIndex))
+    return { state: "stale" };
+  if (binding.serverPid !== undefined && binding.serverPid !== serverPid)
+    return { state: "stale" };
+  return { state: "alive" };
+}
+export async function openTmuxInspector(context, launch, focus, client) {
+  const detected = await client.run(["-V"], { timeoutMs: 3000, signal: context.signal });
+  if (!detected.ok)
+    return result(errorText(detected.error), true);
+  const existing = readTmuxInspectorBindingForTarget(context.target);
+  if (existing) {
+    const probe = await probePane(client, existing, context.signal);
+    if (probe.state === "alive") {
+      if (focus) {
+        const refocus = await client.run(["select-pane", "-t", existing.paneId], { timeoutMs: 5000, signal: context.signal });
+        if (!refocus.ok)
+          return result(errorText(refocus.error), true);
+      }
+      return result(`tmux inspector pane ${existing.paneId} is already open for async run ${context.target.runId}. Ctrl-C inside the pane closes it.`);
+    }
+    if (probe.state === "error")
+      return result(errorText(probe.error), true);
+  }
+  const originalPane = focus ? undefined : await client.run(["display-message", "-p", "#{pane_id}"], { timeoutMs: 5000, signal: context.signal });
+  const split = await client.run([
+    "split-window",
+    "-h",
+    "-P",
+    "-F",
+    "#{pane_id}",
+    "-c",
+    context.target.status.cwd ?? context.cwd,
+    launch.displayCommand
+  ], { timeoutMs: 15000, signal: context.signal });
+  if (!split.ok)
+    return result(errorText(split.error), true);
+  const id = split.data;
+  if (!id.startsWith("%"))
+    return result(errorText({ code: "TMUX_ERROR", message: `split-window returned no pane id ('${id}').` }), true);
+  if (context.signal?.aborted) {
+    await client.run(["kill-pane", "-t", id], { timeoutMs: 5000 });
+    return result(errorText({ code: "TIMEOUT", message: `tmux inspector open was aborted.` }), true);
+  }
+  if (originalPane?.ok && originalPane.data) {
+    await client.run(["select-pane", "-t", originalPane.data], { timeoutMs: 5000, signal: context.signal });
+  }
+  const stamp = await client.run(["set-option", "-p", "-t", id, OWNER_OPTION, ownerTag(context.target.runId, context.target.index)], { timeoutMs: 5000 });
+  if (!stamp.ok) {
+    await client.run(["kill-pane", "-t", id], { timeoutMs: 5000 });
+    return result(errorText(stamp.error), true);
+  }
+  const server = await client.run(["display-message", "-p", "#{pid}"], { timeoutMs: 5000 });
+  const binding = {
+    schemaVersion: 1,
+    kind: "tmux-inspector",
+    runId: context.target.runId,
+    asyncDir: context.target.asyncDir,
+    ...context.target.index === undefined ? {} : { childIndex: context.target.index },
+    paneId: id,
+    ...server.ok ? { serverPid: server.data } : {},
+    openedAt: (context.now?.() ?? new Date).toISOString(),
+    tmuxVersion: detected.data,
+    ...launch.mission ? { missionId: launch.mission.id, missionPath: launch.mission.path } : {},
+    command: launch.displayCommand
+  };
+  try {
+    writeAtomicJson(bindingPath(context.target.asyncDir, context.target.index), binding);
+  } catch (error) {
+    await client.run(["kill-pane", "-t", id], { timeoutMs: 5000 });
+    throw error;
+  }
+  return result(`Opened read-only tmux 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. Ctrl-C closes the pane.`);
+}
+export async function statusTmuxInspector(context, client) {
+  const binding = readTmuxInspectorBindingForTarget(context.target);
+  if (!binding) {
+    return result(`No tmux inspector binding exists for async run ${context.target.runId}${context.target.index === undefined ? "" : ` child ${context.target.index}`}.`);
+  }
+  const label = context.target.index === undefined ? "" : ` child ${context.target.index}`;
+  const probe = await probePane(client, binding, context.signal);
+  if (probe.state === "error")
+    return result(errorText(probe.error), true);
+  if (probe.state === "stale") {
+    return result(`tmux inspector pane ${binding.paneId} (run ${context.target.runId}${label}) is alive but does not carry this run's inspector marker; it may belong to other work after a tmux server restart.
+Binding: ${bindingPath(context.target.asyncDir, context.target.index)}
+Run state remains authoritative: ${context.target.status.state}.`);
+  }
+  if (probe.state === "gone") {
+    return result(`tmux inspector pane ${binding.paneId} (run ${context.target.runId}${label}) no longer exists.
+Binding: ${bindingPath(context.target.asyncDir, context.target.index)}
+Run state remains authoritative: ${context.target.status.state}.`);
+  }
+  return result(`tmux inspector pane ${binding.paneId} is open for async run ${context.target.runId}${label}.
+Run state: ${context.target.status.state}
+Binding: ${bindingPath(context.target.asyncDir, context.target.index)}`);
+}
+export async function closeTmuxInspector(context, client) {
+  const binding = readTmuxInspectorBindingForTarget(context.target);
+  if (!binding)
+    return result(`No tmux inspector binding exists for async run ${context.target.runId}.`);
+  const probe = await probePane(client, binding, context.signal);
+  if (probe.state === "error")
+    return result(errorText(probe.error), true);
+  if (probe.state === "stale") {
+    fs.rmSync(bindingPath(context.target.asyncDir, context.target.index), { force: true });
+    return result(`tmux inspector pane ${binding.paneId} does not carry this run's inspector marker; removed the stale binding without killing the pane.`);
+  }
+  if (probe.state === "alive") {
+    const closed = await client.run(["kill-pane", "-t", binding.paneId], { timeoutMs: 1e4, signal: context.signal });
+    if (!closed.ok && 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 tmux inspector pane ${binding.paneId} for async run ${context.target.runId}. The subagent run was not stopped.`);
+}

package/extensions/dm-subagents/src/inspectors/tmux/client.js

@@ -0,0 +1,63 @@
+import { execFile } from "node:child_process";
+function error(code, message, details) {
+  return { ok: false, error: { code, message, ...details !== undefined ? { details } : {} } };
+}
+function failureText(execError, stderr) {
+  const direct = stderr?.split(/\r?\n/).map((line) => line.trim()).find(Boolean);
+  if (direct)
+    return direct;
+  const lines = execError.message.split(/\r?\n/).map((line) => line.trim()).filter(Boolean);
+  const withoutPrefix = lines.filter((line) => !/^Command failed:/.test(line));
+  return withoutPrefix[0] ?? "tmux failed.";
+}
+function classifyFailure(text) {
+  const lower = text.toLowerCase();
+  if (lower.includes("can't find pane") || lower.includes("can't find window"))
+    return "PANE_GONE";
+  if (lower.includes("no server running") || lower.includes("no current client"))
+    return "TMUX_UNAVAILABLE";
+  return "TMUX_ERROR";
+}
+export function createTmuxClient(options = {}) {
+  const bin = options.bin ?? process.env.TMUX_BIN ?? "tmux";
+  const execImpl = options.exec ?? execFile;
+  return {
+    run(args, runOptions = {}) {
+      return new Promise((resolve) => {
+        let settled = false;
+        const abort = () => finish(error("TIMEOUT", `tmux command '${args.join(" ")}' was aborted.`));
+        const finish = (result) => {
+          if (settled)
+            return;
+          settled = true;
+          runOptions.signal?.removeEventListener("abort", abort);
+          resolve(result);
+        };
+        if (runOptions.signal?.aborted) {
+          abort();
+          return;
+        }
+        runOptions.signal?.addEventListener("abort", abort, { once: true });
+        execImpl(bin, args, { timeout: runOptions.timeoutMs ?? 1e4, signal: runOptions.signal }, (execError, stdout, stderr) => {
+          if (execError) {
+            const code = execError.code;
+            if (code === "ENOENT") {
+              finish(error("TMUX_UNAVAILABLE", "tmux is not installed or is not on PATH."));
+              return;
+            }
+            const killed = execError;
+            if (killed.killed === true || killed.signal) {
+              finish(error("TIMEOUT", `tmux command '${args.join(" ")}' timed out.`));
+              return;
+            }
+            const text = failureText(execError, stderr);
+            const exitCode = Number(code);
+            finish(error(exitCode === 127 ? "TMUX_UNAVAILABLE" : classifyFailure(text), text));
+            return;
+          }
+          finish({ ok: true, data: stdout.trim() });
+        });
+      });
+    }
+  };
+}

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

@@ -0,0 +1,14 @@
+import { closeTmuxInspector, openTmuxInspector, readTmuxInspectorBindingForTarget, statusTmuxInspector } from "./actions.js";
+import { createTmuxClient } from "./client.js";
+export function createTmuxInspectorPlugin(deps = {}) {
+  const platform = deps.platform ?? process.platform;
+  const client = deps.client ?? createTmuxClient();
+  return {
+    name: "tmux",
+    available: (context) => platform !== "win32" && Boolean(context.env.TMUX),
+    owns: (context) => readTmuxInspectorBindingForTarget(context.target) !== undefined,
+    open: (context, launch, params) => openTmuxInspector(context, launch, params.focus === true, client),
+    status: (context) => statusTmuxInspector(context, client),
+    close: (context) => closeTmuxInspector(context, client)
+  };
+}

package/extensions/dm-subagents/src/integrations/herdr-status.js

@@ -4,6 +4,7 @@ import {
   SUBAGENT_CONTROL_EVENT
 } from "../shared/types.js";
 import { previewDisplayText, sanitizeDisplayText } from "../shared/display-text.js";
+export const HERDR_FOREGROUND_CONTROL_CHANGED_EVENT = "dm-subagents:herdr:foreground-control-changed";
 const DEFAULT_SOURCE = "dm-subagents:herdr";
 const DEFAULT_TTL_MS = 120000;
 const DEFAULT_REFRESH_MS = 45000;
@@ -57,10 +58,12 @@ function startedRun(data) {
   if (!isRecord(data) || typeof data.id !== "string" || !data.id)
     return;
   const taskLabel = workflowTaskLabel(data);
+  const isWorkflowCoordinator = data.mode === "workflow";
   return {
     id: data.id,
-    ...typeof data.agent === "string" ? { agent: data.agent } : {},
-    ...Array.isArray(data.agents) && data.agents.every((agent) => typeof agent === "string") ? { agents: data.agents } : {},
+    ...isWorkflowCoordinator ? { coordinator: true } : {},
+    ...!isWorkflowCoordinator && typeof data.agent === "string" ? { agent: data.agent } : {},
+    ...isWorkflowCoordinator ? { agents: [] } : Array.isArray(data.agents) && data.agents.every((agent) => typeof agent === "string") ? { agents: data.agents } : {},
     ...taskLabel ? { taskLabel } : {}
   };
 }
@@ -70,13 +73,12 @@ function completedRunId(data) {
   const id = typeof data.runId === "string" ? data.runId : data.id;
   return typeof id === "string" && id.length > 0 ? id : undefined;
 }
-function attentionNotice(data) {
+function attentionRunId(data) {
   if (!isRecord(data) || data.source !== "async" || !isRecord(data.event))
     return;
   if (data.event.type !== "needs_attention" || typeof data.event.runId !== "string" || !data.event.runId)
     return;
-  const label = typeof data.noticeText === "string" && data.noticeText ? data.noticeText : typeof data.event.message === "string" && data.event.message ? data.event.message : "subagent needs attention";
-  return { runId: data.event.runId, label };
+  return data.event.runId;
 }
 export function registerHerdrStatusBridge(options) {
   const env = options.env ?? process.env;
@@ -87,22 +89,20 @@ export function registerHerdrStatusBridge(options) {
   const refreshMs = options.refreshMs ?? DEFAULT_REFRESH_MS;
   const timers = options.timers ?? { setInterval, clearInterval };
   const runs = new Map;
-  const attentionLabels = new Map;
+  const attentionRuns = new Set;
   const acknowledgedAttention = new Set;
   const subscriptions = [];
   let rootSession = false;
   let published = false;
   let busyRaised = false;
   let busyLabel;
-  let blockedRaised = false;
-  let blockedLabel;
   let disposed = false;
   let pendingReport;
   let draining = false;
   let drainPromise = Promise.resolve();
   let refreshTimer;
   const activeAgentNames = () => [...new Set([...runs.values()].flatMap((run) => run.agents?.length ? run.agents : run.agent ? [run.agent] : []))];
-  const activeSubagentCount = () => [...runs.values()].reduce((total, run) => total + Math.max(1, run.agents?.length ?? (run.agent ? 1 : 0)), 0);
+  const activeSubagentCount = () => [...runs.values()].reduce((total, run) => total + (run.coordinator && !run.agents?.length ? 0 : Math.max(1, run.agents?.length ?? (run.agent ? 1 : 0))), 0);
   const activeTaskLabel = () => [...runs.values()].reverse().find((run) => run.taskLabel)?.taskLabel;
   const label = (includeAttention = false) => {
     const agents = activeAgentNames();
@@ -112,7 +112,7 @@ export function registerHerdrStatusBridge(options) {
     const paneText = panes > 0 ? ` · ${panes} pane${panes === 1 ? "" : "s"}` : "";
     const task = activeTaskLabel();
     const taskText = task ? ` · ${task}` : "";
-    const attention = includeAttention && attentionLabels.size > 0 ? " ⚠" : "";
+    const attention = includeAttention && attentionRuns.size > 0 ? " ⚠" : "";
     return `⏳ ${activeCount} subagent${activeCount === 1 ? "" : "s"}${who}${paneText}${taskText}${attention}`;
   };
   const titleSuffix = () => {
@@ -122,7 +122,7 @@ export function registerHerdrStatusBridge(options) {
     const activeCount = activeSubagentCount();
     const task = boundedTaskLabel(activeTaskLabel(), MAX_TITLE_TASK_CHARS);
     const target = task ?? (activeCount === 1 && agentNames.length === 1 ? agentNames[0] : String(activeCount));
-    return `⏳${target}${attentionLabels.size > 0 ? "⚠" : ""}`;
+    return `⏳${target}${attentionRuns.size > 0 ? "⚠" : ""}`;
   };
   const enqueue = (args) => {
     pendingReport = args;
@@ -226,43 +226,21 @@ export function registerHerdrStatusBridge(options) {
       options.events.emit("herdr:busy", { active: false });
     }
   };
-  const syncBlocked = () => {
-    if (!enabled || !rootSession || disposed)
-      return;
-    const nextLabel = [...attentionLabels.values()].at(-1);
-    if (nextLabel !== undefined) {
-      if (blockedRaised && blockedLabel === nextLabel)
-        return;
-      if (blockedRaised)
-        options.events.emit("herdr:blocked", { active: false });
-      blockedRaised = true;
-      blockedLabel = nextLabel;
-      options.events.emit("herdr:blocked", { active: true, label: nextLabel });
-      return;
-    }
-    if (blockedRaised) {
-      blockedRaised = false;
-      blockedLabel = undefined;
-      options.events.emit("herdr:blocked", { active: false });
-    }
-  };
   const clearAttention = () => {
-    attentionLabels.clear();
-    syncBlocked();
+    attentionRuns.clear();
     publish();
   };
-  const raiseAttention = (runId, labelText) => {
-    if (!rootSession || attentionLabels.has(runId))
+  const raiseAttention = (runId) => {
+    if (!rootSession || attentionRuns.has(runId))
       return;
     acknowledgedAttention.delete(runId);
-    attentionLabels.set(runId, labelText);
-    syncBlocked();
+    attentionRuns.add(runId);
     publish();
   };
   const replaceRuns = (nextRuns) => {
-    const nextAttention = new Map;
     const activeIds = new Set;
     runs.clear();
+    attentionRuns.clear();
     for (const run of nextRuns) {
       if (!run || typeof run.id !== "string" || !run.id)
         continue;
@@ -273,19 +251,15 @@ export function registerHerdrStatusBridge(options) {
       if (!run.needsAttention) {
         acknowledgedAttention.delete(run.id);
       } else if (!acknowledgedAttention.has(run.id)) {
-        nextAttention.set(run.id, run.attentionLabel || attentionLabels.get(run.id) || "subagent needs attention");
+        attentionRuns.add(run.id);
       }
     }
     for (const id of acknowledgedAttention) {
       if (!activeIds.has(id))
         acknowledgedAttention.delete(id);
     }
-    attentionLabels.clear();
-    for (const [id, labelText] of nextAttention)
-      attentionLabels.set(id, labelText);
     syncBusy();
     syncRefreshTimer();
-    syncBlocked();
     publish();
   };
   const refresh = () => {
@@ -305,6 +279,10 @@ export function registerHerdrStatusBridge(options) {
       subscriptions.push(unsubscribe);
   };
   if (enabled) {
+    subscribe(HERDR_FOREGROUND_CONTROL_CHANGED_EVENT, () => {
+      if (rootSession && options.getRuns)
+        refresh();
+    });
     subscribe(SUBAGENT_ASYNC_STARTED_EVENT, (data) => {
       if (!rootSession)
         return;
@@ -324,8 +302,7 @@ export function registerHerdrStatusBridge(options) {
       if (!id || !runs.delete(id))
         return;
       acknowledgedAttention.delete(id);
-      if (attentionLabels.delete(id))
-        syncBlocked();
+      attentionRuns.delete(id);
       syncBusy();
       syncRefreshTimer();
       publish();
@@ -333,15 +310,15 @@ export function registerHerdrStatusBridge(options) {
     subscribe(SUBAGENT_CONTROL_EVENT, (data) => {
       if (!rootSession)
         return;
-      const notice = attentionNotice(data);
-      if (!notice || !runs.has(notice.runId))
+      const runId = attentionRunId(data);
+      if (!runId || !runs.has(runId))
         return;
-      raiseAttention(notice.runId, notice.label);
+      raiseAttention(runId);
     });
   }
   return {
     agentStarted() {
-      for (const id of attentionLabels.keys())
+      for (const id of attentionRuns)
         acknowledgedAttention.add(id);
       clearAttention();
     },

package/extensions/dm-subagents/src/integrations/program-status.js

@@ -0,0 +1,179 @@
+import { createHash } from "node:crypto";
+import { sanitizeDisplayText } from "../shared/display-text.js";
+const ID_ROOT = "subagents";
+const MAX_RECORDS = 64;
+const MAX_MSG_BYTES = 2048;
+const MAX_TITLE_BYTES = 192;
+const RUN_SEGMENT_CHARS = 12;
+const MAX_KEY_CHARS = 32 - RUN_SEGMENT_CHARS - 1;
+function segment(value) {
+  return value.replace(/[^A-Za-z0-9_+-]/g, "-");
+}
+function runSegment(runId) {
+  return segment(runId.replace(/-/g, "").slice(0, RUN_SEGMENT_CHARS));
+}
+function keySegment(key) {
+  if (key.length <= MAX_KEY_CHARS && /^[A-Za-z0-9_+-]+$/.test(key))
+    return key;
+  return `${segment(key).slice(0, 12)}-${createHash("sha1").update(key).digest("hex").slice(0, 6)}`;
+}
+function recordId(job) {
+  if (job.parentWorkflowRunId && job.workflowKey) {
+    const parent = runSegment(job.parentWorkflowRunId);
+    return parent ? `${ID_ROOT}/${parent}.${keySegment(job.workflowKey)}` : undefined;
+  }
+  const run = runSegment(job.asyncId);
+  return run ? `${ID_ROOT}/${run}` : undefined;
+}
+function programState(job, blocked) {
+  switch (job.status) {
+    case "queued":
+    case "running":
+      return blocked ? "blocked" : "working";
+    case "complete":
+      return "done";
+    case "failed":
+    case "partial":
+    case "rejected":
+      return "error";
+    case "stopped":
+    case "paused":
+      return "idle";
+  }
+}
+function jobLabel(job) {
+  if (job.workflowKey)
+    return job.workflowKey;
+  if (job.mode === "workflow")
+    return "workflow";
+  const agents = [...new Set(job.agents ?? [])];
+  if (agents.length === 0)
+    return "subagent";
+  return agents.length > 3 ? `${agents.slice(0, 3).join(", ")} +${agents.length - 3}` : agents.join(", ");
+}
+function message(job, state) {
+  switch (state) {
+    case "working":
+      return job.currentTool ? `Running ${job.currentTool}` : "Running";
+    case "blocked":
+      return "Waiting for a reply";
+    case "done":
+      return "Finished";
+    case "error":
+      return job.status === "partial" ? "Finished with failures" : job.status === "rejected" ? "Rejected" : "Failed";
+    case "idle":
+      return job.status === "paused" ? "Paused" : "Stopped";
+  }
+}
+function encodeText(text, maxBytes) {
+  let bytes = Buffer.from(sanitizeDisplayText(text), "utf-8");
+  if (bytes.length > maxBytes) {
+    let end = maxBytes;
+    while (end > 0 && (bytes[end] & 192) === 128)
+      end--;
+    bytes = bytes.subarray(0, end);
+  }
+  return bytes.toString("base64");
+}
+function programStatusReport(fields) {
+  const pairs = [`state=${fields.state}`, `id=${fields.id}`];
+  if (fields.state !== "clear")
+    pairs.push("app=dm-subagents");
+  if (fields.kind)
+    pairs.push(`kind=${fields.kind}`);
+  if (fields.title !== undefined)
+    pairs.push(`title=${encodeText(fields.title, MAX_TITLE_BYTES)}`);
+  if (fields.msg !== undefined)
+    pairs.push(`msg=${encodeText(fields.msg, MAX_MSG_BYTES)}`);
+  return `\x1B]7501;${pairs.join(":")}\x1B\\`;
+}
+export function registerProgramStatusReporter(options) {
+  const write = options.write ?? ((data) => {
+    process.stdout.write(data);
+  });
+  const env = options.env ?? process.env;
+  const isTTY = options.isTTY ?? process.stdout.isTTY === true;
+  const sent = new Map;
+  let active = false;
+  let parentIdle = true;
+  let unansweredAtSettle = new Set;
+  const resend = () => {
+    if (!active)
+      return;
+    for (const report of sent.values())
+      write(report);
+  };
+  let listeningForResume = false;
+  const sync = () => {
+    if (!active)
+      return;
+    const blockedRuns = new Set;
+    if (parentIdle) {
+      for (const request of options.getPendingRequests()) {
+        if (unansweredAtSettle.has(request.id))
+          blockedRuns.add(request.runId);
+      }
+    }
+    const candidates = [];
+    for (const job of options.getJobs()) {
+      const id = recordId(job);
+      if (!id)
+        continue;
+      const state = programState(job, blockedRuns.has(job.asyncId));
+      const report = programStatusReport({ state, id, ...state === "blocked" ? { kind: "question" } : {}, title: jobLabel(job), msg: message(job, state) });
+      candidates.push({ id, report, active: state === "working" || state === "blocked", updatedAt: job.updatedAt ?? job.startedAt ?? 0 });
+    }
+    candidates.sort((left, right) => Number(right.active) - Number(left.active) || right.updatedAt - left.updatedAt || (left.id < right.id ? -1 : left.id > right.id ? 1 : 0));
+    const desired = new Map;
+    for (const candidate of candidates) {
+      if (desired.size === MAX_RECORDS)
+        break;
+      if (!desired.has(candidate.id))
+        desired.set(candidate.id, candidate.report);
+    }
+    for (const id of sent.keys()) {
+      if (desired.has(id))
+        continue;
+      sent.delete(id);
+      write(programStatusReport({ state: "clear", id }));
+    }
+    for (const [id, report] of desired) {
+      if (sent.get(id) === report)
+        continue;
+      sent.set(id, report);
+      write(report);
+    }
+  };
+  return {
+    sessionStarted({ hasUI, mode }) {
+      active = options.enabled && hasUI && mode === "tui" && isTTY && env.TERM !== "dumb" && env.PI_PROGRAM_STATUS !== "0";
+      if (active && !listeningForResume && process.platform !== "win32") {
+        process.on("SIGCONT", resend);
+        listeningForResume = true;
+      }
+      sync();
+    },
+    sync,
+    agentStarted() {
+      parentIdle = false;
+      sync();
+    },
+    agentSettled() {
+      parentIdle = true;
+      unansweredAtSettle = new Set([...options.getPendingRequests()].map((request) => request.id));
+      sync();
+    },
+    dispose(shutdownReason) {
+      if (active && shutdownReason !== "quit") {
+        for (const id of sent.keys())
+          write(programStatusReport({ state: "clear", id }));
+      }
+      sent.clear();
+      active = false;
+      if (listeningForResume) {
+        process.off("SIGCONT", resend);
+        listeningForResume = false;
+      }
+    }
+  };
+}