@fradser/pi-agent-teams 0.5.0 → 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.0",
+  "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,7 +35,10 @@
   },
   "pi": {
     "extensions": [
-      "./src/index.ts"
+      "./index.ts"
     ]
+  },
+  "dependencies": {
+    "@fradser/pi-kit": "0.1.1"
   }
 }

package/src/index.ts

@@ -1,5 +1,5 @@
 /**
- * @fradser/pi-agent-teams — Pi extension for run-centric agent teams.
+ * pi-agent-teams-fradser — Pi extension for run-centric agent teams.
  *
  * The entry point is composition only: worker capability registration,
  * session lifecycle, and delegation to tools.ts. Scheduling lives in

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

@@ -12,6 +12,7 @@ import * as fs from "node:fs";
 import * as os from "node:os";
 import * as path from "node:path";
 import { fileURLToPath } from "node:url";
+import { extractTextContent } from "@fradser/pi-kit";
 import type { WorkerUsage } from "./types";
 
 /**
@@ -151,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;
@@ -179,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);
@@ -307,10 +367,7 @@ function applyWorkerJsonLine(state: WorkerStreamState, line: string): boolean {
     if (event.type !== "message_end" || event.message?.role !== "assistant") return false;
     state.turns++;
     if (event.message.stopReason === "stop") state.finalResponse = true;
-    const parts = (event.message.content ?? [])
-      .filter((part) => part.type === "text" && typeof part.text === "string")
-      .map((part) => part.text as string)
-      .join("");
+    const parts = extractTextContent(event.message.content, "");
     if (parts.trim()) state.text = parts;
     const u = event.message.usage;
     if (u) {
@@ -433,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.
@@ -489,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),
@@ -510,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);
@@ -528,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

package/src/ui.ts

@@ -1,6 +1,7 @@
 /** Passive teammate widget and interactive full-screen console. */
 
 import { truncateToWidth, Key, matchesKey } from "@earendil-works/pi-tui";
+import { createPiThemeStyle, PI_SPINNER_FRAMES, PI_SPINNER_INTERVAL_MS } from "@fradser/pi-kit";
 import type { ExtensionUIContext, Theme, ThemeColor } from "@earendil-works/pi-coding-agent";
 import { truncateTail, DEFAULT_MAX_BYTES, DEFAULT_MAX_LINES } from "@earendil-works/pi-coding-agent";
 import {
@@ -23,8 +24,6 @@ function cap(text: string | undefined, maxBytes = DEFAULT_MAX_BYTES): string {
 
 const TEAM_COLORS = ["accent", "success", "warning", "error", "toolTitle", "mdLink"] as const;
 const PANEL_IDLE_COLLAPSE_MS = 30_000;
-const SPINNER_FRAMES = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
-const SPINNER_MS = 120;
 
 let panelRequestRender: (() => void) | undefined;
 let spinnerTimer: ReturnType<typeof setInterval> | undefined;
@@ -50,7 +49,7 @@ function buildPanelRows(): PanelRow[] {
 }
 
 function runningTeammateLabel(node: Node): string {
-  const frame = SPINNER_FRAMES[spinnerFrame];
+  const frame = PI_SPINNER_FRAMES[spinnerFrame];
   const tool = node.spawn?.activeTool;
   const thinking = (node.spawn?.liveThinking ?? "").split("\n").map((l) => l.trim()).find((l) => l.length > 0) ?? "";
   const live = (node.spawn?.liveText ?? "").split("\n").map((l) => l.trim()).find((l) => l.length > 0) ?? "";
@@ -71,9 +70,9 @@ function ensureSpinner(): void {
   const running = listNodes().some((node) => node.status === "running");
   if (running && !spinnerTimer) {
     spinnerTimer = setInterval(() => {
-      spinnerFrame = (spinnerFrame + 1) % SPINNER_FRAMES.length;
+      spinnerFrame = (spinnerFrame + 1) % PI_SPINNER_FRAMES.length;
       panelRequestRender?.();
-    }, SPINNER_MS);
+    }, PI_SPINNER_INTERVAL_MS);
     spinnerTimer.unref?.();
   } else if (!running && spinnerTimer) {
     clearInterval(spinnerTimer);
@@ -245,7 +244,7 @@ export function openTeamConsole(ctx: { ui: ExtensionUIContext }): Promise<void>
     };
     const startLiveRefresh = () => {
       if (renderTimer) return;
-      renderTimer = setInterval(requestRender, SPINNER_MS);
+      renderTimer = setInterval(requestRender, PI_SPINNER_INTERVAL_MS);
       renderTimer.unref?.();
     };
     const stopLiveRefresh = () => {
@@ -255,15 +254,8 @@ export function openTeamConsole(ctx: { ui: ExtensionUIContext }): Promise<void>
     };
     startLiveRefresh();
 
-    // btw-style callbacks (same accent/muted/dim/border/success/error language as @fradser/pi-btw).
-    const style = {
-      accent: (s: string) => theme.fg("accent", s),
-      muted: (s: string) => theme.fg("muted", s),
-      dim: (s: string) => theme.fg("dim", s),
-      border: (s: string) => theme.fg("border", s),
-      success: (s: string) => theme.fg("success", s),
-      error: (s: string) => theme.fg("error", s),
-    };
+    // btw-style callbacks (same accent/muted/dim/border/success/error language as pi-btw-fradser).
+    const style = createPiThemeStyle(theme);
 
     const windowLines = (full: string[], width: number): { lines: string[]; range: string } => {
       const wrapped = wrapConsoleDetail(full, width);
@@ -341,7 +333,7 @@ export function openTeamConsole(ctx: { ui: ExtensionUIContext }): Promise<void>
           }
           const detail = wrapConsoleDetail(buildNodeDetail(detailKey), tui.terminal.columns);
           const viewport = maxConsoleBody(tui.terminal.rows);
-          // Mouse-wheel scrolling (SGR wheel events, same as @fradser/pi-btw).
+          // Mouse-wheel scrolling (SGR wheel events, same as pi-btw-fradser).
           const sgrWheel = /^\x1b\[<(\d+);(\d+);(\d+)[Mm]$/.exec(data);
           if (sgrWheel) {
             const button = Number.parseInt(sgrWheel[1], 10);