@staix/agent-hub 0.12.4 → 0.12.6

package/plugins/agent-hub/server.js

@@ -15727,7 +15727,7 @@ class ControlClient {
 // package.json
 var package_default = {
   name: "@staix/agent-hub",
-  version: "0.12.4",
+  version: "0.12.6",
   description: "Native multi-agent hub: Claude Code, Codex, Kimi Code, Pi and local inference as peers in one project",
   license: "MIT",
   type: "module",

package/src/adapters/acp.ts

@@ -2,7 +2,7 @@ import { spawn, type ChildProcessWithoutNullStreams } from "node:child_process";
 import { createInterface } from "node:readline";
 import { renderDigest, replyAudience, replyParent, type Envelope, type PeerId } from "../hub/envelope.ts";
 import { BasePeer } from "../hub/peers.ts";
-import { childEnv, stopOwnedProcess } from "../hub/child-process.ts";
+import { childEnv, stopOwnedProcess, trackGroup } from "../hub/child-process.ts";
 
 export interface PermissionOption {
   optionId: string;
@@ -85,8 +85,10 @@ export class AcpPeer extends BasePeer {
 
   async start(): Promise<void> {
     const [bin, ...args] = this.opts.cmd;
-    const proc = spawn(bin!, args, { cwd: this.opts.cwd, env: childEnv({ ...process.env, ...(this.opts.env ?? {}) }), stdio: ["pipe", "pipe", "pipe"] });
+    // Its own process group, stopped as a whole (#115, as Codex's in #113): an agent CLI may be a launcher with a native child.
+    const proc = spawn(bin!, args, { cwd: this.opts.cwd, env: childEnv({ ...process.env, ...(this.opts.env ?? {}) }), stdio: ["pipe", "pipe", "pipe"], detached: true });
     this.proc = proc;
+    trackGroup(proc);
     proc.on("error", (e) => this.down(`spawn failed: ${e.message}`));
     proc.on("exit", (code) => this.down(`exited with code ${code}`));
     proc.stdin.on("error", () => {}); // EPIPE from a child that died; `exit` / `error` already report it
@@ -112,7 +114,7 @@ export class AcpPeer extends BasePeer {
     try {
       this.sessionId = (await Promise.race([handshake(), timeout])).sessionId;
     } catch (e) {
-      await stopOwnedProcess(proc);
+      await stopOwnedProcess(proc, { group: true }).catch((stop: Error) => this.opts.log?.(`[${this.id}] ${stop.message}`));
       throw e;
     }
     this.setState("idle");
@@ -122,8 +124,8 @@ export class AcpPeer extends BasePeer {
     if (this.activeDeliveryId) this.delivery({ id: this.activeDeliveryId, state: "needs_review", reason: "ACP session stopped before settlement" });
     this.activeDeliveryId = undefined;
     const proc = this.proc;
-    if (!proc || proc.exitCode !== null) return;
-    await stopOwnedProcess(proc);
+    if (!proc) return;
+    await stopOwnedProcess(proc, { group: true }); // also when it exited: what it left in its group fails the stop
     if (this.proc === proc) this.proc = undefined;
   }
 

package/src/adapters/codex-appserver.ts

@@ -2,7 +2,7 @@ import { spawn, type ChildProcess } from "node:child_process";
 import type { Server, ServerWebSocket } from "bun";
 import { renderDigest, replyAudience, replyParent, type Envelope, type PeerId } from "../hub/envelope.ts";
 import { BasePeer } from "../hub/peers.ts";
-import { childEnv, stopOwnedProcess } from "../hub/child-process.ts";
+import { childEnv, stopOwnedProcess, trackGroup } from "../hub/child-process.ts";
 
 export interface CodexOptions {
   /** Port the TUI attaches to: `codex --enable tui_app_server --remote ws://127.0.0.1:<proxyPort>`. */
@@ -79,6 +79,8 @@ export class CodexPeer extends BasePeer {
   private lastAnswer = "";
   private readonly deltas = new Map<string, string[]>();
   private primed = false;
+  /** The Codex version app-server reported in its `initialize` answer (`<client>/<version> (...)`), once seen. */
+  version: string | undefined;
   private readonly steers = new Set<number>(); // request ids of turn/steer calls app-server has not answered yet
   private readonly turnDeliveries = new Map<string, Set<string>>();
   private readonly unboundDeliveries = new Set<string>();
@@ -137,21 +139,26 @@ export class CodexPeer extends BasePeer {
       });
     } catch (error) {
       const proc = this.proc;
-      if (proc) {
-        await stopOwnedProcess(proc);
-        if (this.proc === proc) this.proc = undefined;
-      }
+      // The start's own error is the one reported: a stop that fails too is logged beside it.
+      if (proc && (await this.stopQuietly(proc)) && this.proc === proc) this.proc = undefined;
       throw error;
     }
   }
 
+  /** Stops `proc` as a group; a failure is logged and reported as false, for paths that throw an error of their own. */
+  private stopQuietly(proc: ChildProcess): Promise<boolean> {
+    return stopOwnedProcess(proc, { group: true }).then(() => true, (error: Error) => { this.opts.log?.(`[${this.id}] ${error.message}`); return false; });
+  }
+
   async stop(): Promise<void> {
     this.server?.stop(true);
     this.claimedTui?.tui.close(1001, "hub shutting down");
     const proc = this.proc;
-    if (proc && proc.exitCode === null) {
-      // Wait for the port to be released: `ahub codex` may restart the adapter right away.
-      await stopOwnedProcess(proc);
+    if (proc) {
+      // Wait for the port to be released: `ahub codex` may restart the adapter right away. A launcher that already
+      // exited still has its pipes dropped there, so nothing it left can keep the hub alive, and a group it left members
+      // in fails the stop rather than freeing the port for a restart.
+      await stopOwnedProcess(proc, { group: true });
       if (this.proc === proc) this.proc = undefined;
     }
     this.setState("offline");
@@ -298,7 +305,9 @@ export class CodexPeer extends BasePeer {
       cwd: this.opts.cwd,
       env: childEnv({ ...process.env, ...(this.opts.env ?? {}) }),
       stdio: ["ignore", "ignore", "pipe"],
+      detached: true, // its own process group, stopped as a whole (#113): `codex` is a launcher with a native child
     });
+    trackGroup(this.proc);
     this.proc.stderr?.on("data", (d) => this.opts.log?.(`[${this.id}] ${String(d).trimEnd()}`));
     this.proc.on("error", (e) => (gone = `cannot run ${this.opts.bin ?? "codex"}: ${e.message}`));
     this.proc.on("exit", (code) => {
@@ -312,8 +321,7 @@ export class CodexPeer extends BasePeer {
     }
     if (gone) throw new Error(gone);
     const proc = this.proc;
-    await stopOwnedProcess(proc);
-    if (this.proc === proc) this.proc = undefined;
+    if (proc && (await this.stopQuietly(proc)) && this.proc === proc) this.proc = undefined;
     throw new Error("codex app-server did not become healthy within 10 s");
   }
 
@@ -375,6 +383,7 @@ export class CodexPeer extends BasePeer {
       else p?.resolve(msg.result);
       return; // ours: the TUI never asked for it
     }
+    if (typeof msg.result?.userAgent === "string") this.version = /^[^/\s]+\/(\d+\.\d+\.\d+(?:-[\w.]+)?)/.exec(msg.result.userAgent)?.[1] ?? this.version;
     const tracked = msg.id !== undefined && !msg.method ? link.tracked.get(msg.id) : undefined;
     if (tracked && link.tracked.delete(msg.id)) this.adopt(link, msg.result?.thread?.id, tracked === "thread/start");
     else if (msg.method) this.onNotification(link, msg.method, msg.params ?? {});

package/src/adapters/pi.ts

@@ -4,7 +4,7 @@ import { join, resolve, relative } from "node:path";
 import { spawn, type ChildProcessWithoutNullStreams } from "node:child_process";
 import { renderDigest, replyAudience, replyParent, type Envelope, type PeerId } from "../hub/envelope.ts";
 import { BasePeer } from "../hub/peers.ts";
-import { stopOwnedProcess } from "../hub/child-process.ts";
+import { stopOwnedProcess, trackGroup } from "../hub/child-process.ts";
 import { realPath } from "../hub/project.ts";
 import type { ExecutionBudgetDecision, ExecutionUnit } from "../hub/execution-budget.ts";
 
@@ -266,7 +266,9 @@ export class PiPeer extends BasePeer {
     const command = this.opts.cmd ?? ["pi"];
     this._tuiLaunch = { cmd: command[0]!, args: [...command.slice(1), ...args], env };
     if (this.opts.mode === "tui") { return; }
-    this.proc = spawn(command[0]!, [...command.slice(1), ...args], { cwd: this.opts.cwd, env, stdio: ["pipe", "pipe", "pipe"] });
+    // Its own process group, stopped as a whole (#115, as Codex's in #113).
+    this.proc = spawn(command[0]!, [...command.slice(1), ...args], { cwd: this.opts.cwd, env, stdio: ["pipe", "pipe", "pipe"], detached: true });
+    trackGroup(this.proc);
     this.proc.stdout.on("data", (chunk) => this.onOutput(String(chunk)));
     this.proc.stderr.on("data", (chunk) => this.opts.log?.(`[${this.id}] ${String(chunk).trimEnd()}`));
     this.proc.on("error", (error) => this.fail(error));
@@ -311,8 +313,10 @@ export class PiPeer extends BasePeer {
       this.resolveTuiExit?.(); this.resolveTuiExit = undefined;
     }
     const proc = this.proc;
-    if (proc && proc.exitCode === null) await stopOwnedProcess(proc);
-    this.proc = undefined;
+    // Also when it exited: what it left in its group fails the stop. The rest of the teardown runs either way; a process
+    // that could not be stopped stays recorded, so a later stop tries it again.
+    let failed: unknown;
+    if (proc) await stopOwnedProcess(proc, { group: true }).then(() => { if (this.proc === proc) this.proc = undefined; }, (error: unknown) => { failed = error; });
     for (const waiter of this.tuiWaiters) { clearTimeout(waiter.timer); waiter.resolve(undefined); }
     this.tuiWaiters = [];
     for (const pending of this.tuiCommands.values()) pending.reject(new Error("Pi owner stopped"));
@@ -320,6 +324,7 @@ export class PiPeer extends BasePeer {
     for (const pending of this.pending.values()) pending.reject(new Error("Pi owner stopped"));
     this.pending.clear();
     this.server?.stop(true); this.server = undefined; this.setState("offline");
+    if (failed) throw failed;
   }
 
   /**

package/src/hub/board.ts

@@ -24,6 +24,8 @@ export interface HistoryEntry {
   note?: string;
   /** The owner an event that set it left the task with (#67); absent in rows written before 0.11. */
   owner?: PeerId | null;
+  /** On a hand-over: the new owner's split profile then (#109); absent when it was unknown. */
+  profile?: string;
 }
 export interface Task {
   id: number;
@@ -117,14 +119,14 @@ export class Board {
 
   /** The only way a task changes. Validates the move, records who did what, returns the new row. */
   /** A `plan` in the patch replaces the old one whole: a new plan is the owner's current intent, not an addition. */
-  update(id: number, by: PeerId, event: string, patch: Partial<Pick<Task, "state" | "owner" | "reviewer" | "refs" | "plan" | "rejections">>, note?: string): Task {
+  update(id: number, by: PeerId, event: string, patch: Partial<Pick<Task, "state" | "owner" | "reviewer" | "refs" | "plan" | "rejections">>, note?: string, extra: Pick<HistoryEntry, "profile"> = {}): Task {
     const task = this.get(id);
     if (!task) throw new Error(`no task #${id}`);
     if (patch.state && patch.state !== task.state && !MOVES[task.state].includes(patch.state)) {
       throw new Error(`task #${id} is ${task.state}: cannot move to ${patch.state}`);
     }
     const next = { ...task, ...patch, refs: { ...task.refs, ...patch.refs } };
-    const history = [...task.history, { at: Date.now(), by, event, ...(note ? { note } : {}), ...("owner" in patch ? { owner: next.owner } : {}) }];
+    const history = [...task.history, { at: Date.now(), by, event, ...(note ? { note } : {}), ...("owner" in patch ? { owner: next.owner } : {}), ...(extra.profile ? { profile: extra.profile } : {}) }];
     this.db
       .query("UPDATE tasks SET state = ?, owner = ?, reviewer = ?, refs = ?, plan = ?, rejections = ?, history = ?, updated = ? WHERE id = ?")
       .run(next.state, next.owner, next.reviewer, JSON.stringify(next.refs), JSON.stringify(next.plan ?? {}), next.rejections, JSON.stringify(history), Date.now(), id);

package/src/hub/child-process.ts

@@ -11,14 +11,122 @@ export function childEnv(source: NodeJS.ProcessEnv = process.env): NodeJS.Proces
   return env;
 }
 
+/** One process: its identity is the pid with its start time (`lstart`, which exec keeps); group and command are evidence. */
+export interface ProcRow {
+  pid: number;
+  ppid: number;
+  pgid: number;
+  started: string;
+  command: string;
+}
+
+/**
+ * `ps -axo pid=,ppid=,pgid=,stat=,lstart=,command=` output (unlimited width when not on a terminal), read in the C
+ * locale. A zombie is left out: it has exited, and only its parent's wait is missing.
+ */
+export function parseProcessTable(text: string): ProcRow[] {
+  return text.split("\n").flatMap((line) => {
+    const m = /^\s*(\d+)\s+(\d+)\s+(\d+)\s+(\S+)\s+(\w{3} \w{3} [ \d]\d \d\d:\d\d:\d\d \d{4})\s+(.*)$/.exec(line);
+    return m && !m[4]!.startsWith("Z") ? [{ pid: Number(m[1]), ppid: Number(m[2]), pgid: Number(m[3]), started: m[5]!, command: m[6]! }] : [];
+  });
+}
+
+const PS = ["ps", "-axo", "pid=,ppid=,pgid=,stat=,lstart=,command="];
+// `lstart` is local time: one zone for every reader, or a reader in another zone sees every identity as changed.
+const PS_OPTIONS = { env: { ...process.env, LC_ALL: "C", TZ: "UTC" }, detached: true } as const;
+/** The rows of one read, or undefined when they do not show the reader: a parse that found nothing is not a table. */
+const own = (text: string) => { const rows = parseProcessTable(text); return rows.some((row) => row.pid === process.pid) ? rows : undefined; };
+
+/**
+ * The process table, or undefined when it cannot be read or does not show this process: a parse that found nothing
+ * (a localized `lstart`, a changed `ps`) is not an empty table. Read with LC_ALL=C for that reason (and TZ=UTC, so
+ * start times compare across readers), by a `ps` in a
+ * process group of its own (a Ctrl-C to the caller's group would kill it), bounded, and tried twice.
+ */
+export function processTable(): ProcRow[] | undefined {
+  for (let attempt = 0; attempt < 2; attempt++) {
+    try {
+      const r = Bun.spawnSync(PS, { ...PS_OPTIONS, stdout: "pipe", stderr: "pipe", timeout: 10_000 });
+      const rows = r.exitCode === 0 ? own(r.stdout.toString()) : undefined;
+      if (rows) return rows;
+    } catch {
+      // tried again below
+    }
+  }
+  return undefined;
+}
+
+/** `processTable`, without blocking the event loop: a hub stop reads the table many times while it keeps serving. */
+export async function readProcessTable(): Promise<ProcRow[] | undefined> {
+  for (let attempt = 0; attempt < 2; attempt++) {
+    try {
+      const p = Bun.spawn(PS, { ...PS_OPTIONS, stdout: "pipe", stderr: "ignore" });
+      const timer = setTimeout(() => p.kill("SIGKILL"), 10_000);
+      const [text, code] = await Promise.all([new Response(p.stdout).text(), p.exited]).finally(() => clearTimeout(timer));
+      const rows = code === 0 ? own(text) : undefined;
+      if (rows) return rows;
+    } catch {
+      // tried again below
+    }
+  }
+  return undefined;
+}
+
+/** Every descendant of `pid` in `rows`, by parent links. */
+export function descendantsOf(rows: ProcRow[], pid: number): ProcRow[] {
+  const out: ProcRow[] = [];
+  const parents = new Set([pid]);
+  for (let grew = true; grew; ) {
+    grew = false;
+    for (const row of rows) {
+      if (parents.has(row.ppid) && !parents.has(row.pid)) {
+        parents.add(row.pid);
+        out.push(row);
+        grew = true;
+      }
+    }
+  }
+  return out;
+}
+
 /**
  * Stop a child owned by this hub and confirm that it exited. A timeout is an
  * incomplete shutdown, even after SIGKILL, because callers must not reuse a
  * port or claim ownership while the old process may still be alive.
+ *
+ * `group`: the child was spawned `detached` and leads its own process group; see `stopGroup`. `table` replaces the
+ * process table read (tests).
  */
-export async function stopOwnedProcess(proc: ChildProcess, termMs = 1_000, killMs = 2_000): Promise<void> {
-  if (proc.exitCode !== null || proc.signalCode !== null || proc.pid === undefined) return;
+export async function stopOwnedProcess(proc: ChildProcess, { termMs = 1_000, killMs = 2_000, group = false, table = readProcessTable }: { termMs?: number; killMs?: number; group?: boolean; table?: () => ProcRow[] | undefined | Promise<ProcRow[] | undefined> } = {}): Promise<void> {
+  if (proc.exitCode !== null || proc.signalCode !== null || proc.pid === undefined) {
+    // ponytail: a leader that exited before the stop (its launcher killed from outside) is not swept, as its pid may be
+    // reused once its group empties; its pipes are dropped so a survivor cannot keep the hub alive, and a group that
+    // still has members fails the stop instead of reading as done. Record the leader's start time at spawn to sweep it.
+    if (proc.pid === undefined) return;
+    dropPipes(proc); // whatever it left cannot keep the hub alive through them
+    if (!group) return;
+    if (emptied.has(proc)) return; // its group was seen gone since: the id may be someone else's now
+    // A pid is not given out while a group with that id exists: a live process with the leader's pid means the group was
+    // emptied and the id is someone else's now. Members without it are what the leader left (zombies are not listed).
+    // Members still finishing their own exit get up to `killMs` before the stop fails.
+    for (const end = Date.now() + killMs; ; await Bun.sleep(100)) {
+      const rows = await table();
+      const reused = rows?.some((r) => r.pid === proc.pid);
+      const members = reused ? [] : rows?.filter((r) => r.pgid === proc.pid);
+      if (members ? !members.length : groupGone(proc.pid)) return;
+      if (Date.now() >= end) throw new Error(`owned child ${proc.pid} exited before the stop and its process group still has members${members ? ` (${members.map((r) => r.pid).join(", ")})` : ""}: not signalled; stop them to restart it`);
+    }
+  }
+  if (group) return stopGroup(proc, proc.pid, termMs, killMs, table);
+  try {
+    await stopAlone(proc, termMs, killMs);
+  } finally {
+    dropPipes(proc); // a process it started and left may still hold them: it must not keep the hub alive
+  }
+}
 
+/** SIGTERM, then SIGKILL, to the child alone, each confirmed by its exit. */
+async function stopAlone(proc: ChildProcess, termMs: number, killMs: number): Promise<void> {
   const waitForExit = (timeoutMs: number): Promise<boolean> =>
     new Promise((resolve) => {
       let timer: ReturnType<typeof setTimeout> | undefined;
@@ -53,3 +161,134 @@ export async function stopOwnedProcess(proc: ChildProcess, termMs = 1_000, killM
   if (proc.exitCode !== null || proc.signalCode !== null || (await waitForExit(killMs))) return;
   throw new Error(`owned child ${proc.pid} shutdown incomplete after SIGKILL`);
 }
+
+const dropPipes = (proc: ChildProcess) => {
+  proc.stdout?.destroy();
+  proc.stderr?.destroy();
+};
+
+const emptied = new WeakSet<ChildProcess>();
+/**
+ * Follows the group of a child spawned `detached` after the child exits, until the group is gone: a later stop then
+ * never inspects the group id, which can be reused once the group is empty (issue #113).
+ */
+export function trackGroup(proc: ChildProcess): void {
+  proc.once("exit", () => {
+    const pid = proc.pid;
+    if (pid === undefined) return;
+    const check = () => { if (groupGone(pid)) emptied.add(proc); else setTimeout(check, 1_000).unref(); };
+    check();
+  });
+}
+
+/** Whether no process is left in group `pgid` (macOS answers EPERM for a group of zombies). */
+function groupGone(pgid: number): boolean {
+  try { process.kill(-pgid, 0); return false; } catch (error) {
+    const code = (error as NodeJS.ErrnoException).code;
+    return code === "ESRCH" || (code === "EPERM" && process.platform === "darwin");
+  }
+}
+
+/**
+ * Stops a child that leads its own process group, with everything it started (issue #113). A launcher that forwards
+ * signals to a native child (Codex's `codex.js`) otherwise dies alone at SIGKILL while its child, still at work, is
+ * re-parented to init with the launcher's pipes and keeps the hub alive; and the native child starts processes that
+ * lead groups of their own (Codex's MCP servers and tool commands), which no group signal reaches.
+ *
+ * SIGTERM to the group, a grace period in which what the tree starts is recorded while its parent still runs, then
+ * freeze, enumerate, kill: what is left is stopped (SIGSTOP) before the table is read again, because a stopped process
+ * starts nothing, so that read sees all of it; then SIGKILL. A snapshot taken while the tree runs misses what it starts
+ * next (three review rounds found such a gap). Done means the table shows none of it; without any table, the group's
+ * own answer (ESRCH, or EPERM on macOS for a group of zombies) is used, which cannot see groups below it.
+ */
+async function stopGroup(proc: ChildProcess, pid: number, termMs: number, killMs: number, table: () => ProcRow[] | undefined | Promise<ProcRow[] | undefined>): Promise<void> {
+  const key = (r: { pid: number; started: string }) => `${r.pid}@${r.started}`;
+  const found = new Map<string, ProcRow>();
+  const exited = () => proc.exitCode !== null || proc.signalCode !== null;
+  let leader: ProcRow | undefined;
+  const live = (rows: ProcRow[], f: ProcRow) => rows.some((r) => r.pid === f.pid && r.started === f.started);
+  /** Reads the table and records what runs below the leader or anything recorded that still runs. */
+  const look = async (): Promise<ProcRow[] | undefined> => {
+    const rows = await table();
+    if (!rows) return undefined;
+    if (!leader && !exited()) leader = rows.find((r) => r.pid === pid); // never a pid taken over after the leader exited
+    const roots = [...(leader && live(rows, leader) ? [leader] : []), ...[...found.values()].filter((f) => live(rows, f))];
+    for (const root of roots) for (const r of descendantsOf(rows, root.pid)) found.set(key(r), r);
+    // A group is followed while it is known to be the same one: its leader or a recorded member still in it.
+    for (const id of [pid, ...[...found.values()].filter((f) => f.pgid === f.pid).map((f) => f.pid)]) {
+      // Current rows, never a recorded pgid: a member may have left the group since it was recorded.
+      const known = (id === pid && leader && live(rows, leader)) || rows.some((r) => r.pgid === id && r.pid !== id && found.has(key(r))) || rows.some((r) => r.pid === id && r.pgid === id && found.has(key(r)));
+      if (known) for (const r of rows) if (r.pgid === id && r.pid !== pid) found.set(key(r), r);
+    }
+    return rows;
+  };
+  const left = (rows: ProcRow[]) => [...found.values()].filter((f) => live(rows, f));
+  /**
+   * Running in the leader's group, or the group of a recorded process, without being recorded: after an empty moment the
+   * group id can be someone else's, so it is never signalled, but the stop is not done while it runs.
+   */
+  const unproven = (rows: ProcRow[]) => {
+    const ids = new Set([pid, ...[...found.values()].filter((f) => f.pgid === f.pid).map((f) => f.pid)]);
+    return rows.filter((r) => ids.has(r.pgid) && r.pid !== process.pid && !found.has(key(r)) && !(leader && r.pid === leader.pid && r.started === leader.started));
+  };
+  // Errors are not results here: the table read back decides. A sent signal says the target existed at that moment.
+  const signal = (target: number, sig: NodeJS.Signals) => { try { process.kill(target, sig); return true; } catch { return false; } };
+  const each = (rows: ProcRow[], sig: NodeJS.Signals) => rows.filter((r) => signal(r.pgid === r.pid ? -r.pid : r.pid, sig));
+  /** A read that takes longer than `ms` is given up: a frozen tree must not wait on a slow `ps` for its SIGKILL. */
+  const within = (ms: number) => Promise.race([look(), Bun.sleep(ms).then(() => undefined)]);
+  // What leads a group of its own (an MCP server, a tool command) gets a SIGTERM of its own and the same grace period:
+  // a git process stopped by SIGKILL leaves its index lock behind.
+  const termed = new Set<string>();
+  const term = (rows: ProcRow[] | undefined) => {
+    for (const r of rows ? left(rows) : []) if (r.pgid === r.pid && !termed.has(key(r))) { termed.add(key(r)); signal(-r.pid, "SIGTERM"); }
+  };
+  try {
+    const first = await look();
+    if (!exited()) signal(-pid, "SIGTERM"); // a reaped leader's group id is not proven any more
+    term(first);
+    // The grace period, for the leader and for what it started: what they start meanwhile is recorded while its parent
+    // still runs.
+    const leaderGone = new Promise<void>((resolve) => (exited() ? resolve() : proc.once("exit", () => resolve())));
+    for (const end = Date.now() + termMs; Date.now() < end; ) {
+      // The leader's exit ends a wait at once (a stop is usually that quick); after it, the table is read every 100 ms.
+      await (exited() ? Bun.sleep(100) : Promise.race([leaderGone, Bun.sleep(100)]));
+      const rows = await look();
+      term(rows);
+      if (exited() && rows && !left(rows).length) {
+        if (!unproven(rows).length) return; // done: this read shows none of it
+        break;
+      }
+    }
+    // Freeze, enumerate, kill: a stopped process starts nothing, so a read after the freeze sees all of it.
+    for (const end = Date.now() + killMs; ; ) {
+      const rows = await look();
+      const rest = rows ? left(rows) : undefined;
+      const strangers = rows ? unproven(rows) : [];
+      if (exited() && !strangers.length && (rest ? !rest.length : !found.size && groupGone(pid))) return;
+      if (Date.now() >= end) {
+        throw new Error(`owned child ${pid}: ${rest ? `${rest.length + strangers.length} process(es) of its group or below it still running${strangers.length ? `, ${strangers.length} not proven its own and left alone` : ""}` : "the process table cannot be read to confirm what it started is gone"}`);
+      }
+      // What is stopped is killed or continued, never left frozen: the group by whether its STOP was sent (its id stays
+      // reserved while a member lives), each process by whether the read after the freeze still shows it. What a read
+      // after the freeze shows for the first time (started between the read and the STOPs, in a group of its own) is
+      // frozen too, and read again, before anything is killed.
+      const groupStopped = !exited() && signal(-pid, "SIGSTOP");
+      const stopped = new Map<string, ProcRow>();
+      let frozen: ProcRow[] | undefined;
+      for (let todo = rest ?? [], round = 0; ; round++) {
+        for (const r of each(todo, "SIGSTOP")) stopped.set(key(r), r);
+        frozen = await within(1_000);
+        todo = frozen ? left(frozen).filter((r) => !stopped.has(key(r))) : [];
+        if (!todo.length || round >= 4) break;
+      }
+      // Without a read after the freeze, only what the STOP reached is killed: a stopped process keeps its pid.
+      const kill = frozen ? left(frozen) : [...stopped.values()];
+      each(kill, "SIGKILL");
+      if (groupStopped) signal(-pid, "SIGKILL");
+      for (const r of stopped.values()) if (!kill.some((k) => k.pid === r.pid && k.started === r.started)) signal(r.pgid === r.pid ? -r.pid : r.pid, "SIGCONT");
+      await Bun.sleep(50);
+    }
+  } finally {
+    dropPipes(proc); // a process that left the tree between two reads may still hold them: it must not keep the hub alive
+  }
+}

package/src/hub/daemon.ts

@@ -1,5 +1,5 @@
 import { createHash, randomBytes, randomUUID } from "node:crypto";
-import { appendFileSync, chmodSync, existsSync, mkdirSync, readFileSync, renameSync, rmSync, writeFileSync } from "node:fs";
+import { appendFileSync, chmodSync, existsSync, fstatSync, mkdirSync, readFileSync, renameSync, rmSync, writeFileSync } from "node:fs";
 import { join, resolve } from "node:path";
 import { homedir } from "node:os";
 import { spawn } from "node:child_process";
@@ -28,7 +28,7 @@ import { Board, CLASSES, type Task, type TaskClass } from "./board.ts";
 import { Budget, claudeWindows, codexWindows, DEFAULT_BUDGET, type BudgetConfig } from "./budget.ts";
 import { HUB } from "./envelope.ts";
 import { trimToTokens } from "../memory/recall.ts";
-import { closeSync, openSync, readSync, statSync } from "node:fs";
+import { closeSync, constants as fsConstants, openSync, readSync, statSync } from "node:fs";
 import { basename, isAbsolute } from "node:path";
 import { realPath } from "./project.ts";
 import type { BusEvent } from "./bus.ts";
@@ -539,15 +539,15 @@ export async function startDaemon(opts: DaemonOptions) {
       if (!factsOn()) return undefined;
       let offered: ReturnType<Facts["due"]>;
       try { offered = facts.due(peer, undefined, true); } catch (error) { log(`integration facts for ${peer}: ${(error as Error).message}`); return undefined; }
-      if (offered) event({ type: "fact", peer, id: offered.id, files: offered.files, plans: offered.plans, unknown: offered.unknown, bytes: offered.bytes, via: "done" });
+      if (offered) event({ type: "fact", peer, id: offered.id, files: offered.files, plans: offered.plans, unknown: offered.unknown, named: offered.named, bytes: offered.bytes, via: "done" });
       return offered ? { id: offered.id, text: offered.text } : undefined;
     },
     ackFacts: (peer, id) => acked(peer, id, "done"),
     factsCurrent: (peer) => !factsOn() || facts.current(peer),
-    since: hubStartedAt,
+    splitProfile: (peer) => splitProfile(peer),
     recordCohort: (c) => event({ type: "cohort", ...c }),
     // The trace holds peer names and numbers only (never task text): it is the inputs a later check of the prediction needs.
-    recordSplit: (task, p) => event({ type: "split", task, verdict: p.verdict, ...(p.single ? { single: p.single, splitS: p.splitS, singleS: p.singleS } : {}), ...(p.verdict === "unknown" ? { reason: p.trace.at(-1)!.replace(/^ {2}unknown: /, "").slice(0, 200) } : {}), trace: p.trace.slice(1).map((l) => l.trim()).slice(0, 10) }),
+    recordSplit: (task, p, where) => event({ type: "split", task, where, verdict: p.verdict, ...(p.single ? { single: p.single, splitS: p.splitS, singleS: p.singleS } : {}), ...(p.verdict === "unknown" ? { reason: p.trace.at(-1)!.replace(/^ {2}unknown: /, "").slice(0, 200) } : {}), trace: p.trace.slice(1).map((l) => l.trim()).slice(0, 10) }),
     failing: () => bus.failingPeers(),
     held: () => Object.fromEntries(bus.knownPeers().flatMap((peer) => { const hold = queueHold(peer); return hold ? [[peer, hold]] : []; })),
   });
@@ -1018,6 +1018,51 @@ export async function startDaemon(opts: DaemonOptions) {
       };
     } catch { return {}; }
   };
+  /**
+   * Claude Code's version, from the last row of its transcript that names one (its rows carry it): the last MiB is read,
+   * opened without blocking and only as a regular file, and the last version found is kept for a tail of big rows.
+   */
+  const claudeVersions = new Map<string, string>();
+  const claudeStamps = new Map<string, string>(); // the transcript's size and mtime when its version was read (#115)
+  const claudeVersion = (): string | undefined => {
+    const path = claudeSession().transcriptPath;
+    if (!path) return undefined;
+    let fd: number | undefined;
+    try {
+      fd = openSync(path, fsConstants.O_RDONLY | fsConstants.O_NONBLOCK);
+      const st = fstatSync(fd);
+      if (!st.isFile()) return claudeVersions.get(path);
+      // Asked several times per assignment: the last MiB is read again only once the transcript changed.
+      const stamp = `${st.size}:${st.mtimeMs}`;
+      if (claudeStamps.get(path) === stamp) return claudeVersions.get(path); // no version in it is an answer too
+      const buf = Buffer.alloc(Math.min(st.size, 1024 * 1024));
+      readSync(fd, buf, 0, buf.length, st.size - buf.length);
+      claudeStamps.set(path, stamp); // after the read: one that failed is tried again
+      for (const line of buf.toString("utf8").split("\n").reverse()) {
+        try {
+          const version = JSON.parse(line)?.version;
+          const found = typeof version === "string" ? /^\d+\.\d+\.\d+(?:-[\w.]+)?/.exec(version)?.[0] : undefined;
+          if (found) {
+            claudeVersions.set(path, found);
+            return found;
+          }
+        } catch { /* the cut first line, or not JSON */ }
+      }
+    } catch { /* no transcript yet */ } finally { if (fd !== undefined) closeSync(fd); }
+    return claudeVersions.get(path);
+  };
+  /**
+   * A peer's split profile (issue #109): the hub's version, its agent's, and the hook profile, which is the hub's own (a
+   * turn-free project runs the facts hooks in Claude and steers facts into Codex). Undefined while a version is unknown.
+   * ponytail: the user's and plugins' hooks are not seen here, and only Claude and Codex report a version; read hooks
+   * from the native records, as the benchmark ledger does, and add other agents' versions when a pair needs them.
+   */
+  function splitProfile(peer: PeerId): string | undefined {
+    try {
+      const version = peer === "codex" ? (bus.peers.get("codex") as { version?: string } | undefined)?.version : peer === "claude" ? claudeVersion() : undefined;
+      return version ? `hub ${VERSION}; ${peer} ${version}; ${turnFree() ? "turn-free" : "advisory"}` : undefined; // the regime in force: a PII task suspends turn-free
+    } catch { return undefined; } // asked before the daemon finished starting
+  }
   /** Claude persists projects/<slug>/<sessionId>.jsonl only with the first turn. Prefer the
    * path Claude itself reported through the status line; fall back to the slug computation. */
   const claudeTranscriptPersisted = (sessionId: string): boolean => {
@@ -1552,7 +1597,7 @@ export async function startDaemon(opts: DaemonOptions) {
             // Refused, it never went in: not an unread offer, and the next boundary offers it again. Unanswered, it may
             // have: its readback can still come.
             if (outcome === "refused") facts.drop("codex", offered.id);
-            event({ type: "fact", peer: "codex", id: offered.id, files: offered.files, plans: offered.plans, unknown: offered.unknown, bytes: offered.bytes, via: "steer", ms, ...(outcome === "accepted" ? { rttMs: Math.round(performance.now() - sent) } : {}), accepted: outcome === "accepted", ...(outcome === "unanswered" ? { unanswered: true } : {}), ...(offered.probe ? { probe: true } : {}), ...(offered.coverage ? { coverage: true } : {}) });
+            event({ type: "fact", peer: "codex", id: offered.id, files: offered.files, plans: offered.plans, unknown: offered.unknown, named: offered.named, bytes: offered.bytes, via: "steer", ms, ...(outcome === "accepted" ? { rttMs: Math.round(performance.now() - sent) } : {}), accepted: outcome === "accepted", ...(outcome === "unanswered" ? { unanswered: true } : {}), ...(offered.probe ? { probe: true } : {}), ...(offered.coverage ? { coverage: true } : {}) });
           });
         },
         appPort: opts.codexAppPort,
@@ -1657,7 +1702,8 @@ export async function startDaemon(opts: DaemonOptions) {
       recoveryTaskPreface("pi");
       await ensurePreface("pi");
       bus.add(pi);
-      try { await pi.start(); } catch (error) { await pi.stop(); throw error; }
+      // The start's own error is the one reported; a stop that fails too is logged beside it (#115).
+      try { await pi.start(); } catch (error) { await pi.stop().catch((stop: Error) => log(`pi stop after a failed start: ${stop.message}`)); throw error; }
       return { ok: true, ...(mode === "tui" ? { launch: pi.tuiLaunch } : {}) };
     }
     if (peer === "local") {
@@ -2143,7 +2189,7 @@ export async function startDaemon(opts: DaemonOptions) {
             return void reply({ t: "facts", ok: true });
           }
           const offered = offerFor(peer, toolUseId);
-          if (offered) event({ type: "fact", peer, id: offered.id, files: offered.files, plans: offered.plans, unknown: offered.unknown, bytes: offered.bytes, via: "hook", ms: Math.round(performance.now() - started), ...(typeof msg.startedMs === "number" && Number.isFinite(msg.startedMs) ? { hookMs: Math.round(msg.startedMs) } : {}), ...(offered.probe ? { probe: true } : {}), ...(offered.coverage ? { coverage: true } : {}) });
+          if (offered) event({ type: "fact", peer, id: offered.id, files: offered.files, plans: offered.plans, unknown: offered.unknown, named: offered.named, bytes: offered.bytes, via: "hook", ms: Math.round(performance.now() - started), ...(typeof msg.startedMs === "number" && Number.isFinite(msg.startedMs) ? { hookMs: Math.round(msg.startedMs) } : {}), ...(offered.probe ? { probe: true } : {}), ...(offered.coverage ? { coverage: true } : {}) });
           return void reply({ t: "facts", ok: true, ...(offered ? { text: offered.text, id: offered.id } : {}) });
         } catch (error) {
           log(`facts for ${c.peer}: ${(error as Error).message}`);

package/src/hub/events.ts

@@ -12,10 +12,10 @@ export type HubEvent =
   | { type: "overflow" | "undeliverable"; id: string; from: string; peer: string }
   | { type: "stale"; id: string; from: string; peer: string; task?: string }
   | { type: "quiet"; id: string; from: string; peers: string[] }
-  | { type: "fact"; peer: string; id: string; files: number; plans: number; unknown: number; bytes: number; via: "hook" | "steer" | "done"; ms?: number; hookMs?: number; rttMs?: number; accepted?: boolean; unanswered?: boolean; probe?: boolean; coverage?: boolean }
+  | { type: "fact"; peer: string; id: string; files: number; plans: number; unknown: number; named: number; bytes: number; via: "hook" | "steer" | "done"; ms?: number; hookMs?: number; rttMs?: number; accepted?: boolean; unanswered?: boolean; probe?: boolean; coverage?: boolean }
   | { type: "fact_ack"; peer: string; id: string; via: string; ms: number }
   | { type: "capability"; peer: string; state: "verified" | "lost"; via?: string }
-  | { type: "split"; task: number; verdict: "split" | "single" | "unknown"; single?: string; splitS?: number; singleS?: number; reason?: string; trace?: string[] }
+  | { type: "split"; task: number; where?: "routing" | "cohort"; verdict: "split" | "single" | "unknown"; single?: string; splitS?: number; singleS?: number; reason?: string; trace?: string[] }
   | { type: "state"; peer: string; state: string }
   | { type: "turn_start"; peer: string; turn: string }
   | { type: "turn_end"; peer: string; turn: string; ms: number; tokens?: number; files?: number; snapshotMs?: number }