@staix/agent-hub 0.12.5 → 0.12.7

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

@@ -139,14 +139,17 @@ export class CodexPeer extends BasePeer {
       });
     } catch (error) {
       const proc = this.proc;
-      if (proc) {
-        await stopOwnedProcess(proc, { group: true });
-        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");
@@ -318,8 +321,7 @@ export class CodexPeer extends BasePeer {
     }
     if (gone) throw new Error(gone);
     const proc = this.proc;
-    await stopOwnedProcess(proc, { group: true });
-    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");
   }
 

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/child-process.ts

@@ -102,18 +102,31 @@ export async function stopOwnedProcess(proc: ChildProcess, { termMs = 1_000, kil
     // 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 (!group || proc.pid === undefined) return;
-    dropPipes(proc);
+    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).
-    const rows = await table();
-    const members = rows ? (rows.some((r) => r.pid === proc.pid) ? [] : rows.filter((r) => r.pgid === proc.pid)) : undefined;
-    if (members ? members.length : !groupGone(proc.pid)) 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`);
-    return;
+    // 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;
@@ -235,11 +248,16 @@ async function stopGroup(proc: ChildProcess, pid: number, termMs: number, killMs
     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; ) {
-      await Bun.sleep(100);
+      // 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) break;
+      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; ; ) {

package/src/hub/daemon.ts

@@ -1023,6 +1023,7 @@ export async function startDaemon(opts: DaemonOptions) {
    * 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;
@@ -1031,8 +1032,12 @@ export async function startDaemon(opts: DaemonOptions) {
       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;
@@ -1697,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") {

package/src/hub/project.ts

@@ -18,10 +18,11 @@ export function canonicalPath(path: string): string {
 }
 
 /**
- * realpathSync, except that Bun 1.3.14 throws ENOENT for an existing path containing a backslash (issue #26). Such a
- * path goes to the system realpath, which handles it and returns every component as stored on disk: guardPath checks
- * names, and on a case-insensitive disk `.GIT/config` or `id_rſa` would otherwise pass for another file. A missing
- * path or a dangling symlink still throws, which guardPath relies on. Other paths take realpathSync's answer unchanged.
+ * realpathSync, except that Bun (1.3.14, and 1.4.2 still: #121) throws ENOENT for an existing path containing a
+ * backslash (issue #26). Such a path goes to the system realpath, which handles it and returns every component as
+ * stored on disk: guardPath checks names, and on a case-insensitive disk `.GIT/config` or `id_rſa` would otherwise
+ * pass for another file. A missing path or a dangling symlink still throws, which guardPath relies on. Other paths take
+ * realpathSync's answer unchanged.
  */
 export function realPath(path: string): string {
   try {

package/src/hub/tasks.ts

@@ -97,6 +97,8 @@ const OWNERSHIP_EVENTS = new Set(["assigned", "escalated", "reassigned", "unassi
 const WITH_DONE = "with its done";
 /** How many times a task changed hands: a cohort member's generation (issue #107). */
 const ownerGen = (t: Task) => t.history.filter((h) => OWNERSHIP_EVENTS.has(h.event)).length;
+/** One hand-over of a task to an owner: a task handed back to a peer that had it before is a new one (#115). */
+const handOver = (t: Task, owner: PeerId) => `${t.id}@${owner}#${ownerGen(t)}`;
 /** When the task was handed to its current owner (its creation, if it never changed hands). */
 const handedAt = (t: Task) => [...t.history].reverse().find((h) => OWNERSHIP_EVENTS.has(h.event) && h.event !== "unassigned")?.at ?? t.history[0]?.at ?? Date.now();
 
@@ -141,6 +143,9 @@ export class Tasks {
     // What the on-prem worker says about a PII task is private on the bus (console tail and log show a stub), so the
     // board keeps the text: `ahub task show <id>` is where the console user reads it, a refusal included.
     d.bus.tap((e) => {
+      // A turn that ends takes its hand-overs with it: busy later is another turn (#115). The adapter's own state, since a
+      // pause shows as `paused` while the turn goes on.
+      if (e.t === "state" && d.bus.peers.get(e.peer)?.state !== "busy") for (const [k, p] of this.sent) if (p === e.peer) this.sent.delete(k);
       if (e.t !== "envelope" || !e.env.private || e.env.from === HUB || !e.env.refs?.task) return;
       try {
         d.board.update(Number(e.env.refs.task), e.env.from, "answer", {}, e.env.body.slice(0, 4000));
@@ -308,15 +313,18 @@ export class Tasks {
     const open = this.d.board.list().filter((t) => OPEN.includes(t.state) && t.id !== task.id && (t.id !== other.id || t.state !== "proposed"));
     // One task of a class is one unit: the only normalization the board supports, so another class is unknown.
     const unit = task.class === other.class ? 1 : undefined;
+    const taking = (p: PeerId) => states[p] === "busy" && (p === candidate ? this.sent.has(handOver(task, p)) : other.state === "proposed" && this.sent.has(handOver(other, p)));
     return predictSplit({
       peers,
       observations: Object.fromEntries(peers.map((p) => [p, this.splitObservations(task.class, p, task.id)])),
       units: [unit, unit],
       profiles: Object.fromEntries(peers.map((p) => [p, this.d.splitProfile?.(p)])),
       backlog: Object.fromEntries(peers.map((p) => [p, open.filter((t) => t.owner === p).length])),
-      // The routed peer may be busy taking this very task, and the other owner taking the overlapped task while it is not
-      // started yet (an owner goes busy as its task is delivered); busy otherwise, it is at work on something already.
-      available: Object.fromEntries(peers.map((p) => [p, !failing[p] && (states[p] === "idle" || (states[p] === "busy" && (p === candidate || other.state === "proposed")))])),
+      // Busy is taking the task in question only in the turn that task started (an owner goes busy as its task is
+      // delivered) or in which it claimed it: the routed peer this very task, the other owner the overlapped one while it
+      // is not started. Busy otherwise, it is at work on something else (#109, #115; a routing or cohort record is taken
+      // before the task is sent, so a busy candidate is not available then).
+      available: Object.fromEntries(peers.map((p) => [p, !failing[p] && (states[p] === "idle" || taking(p))])),
     });
   }
 
@@ -650,6 +658,9 @@ export class Tasks {
         if (shadow) this.d.recordSplit?.(next.id, shadow, "routing");
       } catch { /* shadow only: never between the board write and the delivery */ }
     }
+    // A claim is its own hand-over: the claimant took the task in the turn it is in, so it is taking it, not busy elsewhere.
+    // The cohort record formed just below reads it, and so does `route explain` while that turn lasts.
+    if (opts.claim && a.owner === by && this.d.bus.peers.get(by)?.state === "busy") this.sent.set(handOver(next, by), by);
     const hits = this.overlapHits(next);
     this.formCohort(next, hits);
     if (hits.length) {
@@ -684,7 +695,14 @@ export class Tasks {
       context && !pii ? `Handoff from the previous owner:\n${this.screen(task, context, "handoff", a.owner).slice(0, 3000)}` : "",
       `Take it with hub_task_accept {id: ${task.id}, plan: {paths, symbols, signatures, insertion_points}} (what you will change, before you start${pii ? "" : "; owners of overlapping tasks see it"}) or pass with hub_task_decline. When finished: hub_task_done {id: ${task.id}, summary: what changed, why, and the check you ran with its result, refs}.`,
     ].filter(Boolean).join("\n\n");
-    this.d.bus.publish(newEnvelope(HUB, body, { to: [task.owner!], kind: "task", priority: "important", refs: { ...task.refs, task: String(task.id) }, ...(pii ? { private: true } : {}) }));
+    // A hand-over the owner takes in a turn of its own (#109, #115): idle before, busy after and not queued, this envelope
+    // was in the delivery that started its turn. Busy before, it is queued, or steered into a turn about something else
+    // (Codex, Pi); held, it starts no turn yet: neither is taking it.
+    const owner = task.owner!;
+    const idle = this.d.bus.stateOf(owner) === "idle";
+    const env = newEnvelope(HUB, body, { to: [owner], kind: "task", priority: "important", refs: { ...task.refs, task: String(task.id) }, ...(pii ? { private: true } : {}) });
+    this.d.bus.publish(env);
+    if (idle && this.d.bus.stateOf(owner) === "busy" && !this.d.bus.queueIds(owner).includes(env.id)) this.sent.set(handOver(task, owner), owner);
   }
 
   /** Nobody, the console user included, works on a task before what it waits for is approved. */
@@ -702,6 +720,7 @@ export class Tasks {
   }
 
   private readonly offered = new Set<number>(); // ready tasks offered in this hub run
+  private readonly sent = new Map<string, PeerId>(); // hand-over (`handOver`) -> owner, for the owner's current turn: its task envelope started it, or it claimed the task in it
 
   /**
    * A stop between an approval and the assignment of its dependents (both are saved on their own) leaves them ownerless