@fradser/pi-agent-teams 0.5.1 → 0.5.2

package/README.md

@@ -86,6 +86,7 @@ State is session-scoped and dies with the session (`~/.pi/agent/teammate/<sessio
 
 ```
 agent-teams/
+├── index.ts           — package-root extension entry point
 ├── package.json       — Pi package manifest
 ├── agents/            — bundled agent definitions (worker/reviewer/specialist/observer)
 ├── src/

package/index.ts

@@ -0,0 +1 @@
+export { default } from "./src/index.ts";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fradser/pi-agent-teams",
-  "version": "0.5.1",
+  "version": "0.5.2",
   "description": "Multi-agent team system for Pi — DAG orchestration, leader inbox, and one-way worker reports",
   "keywords": [
     "pi-package",
@@ -22,6 +22,7 @@
     "access": "public"
   },
   "files": [
+    "index.ts",
     "src",
     "agents",
     ".memory",
@@ -34,10 +35,10 @@
   },
   "pi": {
     "extensions": [
-      "./src/index.ts"
+      "./index.ts"
     ]
   },
   "dependencies": {
-    "@fradser/pi-kit": "0.1.0"
+    "@fradser/pi-kit": "0.1.1"
   }
 }

package/src/run-machine.ts

@@ -2,25 +2,23 @@
 
 import { randomUUID } from "node:crypto";
 import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
-import { truncateTail, DEFAULT_MAX_BYTES, DEFAULT_MAX_LINES } from "@earendil-works/pi-coding-agent";
 import { resolveAgent } from "./agents";
 import { isWorkerEvent } from "./worker";
 import {
   cancelBlockedDependents, cancelNode, cancelRun, clearWorkerRunEvents, clearStateDirty, isStateDirty,
-  deliverToLeader, failRunTimeout, findSharedWorkspaceWriteConflict, getNode, getNodeByWorkerKey,
+  deliverToLeader, failRunTimeout, findSharedWorkspaceWriteConflict, getNode,
   getRun, getState, listNodes, listRuns, markNodeRunning, markStateDirty,
-  readyPendingNodes, receiveWorkerMessage, retryRun, runningNodeCount, settleRun, setNodeSpawnInfo,
+  readyPendingNodes, receiveWorkerMessage, runningNodeCount, settleRun, setNodeSpawnInfo,
   SUMMARY_NODE_ID, updateNodeSpawnProgress, updateNodeStatus,
 } from "./state";
 import {
   CancellationIntents, buildAutonomousPrompt, finishReportedWorker, isCompletedWorkerExit,
-  POST_REPORT_GRACE_MS, spawnPiWorker, terminateAllWorkers, terminateWorker,
+  POST_REPORT_GRACE_MS, spawnPiWorker, terminateWorker,
   type WorkerProcessResult,
 } from "./spawner";
 import { buildNodeTerminalResult } from "./terminal";
 import { captureWorktreeDiff, cleanupWorktree, createWorktree, discardWorktree } from "./worktree";
 import { readWorkerEvents, removeWorkerOutbox, stateFilePath, workerOutboxPath, writeStateFile } from "./statefile";
-import type { Run } from "./types";
 
 export interface DispatchCtx {
   ui: ExtensionContext["ui"];
@@ -184,7 +182,7 @@ function enforceRunTimeouts(): void {
       const node = getNode(run.id, nodeId);
       if (node) void terminateWorker(node.workerKey).catch(() => false);
     }
-    onRunSettled(run.id, machineCtx);
+    onRunSettled(run.id);
     // failRunTimeout clears spawns, so those nodes' close events skip their
     // finalize path — release write-deferred nodes in OTHER runs here.
     if (machineCtx) scheduleAllRuns(machineCtx);
@@ -194,10 +192,6 @@ function enforceRunTimeouts(): void {
 
 // ── Run dispatch machinery ────────────────────────────────────────
 
-function sleep(ms: number): Promise<void> {
-  return new Promise((resolve) => setTimeout(resolve, ms));
-}
-
 /** Compact run summary for tool returns and follow-ups. When the run has a
  * synthesized __summary node result, that is shown instead of per-node
  * headlines (no truncation heuristics). */
@@ -231,14 +225,13 @@ export function buildRunSummary(runId: string): string {
   for (const node of nodes) {
     lines.push(`- [${node.id}] ${node.status} (${node.agent})`);
   }
-  lines.push("", "Console: /teammate");
   return lines.join("\n");
 }
 
 /** Called once a run reaches a terminal status. Idempotent: the leader summary
  * and follow-up fire only on the first settled observation (a run can transition
  * through settleRun once per node close). */
-export function onRunSettled(runId: string, ctx?: DispatchCtx): void {
+export function onRunSettled(runId: string): void {
   const run = getRun(runId);
   if (!run) return;
   if (run.settledMessageSent) return;
@@ -266,7 +259,7 @@ export function scheduleRun(runId: string, ctx: DispatchCtx): void {
   if (!run || run.status !== "running") return;
   const settled = settleRun(runId);
   if (settled !== "running") {
-    onRunSettled(runId, ctx);
+    onRunSettled(runId);
     return;
   }
   const sessionBudget = MAX_SESSION_WORKERS - listNodes().filter((node) => node.status === "running").length;
@@ -346,7 +339,7 @@ export async function cancelRunAndTerminate(
     cancellationIntents.resolve(spawnId, terminated);
   }
   publishStateSnapshot();
-  onRunSettled(runId, ctx);
+  onRunSettled(runId);
   scheduleAllRuns(ctx);
   notifyChange();
   return { ok: true };

package/src/spawner.ts

@@ -152,10 +152,68 @@ export class CancellationIntents {
 /** Live workers by teammate name — lets the panel interrupt/stop a running worker. */
 const workers = new Map<string, ReturnType<typeof spawn>>();
 
+export interface WorkerTimeoutHandle {
+  cancel(): void;
+  dispose(): void;
+  wasCancelled(): boolean;
+  didTimeout(): boolean;
+}
+
+const workerTimeouts = new WeakMap<ReturnType<typeof spawn>, WorkerTimeoutHandle>();
+
 function isChildRunning(child: ReturnType<typeof spawn>): boolean {
   return child.exitCode === null && child.signalCode === null;
 }
 
+export function registerWorkerTimeout(
+  child: ReturnType<typeof spawn>,
+  timeoutMs: number,
+): WorkerTimeoutHandle {
+  let cancelled = false;
+  let disposed = false;
+  let timedOut = false;
+  let timer: ReturnType<typeof setTimeout> | undefined;
+
+  const handle: WorkerTimeoutHandle = {
+    cancel() {
+      if (disposed) return;
+      cancelled = true;
+      if (timer) clearTimeout(timer);
+      disposed = true;
+      workerTimeouts.delete(child);
+    },
+    dispose() {
+      if (disposed) return;
+      if (timer) clearTimeout(timer);
+      disposed = true;
+      workerTimeouts.delete(child);
+    },
+    wasCancelled: () => cancelled,
+    didTimeout: () => timedOut,
+  };
+
+  timer = setTimeout(() => {
+    if (disposed || cancelled) return;
+    if (!isChildRunning(child)) {
+      handle.dispose();
+      return;
+    }
+    try {
+      if (child.kill("SIGKILL")) timedOut = true;
+    } catch {
+      // A failed kill is not a timeout outcome; close/error will report the
+      // actual child result.
+    }
+  }, timeoutMs);
+  timer.unref?.();
+  workerTimeouts.set(child, handle);
+  return handle;
+}
+
+export function cancelWorkerTimeout(child: ReturnType<typeof spawn>): void {
+  workerTimeouts.get(child)?.cancel();
+}
+
 function waitForClose(child: ReturnType<typeof spawn>, timeoutMs: number): Promise<boolean> {
   return new Promise((resolve) => {
     let settled = false;
@@ -180,6 +238,7 @@ function waitForClose(child: ReturnType<typeof spawn>, timeoutMs: number): Promi
  * resolve only after a bounded wait observes the child `close` event.
  */
 export async function terminateChildProcess(child: ReturnType<typeof spawn>, graceMs = CANCEL_GRACE_MS): Promise<boolean> {
+  cancelWorkerTimeout(child);
   if (!isChildRunning(child)) return false;
 
   const closedAfterTerm = waitForClose(child, graceMs);
@@ -431,7 +490,17 @@ export function spawnPiWorker(options: SpawnPiWorkerOptions): SpawnedWorker | {
   // resolvePiCli always resolves (worst case a "pi" binary on PATH); a missing
   // binary surfaces later as a child "error" event through onError.
   const cli = resolvePiCli();
-  const args: string[] = [...cli.args, "--print", "--mode", "json", "--no-session"];
+  const workerExtension = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "index.ts");
+  const args: string[] = [
+    ...cli.args,
+    "--print",
+    "--mode",
+    "json",
+    "--no-session",
+    "--no-extensions",
+    "--extension",
+    workerExtension,
+  ];
   if (options.model) args.push("--model", options.model);
   // Capability tools cannot be removed; execution tools are selected by the
   // leader from the teammate's explicit configuration or role default.
@@ -487,7 +556,7 @@ export function spawnPiWorker(options: SpawnPiWorkerOptions): SpawnedWorker | {
   const stderrChunks: string[] = [];
   const streamState = createWorkerStreamState();
   let stdoutBuffer = "";
-  let timedOut = false;
+  let timeoutHandle: WorkerTimeoutHandle | undefined;
   let settled = false;
   const emitProgress = () => options.onUpdate?.({
     text: truncate(streamState.text, OUTPUT_CAP),
@@ -508,17 +577,12 @@ export function spawnPiWorker(options: SpawnPiWorkerOptions): SpawnedWorker | {
   });
   child.stderr.on("data", (chunk: Buffer) => stderrChunks.push(chunk.toString()));
 
-  let timer: ReturnType<typeof setTimeout> | undefined;
   if (options.timeoutMs) {
-    timer = setTimeout(() => {
-      timedOut = true;
-      child.kill("SIGKILL");
-    }, options.timeoutMs);
-    timer.unref?.();
+    timeoutHandle = registerWorkerTimeout(child, options.timeoutMs);
   }
 
   child.on("error", (error) => {
-    if (timer) clearTimeout(timer);
+    timeoutHandle?.dispose();
     cleanupTempDir();
     settled = true;
     if (options.workerName && workers.get(options.workerName) === child) workers.delete(options.workerName);
@@ -526,7 +590,8 @@ export function spawnPiWorker(options: SpawnPiWorkerOptions): SpawnedWorker | {
   });
 
   child.on("close", (code, signal) => {
-    if (timer) clearTimeout(timer);
+    const timedOut = timeoutHandle?.didTimeout() ?? false;
+    timeoutHandle?.dispose();
     cleanupTempDir();
     // A spawn failure already reported via onError (Node fires error then
     // close) — do not double-report through onExit, which would let a failed