pi-agent-fleet 0.6.0 → 0.7.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-agent-fleet",
-  "version": "0.6.0",
+  "version": "0.7.1",
   "description": "DAG-of-agents fleets for pi — parallel workers with contracts, reviewer-gated iteration loops, and live progress",
   "type": "module",
   "scripts": {

package/src/canvas-client.tsx

@@ -90,6 +90,9 @@ function minimapColor(status: string): string {
   if (status === "killed" || status === "blocked") return cssVar("--wire");
   return cssVar("--line");
 }
+function shortModel(model: string): string {
+  return model.split("/").pop()?.replace(/^deepseek-/, "") || model;
+}
 function j<T>(u: string): Promise<T> {
   return fetch(u).then((r) => {
     if (!r.ok) throw new Error(String(r.status));
@@ -103,6 +106,7 @@ type FleetNodeData = {
   selected: boolean;
   demo: boolean;
   gate: boolean;
+  nodeRole: "start" | "end" | "gate" | "normal";
   fleet: string | null;
   onOpen: (id: string) => void;
 };
@@ -110,6 +114,7 @@ type FleetNodeData = {
 function FleetNode({ data }: NodeProps<Node<FleetNodeData>>) {
   const { view: n, selected } = data;
   const running = n.status === "running";
+  const roleLabel = data.nodeRole === "start" ? "START" : data.nodeRole === "end" ? "END" : data.nodeRole === "gate" ? "GATE" : null;
 
   const flags: Array<{ label: string; title: string }> = [];
   if (data.gate) flags.push({ label: "⟳ loop gate", title: "Reviewer gate: its verdict decides whether the fleet iterates again" });
@@ -129,7 +134,7 @@ function FleetNode({ data }: NodeProps<Node<FleetNodeData>>) {
 
   return (
     <div
-      className={"node " + statusClass(n.status) + (selected ? " sel" : "")}
+      className={"node " + statusClass(n.status) + " role-" + data.nodeRole + (selected ? " sel" : "")}
       data-node-id={n.id}
       role="button"
       tabIndex={0}
@@ -138,28 +143,28 @@ function FleetNode({ data }: NodeProps<Node<FleetNodeData>>) {
       onClick={activate}
       onKeyDown={(e) => { if (e.key === "Enter" || e.key === " ") { e.preventDefault(); activate(); } }}
     >
-      <Handle type="target" position={Position.Top} />
-      <Handle type="target" position={Position.Top} id="loopIn" />
+      <Handle type="target" position={Position.Left} />
+      <Handle type="target" position={Position.Bottom} id="loopIn" />
       <div className="card-body">
         <div className="node-header">
           <span className={"node-dot" + (running ? " pulse" : "")} style={{ background: minimapColor(n.status) }} aria-hidden="true" />
           <span className="id" title={n.id}>{n.id}</span>
+          {roleLabel && <span className="role-badge">{roleLabel}</span>}
           <span className="badge">{n.type}</span>
         </div>
         <div className="status-row">
           {running && <span className="spinner" />}
           <span className="st-word">{n.status}</span>
           {n.effort && <><span>·</span><span>{n.effort}</span></>}
-          <span>·</span><span>{n.model}</span>
+          <span>·</span><span title={n.model}>{shortModel(n.model)}</span>
         </div>
         <div className="stats">
           {(n.turns | 0)} turns · {(Number(n.tokens || 0) / 1000).toFixed(1)}k tok · ${Number(n.cost_usd_estimate || 0).toFixed(2)}
         </div>
         {n.outputs?.length > 0 && (
           <div className="outputs">
-            {n.outputs.map((o, i) => (
-              <span className="out-chip" key={i}>{o.path} · {o.kind}</span>
-            ))}
+            <span className="out-count" title={n.outputs.map((o) => `${o.path} · ${o.kind}`).join("\n")}>{n.outputs.length} output{n.outputs.length === 1 ? "" : "s"}</span>
+            <span className="out-chip">{n.outputs[0].kind}</span>
           </div>
         )}
         {flags.length > 0 && (
@@ -172,7 +177,7 @@ function FleetNode({ data }: NodeProps<Node<FleetNodeData>>) {
         {n.status_note && <div className="note nodrag">{n.status_note}</div>}
         {failReason && <div className="fail-reason nodrag">{failReason}</div>}
       </div>
-      <Handle type="source" position={Position.Bottom} />
+      <Handle type="source" position={Position.Right} />
       <Handle type="source" position={Position.Bottom} id="loop" />
     </div>
   );
@@ -573,12 +578,14 @@ function Flow() {
     const gateId = payload.loop
       ? (payload.nodes.find((n) => n.id === payload.loop!.gate) ?? payload.nodes.find((n) => n.type === payload.loop!.gate))?.id
       : undefined;
+    const hasOutgoing = new Set(payload.edges.map((e) => e.from));
     setNodes((prev) => {
       const byId: Record<string, Node<FleetNodeData>> = {};
       prev.forEach((n) => { byId[n.id] = n; });
       return payload.nodes.map((v) => {
         const existing = byId[v.id];
-        const data: FleetNodeData = { view: v, selected: selected === v.id, demo, gate: v.id === gateId, fleet, onOpen };
+        const nodeRole: FleetNodeData["nodeRole"] = v.id === gateId ? "gate" : v.depends_on.length === 0 ? "start" : !hasOutgoing.has(v.id) ? "end" : "normal";
+        const data: FleetNodeData = { view: v, selected: selected === v.id, demo, gate: v.id === gateId, nodeRole, fleet, onOpen };
         return existing
           ? { ...existing, data }
           : { id: v.id, type: "fleet", position: pos[v.id] ?? { x: 0, y: 0 }, data, width: NODE_W };
@@ -593,7 +600,11 @@ function Flow() {
       id: "e" + i,
       source: e.from,
       target: e.to,
+      type: "smoothstep",
+      pathOptions: { borderRadius: 18 },
       animated: payload.nodes.find((n) => n.id === e.to)?.status === "running",
+      style: { strokeWidth: 1.6 },
+      markerEnd: { type: MarkerType.ArrowClosed, color: "var(--edge)" } as Edge["markerEnd"],
     }));
 
     // feedback loop: the gate node re-triggers the iterate roots each iteration

package/src/canvas-layout.ts

@@ -1,12 +1,26 @@
-export const NODE_W = 284;
-export const NODE_H_GAP = 200;
-export const NODE_W_GAP = 40;
+export const NODE_W = 304;
+export const NODE_H_GAP = 44;
+export const NODE_W_GAP = 156;
+
+export interface LayoutNode {
+  id: string;
+  type?: string;
+  outputs?: Array<unknown>;
+  depends_on?: string[];
+}
 
 export function excerptText(text: string, max: number): { excerpt: string; truncated: boolean } {
   const truncated = text.length > max;
   return { excerpt: truncated ? text.slice(0, max) + "…" : text, truncated };
 }
 
+export function estimateNodeHeight(node: LayoutNode): number {
+  const outputs = node.outputs?.length ?? 0;
+  const outputRows = outputs > 0 ? 1 : 0;
+  const gateRow = node.type === "reviewer" ? 18 : 0;
+  return 126 + outputRows * 26 + gateRow;
+}
+
 export function topoLayers(ids: string[], edges: Array<{ from: string; to: string }>): string[][] {
   const indeg: Record<string, number> = {};
   const nextById: Record<string, string[]> = {};
@@ -64,20 +78,69 @@ export function reduceCrossings(layers: string[][], edges: Array<{ from: string;
   return ordered;
 }
 
+function longestPathStages(ids: string[], edges: Array<{ from: string; to: string }>): string[][] {
+  const indeg: Record<string, number> = {};
+  const nextById: Record<string, string[]> = {};
+  const rank: Record<string, number> = {};
+  for (const id of ids) {
+    indeg[id] = 0;
+    nextById[id] = [];
+    rank[id] = 0;
+  }
+  for (const edge of edges) {
+    if (!(edge.from in indeg) || !(edge.to in indeg)) continue;
+    indeg[edge.to]++;
+    nextById[edge.from].push(edge.to);
+  }
+
+  const queue = ids.filter((id) => indeg[id] === 0);
+  const seen = new Set<string>();
+  for (let qi = 0; qi < queue.length; qi++) {
+    const id = queue[qi];
+    seen.add(id);
+    for (const to of nextById[id]) {
+      rank[to] = Math.max(rank[to], rank[id] + 1);
+      indeg[to]--;
+      if (indeg[to] === 0) queue.push(to);
+    }
+  }
+  for (const id of ids) {
+    if (!seen.has(id)) rank[id] = Math.max(...Object.values(rank), 0) + 1;
+  }
+
+  const rightmost = Math.max(...Object.values(rank), 0);
+  const hasOutgoing = new Set(edges.filter((edge) => edge.from in rank && edge.to in rank).map((edge) => edge.from));
+  for (const id of ids) {
+    if (!hasOutgoing.has(id)) rank[id] = rightmost;
+  }
+
+  const stages: string[][] = [];
+  for (const id of ids) (stages[rank[id]] ??= []).push(id);
+  return stages.filter(Boolean);
+}
+
 export function computePositions(
-  nodes: Array<{ id: string }>,
+  nodes: LayoutNode[],
   edges: Array<{ from: string; to: string }>,
 ): Record<string, { x: number; y: number }> {
-  const layers = reduceCrossings(topoLayers(nodes.map((node) => node.id), edges), edges);
-  const maxLayerLen = layers.reduce((max, layer) => Math.max(max, layer.length), 0);
+  const byId = Object.fromEntries(nodes.map((node) => [node.id, node]));
+  const stages = reduceCrossings(longestPathStages(nodes.map((node) => node.id), edges), edges);
   const stepX = NODE_W + NODE_W_GAP;
+  const heights = Object.fromEntries(nodes.map((node) => [node.id, estimateNodeHeight(node)]));
+  const stageHeights = stages.map((stage) => stage.reduce((sum, id, i) => sum + heights[id] + (i ? NODE_H_GAP : 0), 0));
+  const maxStageHeight = Math.max(...stageHeights, 0);
   const pos: Record<string, { x: number; y: number }> = {};
 
-  layers.forEach((layer, li) => {
-    const xOffset = ((maxLayerLen - layer.length) * stepX) / 2;
-    layer.forEach((id, ni) => {
-      pos[id] = { x: xOffset + ni * stepX, y: li * NODE_H_GAP };
+  stages.forEach((stage, si) => {
+    let y = Math.max(0, (maxStageHeight - stageHeights[si]) / 2);
+    stage.forEach((id) => {
+      const node = byId[id];
+      const fan = edges.filter((edge) => edge.from === id || edge.to === id).length;
+      const repel = Math.min(fan * 3, 24);
+      pos[id] = { x: si * stepX, y };
+      y += estimateNodeHeight(node) + NODE_H_GAP + repel;
     });
   });
+
   return pos;
 }

package/src/canvas.ts

@@ -508,6 +508,15 @@ export interface SessionTailView {
   events: TimelineEvent[];
 }
 
+function compactToolArguments(value: unknown): unknown {
+  if (typeof value === "string") return value.length > 1000 ? `[omitted ${value.length} chars]` : value;
+  if (Array.isArray(value)) return value.map(compactToolArguments);
+  if (value && typeof value === "object") {
+    return Object.fromEntries(Object.entries(value).map(([k, v]) => [k, compactToolArguments(v)]));
+  }
+  return value;
+}
+
 export function parseSessionTail(jsonl: string, maxEntries: number): SessionTailView {
   const events: TimelineEvent[] = [];
   const entries: SessionEntryView[] = [];
@@ -545,9 +554,10 @@ export function parseSessionTail(jsonl: string, maxEntries: number): SessionTail
       if (p.type === "text" && typeof p.text === "string") parts.push(p.text);
       else if ((p.type === "toolCall" || p.type === "tool_call") && typeof p.name === "string") {
         parts.push(`[tool: ${p.name}]`);
-        const a: ActionView = { type: "tool_call", name: p.name, arguments: p.arguments, timestamp: ts };
+        const args = compactToolArguments(p.arguments) as Record<string, unknown> | undefined;
+        const a: ActionView = { type: "tool_call", name: p.name, arguments: args, timestamp: ts };
         actions.push(a);
-        events.push({ type: "tool_call", name: p.name, arguments: p.arguments, timestamp: ts });
+        events.push({ type: "tool_call", name: p.name, arguments: args, timestamp: ts });
       } else if (p.type === "toolResult" || p.type === "tool_result") {
         parts.push("[tool result]");
         const a: ActionView = { type: "tool_result", toolName: typeof p.toolName === "string" ? p.toolName : p.name, isError: p.isError, timestamp: ts };
@@ -649,8 +659,8 @@ function readFileSyncSafe(p: string): string {
 }
 
 const PAGE_CSS = `
-:root { color-scheme: dark; --bg:#0d1117; --fg:#c9d1d9; --muted:#8b949e; --line:#30363d; --panel:#1a2029; --panel-2:#212936; --stage-bg:#0a0c10; --accent:#58a6ff; --ok:#3fb950; --bad:#f85149; --warn:#d29922; --wire:#6e7681; --hdr:#f0f6fc; --card-shadow:0 1px 2px rgba(0,0,0,0.5), 0 10px 24px -8px rgba(0,0,0,0.65); --card-shadow-lg:0 2px 4px rgba(0,0,0,0.5), 0 16px 36px -10px rgba(0,0,0,0.75); --edge:#4a5361; --edge-soft:#363d49; --mm-mask:rgba(8,10,14,0.55); --mm-frame:rgba(255,255,255,0.14); }
-[data-theme="light"] { color-scheme: light; --bg:#f6f8fa; --fg:#1f2328; --muted:#57606a; --line:#d0d7de; --panel:#ffffff; --panel-2:#f6f8fa; --stage-bg:#eef1f5; --accent:#0969da; --ok:#1a7f37; --bad:#cf222e; --warn:#9a6700; --wire:#8c959f; --hdr:#1f2328; --card-shadow:0 1px 2px rgba(15,23,42,0.08), 0 10px 24px -8px rgba(15,23,42,0.18); --card-shadow-lg:0 2px 4px rgba(15,23,42,0.10), 0 16px 36px -10px rgba(15,23,42,0.24); --edge:#b5bdc9; --edge-soft:#d0d7de; --mm-mask:rgba(15,23,42,0.10); --mm-frame:rgba(9,105,218,0.35); }
+:root { color-scheme: dark; --bg:#0d1117; --fg:#c9d1d9; --muted:#8b949e; --line:#30363d; --panel:#171d26; --panel-2:#212936; --stage-bg:#0a0c10; --accent:#58a6ff; --ok:#3fb950; --bad:#f85149; --warn:#d29922; --wire:#6e7681; --hdr:#f0f6fc; --card-shadow:0 1px 2px rgba(0,0,0,0.42), 0 12px 28px -12px rgba(0,0,0,0.72); --card-shadow-lg:0 2px 4px rgba(0,0,0,0.5), 0 18px 42px -14px rgba(0,0,0,0.78); --edge:#4a5361; --edge-soft:#363d49; --mm-mask:rgba(8,10,14,0.55); --mm-frame:rgba(255,255,255,0.14); }
+[data-theme="light"] { color-scheme: light; --bg:#f6f8fa; --fg:#1f2328; --muted:#57606a; --line:#d8dee7; --panel:#ffffff; --panel-2:#f6f8fa; --stage-bg:#f2f5f9; --accent:#0969da; --ok:#1a7f37; --bad:#cf222e; --warn:#9a6700; --wire:#8c959f; --hdr:#1f2328; --card-shadow:0 1px 2px rgba(15,23,42,0.08), 0 14px 30px -16px rgba(15,23,42,0.26); --card-shadow-lg:0 2px 4px rgba(15,23,42,0.10), 0 18px 44px -16px rgba(15,23,42,0.30); --edge:#aeb8c6; --edge-soft:#d0d7de; --mm-mask:rgba(15,23,42,0.10); --mm-frame:rgba(9,105,218,0.35); }
 :root { --ui:system-ui, -apple-system, "Segoe UI", Roboto, Helvetica, Arial, sans-serif; --mono:"SF Mono", "JetBrains Mono", Menlo, Consolas, monospace; }
 * { box-sizing:border-box; }
 html,body,#root { margin:0; height:100%; }
@@ -687,43 +697,60 @@ button:hover, select:hover { border-color:var(--accent); }
 .taskbox-side-label { font-size:11px; color:var(--muted); text-transform:uppercase; letter-spacing:0.04em; margin-bottom:4px; }
 main { display:flex; flex:1 1 auto; min-height:0; }
 #stage { flex:1; position:relative; min-width:0; background:var(--stage-bg); }
-.react-flow { background:var(--stage-bg); }
-.react-flow__node { width:284px; }
+.react-flow { background:radial-gradient(circle at 1px 1px, color-mix(in srgb, var(--muted) 18%, transparent) 1px, transparent 0) 0 0/24px 24px, var(--stage-bg); }
+.react-flow__node { width:304px; }
 .react-flow__handle { width:6px; height:6px; background:var(--wire); border:none; opacity:0; }
-.react-flow__edge-path { stroke:var(--edge); stroke-width:1.5; stroke-linecap:round; stroke-linejoin:round; }
-.react-flow__edge:hover .react-flow__edge-path { stroke:var(--accent); stroke-width:2; }
-.react-flow__edge.animated .react-flow__edge-path { stroke:var(--accent); stroke-width:2; stroke-dasharray:1 7; animation:dashflow 0.7s linear infinite; }
-@keyframes dashflow { to { stroke-dashoffset:-16; } }
+.react-flow__edge-path { stroke:var(--edge); stroke-width:1.6; stroke-linecap:round; stroke-linejoin:round; opacity:0.56; }
+.react-flow__edge:hover .react-flow__edge-path { stroke:var(--accent); stroke-width:2.2; opacity:0.95; }
+.react-flow__edge.animated .react-flow__edge-path { stroke:var(--accent); stroke-width:2.2; stroke-dasharray:1 8; opacity:0.95; animation:dashflow 0.7s linear infinite; }
+@keyframes dashflow { to { stroke-dashoffset:-18; } }
 .react-flow__controls button { background:var(--panel); color:var(--fg); border-bottom:1px solid var(--line); fill:var(--fg); }
 .react-flow__minimap { width:172px; height:112px; background:var(--panel); border-radius:12px; box-shadow:var(--card-shadow); overflow:hidden; }
 .react-flow__minimap svg { border-radius:10px; }
 .react-flow__minimap-mask { fill:var(--mm-mask) !important; stroke:none; }
 .react-flow__minimap-node { stroke:var(--panel) !important; stroke-width:4px !important; rx:3; ry:3; }
 .react-flow__attribution { display:none; }
-.node { position:relative; width:284px; border-radius:12px; background:var(--panel); cursor:pointer; box-shadow:var(--card-shadow); transition:box-shadow 0.18s ease, transform 0.18s ease; }
+.node { position:relative; width:304px; border-radius:14px; background:var(--panel); cursor:pointer; box-shadow:var(--card-shadow); overflow:hidden; transition:box-shadow 0.18s ease, transform 0.18s ease, background 0.18s ease; }
+.node::before { content:""; position:absolute; left:0; top:0; bottom:0; width:3px; background:var(--wire); opacity:0.7; }
 .node:hover { box-shadow:var(--card-shadow-lg); transform:translateY(-2px); }
-.node.sel { background:color-mix(in srgb, var(--accent) 14%, var(--panel)); box-shadow:var(--card-shadow-lg); transform:translateY(-2px); }
-.node.sel.st-failed, .node.sel.st-contract_failed { background:color-mix(in srgb, var(--bad) 14%, var(--panel)); }
+.node.sel { background:color-mix(in srgb, var(--accent) 12%, var(--panel)); box-shadow:var(--card-shadow-lg); transform:translateY(-2px); }
+.node.sel.st-failed, .node.sel.st-contract_failed { background:color-mix(in srgb, var(--bad) 12%, var(--panel)); }
 /* keyboard focus ring only — never on mouse click */
 .node:focus:not(:focus-visible) { outline:none; }
-.node.st-running { background:color-mix(in srgb, var(--accent) 10%, var(--panel)); }
-.node.st-failed, .node.st-contract_failed { background:color-mix(in srgb, var(--bad) 11%, var(--panel)); }
-.card-body { padding:13px 14px; }
+.node.st-running { background:color-mix(in srgb, var(--accent) 8%, var(--panel)); }
+.node.st-completed::before { background:var(--ok); }
+.node.st-running::before { background:var(--accent); }
+.node.st-failed::before, .node.st-contract_failed::before { background:var(--bad); }
+.node.st-pending::before, .node.st-ready::before { background:var(--line); }
+.node.role-start { box-shadow:var(--card-shadow), inset 0 0 0 1px color-mix(in srgb, var(--ok) 24%, transparent); }
+.node.role-end { box-shadow:var(--card-shadow), inset 0 0 0 1px color-mix(in srgb, var(--accent) 24%, transparent); }
+.node.role-gate { box-shadow:var(--card-shadow), inset 0 0 0 1px color-mix(in srgb, var(--warn) 38%, transparent); }
+.node.role-start::after, .node.role-end::after, .node.role-gate::after { content:""; position:absolute; inset:auto 12px 0 12px; height:1px; background:linear-gradient(90deg, transparent, color-mix(in srgb, var(--accent) 45%, transparent), transparent); opacity:0.75; }
+.node.role-start::after { background:linear-gradient(90deg, transparent, color-mix(in srgb, var(--ok) 45%, transparent), transparent); }
+.node.role-gate::after { background:linear-gradient(90deg, transparent, color-mix(in srgb, var(--warn) 55%, transparent), transparent); }
+.node.st-failed, .node.st-contract_failed { background:color-mix(in srgb, var(--bad) 9%, var(--panel)); }
+.card-body { padding:15px 16px 14px 17px; }
 .node-header { display:flex; align-items:center; gap:7px; }
 .node-dot { width:8px; height:8px; border-radius:50%; flex-shrink:0; }
 .node-dot.pulse { animation:pulse 1.6s ease-in-out infinite; }
 .node-header .id { flex:1; }
 .node-header .badge { margin-left:auto; }
-.id { font-weight:700; font-size:16px; letter-spacing:-0.01em; color:var(--hdr); overflow:hidden; text-overflow:ellipsis; white-space:nowrap; }
-.badge { font-size:11px; padding:1px 7px; border:1px solid var(--line); border-radius:10px; color:var(--muted); white-space:nowrap; }
-.status-row { margin-top:7px; display:flex; align-items:center; gap:6px; font-size:13px; color:var(--muted); }
-.status-row .st-word { color:var(--fg); font-weight:600; }
+.id { font-weight:760; font-size:16px; letter-spacing:-0.02em; color:var(--hdr); overflow:hidden; text-overflow:ellipsis; white-space:nowrap; }
+.badge, .role-badge { font-size:11px; padding:1px 7px; border:1px solid var(--line); border-radius:10px; color:var(--muted); white-space:nowrap; background:color-mix(in srgb, var(--panel-2) 70%, transparent); }
+.role-badge { font-weight:700; letter-spacing:0.04em; color:var(--fg); }
+.role-start .role-badge { border-color:color-mix(in srgb, var(--ok) 55%, var(--line)); color:var(--ok); }
+.role-end .role-badge { border-color:color-mix(in srgb, var(--accent) 55%, var(--line)); color:var(--accent); }
+.role-gate .role-badge { border-color:color-mix(in srgb, var(--warn) 60%, var(--line)); color:var(--warn); }
+.status-row { margin-top:9px; display:flex; align-items:center; gap:6px; font-size:13px; color:var(--muted); min-width:0; }
+.status-row span:last-child { overflow:hidden; text-overflow:ellipsis; white-space:nowrap; }
+.status-row .st-word { color:var(--fg); font-weight:650; }
 .spinner { width:10px; height:10px; border:2px solid var(--accent); border-top-color:transparent; border-radius:50%; animation:spin 1s linear infinite; display:inline-block; flex-shrink:0; }
 @keyframes spin { to { transform:rotate(360deg); } }
-.stats { margin-top:4px; font-size:13px; color:var(--muted); }
-.outputs { margin-top:6px; }
-.out-chip { display:inline-block; font-size:11px; line-height:1.5; border:1px solid var(--line); border-radius:8px; padding:5px 8px; margin:4px 4px 0 0; color:var(--muted); background:var(--bg); }
-.flags { margin-top:6px; font-size:11px; color:var(--warn); }
+.stats { margin-top:6px; font-size:13px; color:var(--muted); }
+.outputs { margin-top:10px; display:flex; gap:6px; align-items:center; }
+.out-count, .out-chip { display:inline-block; font-size:11px; line-height:1.45; border:1px solid var(--line); border-radius:8px; padding:4px 8px; color:var(--muted); background:var(--bg); }
+.out-count { color:var(--fg); background:color-mix(in srgb, var(--accent) 8%, var(--bg)); }
+.flags { margin-top:8px; font-size:11px; color:var(--warn); }
 .flags span { cursor:help; }
 .note { margin-top:6px; font-size:13px; color:var(--warn); }
 .note, .fail-reason { user-select:text; cursor:text; }
@@ -750,7 +777,7 @@ main { display:flex; flex:1 1 auto; min-height:0; }
 .timeline { margin-bottom:12px; }
 .timeline-action { background:var(--panel); border-radius:5px; margin-bottom:5px; }
 .timeline-action.open { background:var(--panel-2); }
-.timeline-action.action-error { border-left:3px solid var(--bad); background:color-mix(in srgb, var(--bad) 9%, var(--panel)); }
+.timeline-action.action-error { box-shadow:inset 0 0 0 1px color-mix(in srgb, var(--bad) 40%, transparent); background:color-mix(in srgb, var(--bad) 9%, var(--panel)); }
 .timeline-row { display:flex; align-items:center; gap:8px; padding:5px 8px; font-size:12px; }
 .timeline-row .action-icon { flex-shrink:0; width:34px; text-align:center; color:var(--accent); font-family:var(--mono); font-size:11px; text-transform:uppercase; letter-spacing:0.02em; }
 .timeline-row .action-name { flex-shrink:0; font-weight:600; min-width:48px; font-size:12px; white-space:nowrap; }

package/src/controller.ts

@@ -70,7 +70,37 @@ export async function statusText(fleet: ActiveFleet): Promise<string> {
     : failed ? `next: fleet_relaunch ${failed[0]}`
     : state.status === "completed" ? `next: read report ${reportPath}`
     : `next: inspect ${join(fleet.fleetRoot, "state.json")}`;
-  return `${renderDag(fleet.spec, state)}\n\nreport: ${reportPath}\n${next}`;
+  let crashWarning = "";
+  if (state.status === "running") {
+    const heartbeat = state.heartbeat_at;
+    const stale = !heartbeat || (Date.now() - new Date(heartbeat).getTime() > 60000);
+    if (stale && typeof state.pid === "number") {
+      let dead = false;
+      try {
+        process.kill(state.pid, 0);
+      } catch (e) {
+        if ((e as NodeJS.ErrnoException).code === "ESRCH") dead = true;
+      }
+      if (dead) {
+        crashWarning = `\n\nwarning: fleet appears crashed (stale heartbeat/dead pid ${state.pid}); run fleet_continue to recover`;
+      }
+    }
+  }
+  return `${renderDag(fleet.spec, state)}\n\nreport: ${reportPath}\n${next}${crashWarning}`;
+}
+
+export function checkCostLimits(fleet: ActiveFleet, ctx: ExtensionContext): void {
+  const warn = fleet.spec.config.warn_cost_usd;
+  const cap = fleet.spec.config.max_cost_usd;
+  const cost = fleet.state.cost_usd_estimate;
+  if (warn && !fleet.costWarned && cost >= warn) {
+    fleet.costWarned = true;
+    if (ctx.hasUI) ctx.ui.notify(`fleet cost warning: $${cost.toFixed(4)} >= $${warn}`, "warning");
+  }
+  if (cap && cost >= cap && !fleet.killSwitch.killed) {
+    fleet.killSwitch.killed = true;
+    if (ctx.hasUI) ctx.ui.notify(`fleet cost cap reached: $${cost.toFixed(4)} >= $${cap.toFixed(4)}`, "error");
+  }
 }
 
 export async function dagPreview(spec: FleetSpec, state: FleetState | undefined, fleetRoot: string): Promise<string> {
@@ -180,17 +210,40 @@ export async function startLoop(fleet: ActiveFleet, ctx: ExtensionContext, resum
 
   fleet.running = true;
   fleet.costWarned = false;
-  fleet.state = { ...fleet.state, status: "running" };
+  fleet.state = { ...fleet.state, status: "running", pid: process.pid, heartbeat_at: new Date().toISOString() };
+  await writeState(fleet.fleetRoot, fleet.state);
   const stopSpinner = startSpinner(ctx, fleet);
   updateWidget(ctx, fleet);
 
-  const checkCostWarning = () => {
-    const warn = fleet.spec.config.warn_cost_usd;
-    if (!warn || fleet.costWarned) return;
-    const cost = fleet.state.cost_usd_estimate;
-    if (cost >= warn) {
-      fleet.costWarned = true;
-      if (ctx.hasUI) ctx.ui.notify(`fleet cost warning: $${cost.toFixed(4)} >= $${warn}`, "warning");
+  let lastHeartbeatWrite = Date.now();
+  const heartbeatInterval = setInterval(async () => {
+    const now = Date.now();
+    if (now - lastHeartbeatWrite < 5000) return;
+    fleet.state = { ...fleet.state, heartbeat_at: new Date().toISOString() };
+    lastHeartbeatWrite = now;
+    try {
+      await writeState(fleet.fleetRoot, fleet.state);
+    } catch {
+      // ignore heartbeat write failures
+    }
+  }, 5000);
+  if (typeof heartbeatInterval.unref === "function") heartbeatInterval.unref();
+
+  let cleanedUp = false;
+  let finalStateWritten = false;
+  const cleanup = () => {
+    if (cleanedUp) return;
+    cleanedUp = true;
+    stopSpinner();
+    clearInterval(heartbeatInterval);
+  };
+  const writeFinalState = async () => {
+    if (finalStateWritten) return;
+    finalStateWritten = true;
+    try {
+      await writeState(fleet.fleetRoot, fleet.state);
+    } catch {
+      // best-effort final persistence
     }
   };
 
@@ -229,6 +282,7 @@ export async function startLoop(fleet: ActiveFleet, ctx: ExtensionContext, resum
           repoCwd: worktreeCwd,
           sessionDir,
           thinkingLevel: effort,
+          extensionAllowlist: fleet.spec.config.worker_extensions,
           sessionFactory: resolvedModel ? sessionFactoryForModel(resolvedModel) : undefined,
           onSession: (s) => registerNodeSession(fleet, nodeId, s),
           onEvent: (e) => {
@@ -236,7 +290,7 @@ export async function startLoop(fleet: ActiveFleet, ctx: ExtensionContext, resum
             if (e.type === "tokens") fleet.state = patchNode(fleet.fleetRoot, fleet.state, nodeId, { tokens: e.tokens });
             if (e.type === "cost") {
               fleet.state = patchNode(fleet.fleetRoot, fleet.state, nodeId, { cost_usd_estimate: e.cost });
-              checkCostWarning();
+              checkCostLimits(fleet, ctx);
             }
             if (e.type === "error") fleet.state = patchNode(fleet.fleetRoot, fleet.state, nodeId, { status_note: e.message });
             updateWidget(ctx, fleet);
@@ -271,7 +325,7 @@ export async function startLoop(fleet: ActiveFleet, ctx: ExtensionContext, resum
         fleet.state = fleet.state.nodes[nodeId]
           ? patchNode(fleet.fleetRoot, fleet.state, nodeId, nodeState)
           : { ...fleet.state, nodes: { ...fleet.state.nodes, [nodeId]: nodeState } };
-        checkCostWarning();
+        checkCostLimits(fleet, ctx);
         updateWidget(ctx, fleet);
       },
       onNodeAdded: (w) => {
@@ -298,9 +352,10 @@ export async function startLoop(fleet: ActiveFleet, ctx: ExtensionContext, resum
     });
     fleet.state = state;
     fleet.running = false;
-    stopSpinner();
+    cleanup();
     updateWidget(ctx, fleet); // keep final per-node stats visible (todo #12)
-    const report = await writeReport({ spec: fleet.spec, state, fleetRoot: fleet.fleetRoot, repoCwd: ctx.cwd });
+    await writeReport({ spec: fleet.spec, state, fleetRoot: fleet.fleetRoot, repoCwd: ctx.cwd });
+    await writeFinalState();
     const last = state.iterations[state.iterations.length - 1];
     if (state.status === "paused" && last?.verdict === "escalate") {
       if (ctx.hasUI) ctx.ui.notify(`fleet paused: reviewer escalated; report: ${join(fleet.fleetRoot, "report.md")}`, "warning");
@@ -309,8 +364,9 @@ export async function startLoop(fleet: ActiveFleet, ctx: ExtensionContext, resum
     }
   } catch (err: unknown) {
     fleet.running = false;
-    stopSpinner();
+    cleanup();
     updateWidget(ctx, fleet);
+    await writeFinalState();
     const error = err instanceof Error ? err.message : String(err);
     if (ctx.hasUI) ctx.ui.notify(`fleet failed: ${error}`, "error");
   }

package/src/dag.ts

@@ -107,6 +107,10 @@ export function validateFleetSpec(
     errors.push(`config.effort must be one of ${THINKING_LEVELS.join(", ")}`);
   }
   const warnCost = typeof cfg.warn_cost_usd === "number" ? cfg.warn_cost_usd : undefined;
+  const maxCost = typeof cfg.max_cost_usd === "number" ? cfg.max_cost_usd : undefined;
+  const workerExtensions = Array.isArray(cfg.worker_extensions)
+    ? (cfg.worker_extensions as unknown[]).filter((e): e is string => typeof e === "string")
+    : undefined;
 
   const rawWorkers = Array.isArray(r?.workers) ? (r.workers as Record<string, unknown>[]) : [];
   if (rawWorkers.length === 0) errors.push("at least one worker required");
@@ -266,7 +270,7 @@ export function validateFleetSpec(
   const spec: FleetSpec = {
     fleet_name: String(r?.fleet_name ?? ""),
     type: "dag",
-    config: { max_concurrent: maxConcurrent, model, effort, warn_cost_usd: warnCost, loop: loopConfig },
+    config: { max_concurrent: maxConcurrent, model, effort, warn_cost_usd: warnCost, max_cost_usd: maxCost, worker_extensions: workerExtensions, loop: loopConfig },
     workers,
   };
 

package/src/edits.ts

@@ -8,7 +8,7 @@ import type { NodeStatus, ThinkingLevelName } from "./types.js";
 import { THINKING_LEVELS } from "./types.js";
 
 export type NodeEditKey = "model" | "effort" | "task";
-export type ConfigEditKey = "max_concurrent" | "warn_cost_usd" | "model" | "effort";
+export type ConfigEditKey = "max_concurrent" | "warn_cost_usd" | "max_cost_usd" | "worker_extensions" | "model" | "effort";
 
 export interface EditResult {
   ok: boolean;
@@ -85,6 +85,25 @@ export async function editConfig(
       fleet.spec.config.warn_cost_usd = n;
       break;
     }
+    case "max_cost_usd": {
+      const n = Number(value);
+      if (!Number.isFinite(n) || n < 0) return { ok: false, message: "max_cost_usd must be a number >= 0" };
+      fleet.spec.config.max_cost_usd = n;
+      break;
+    }
+    case "worker_extensions": {
+      // accept JSON array or comma-separated string
+      let list: string[];
+      try {
+        const parsed: unknown = JSON.parse(value);
+        list = Array.isArray(parsed) ? parsed.map(String) : [value];
+      } catch {
+        list = value.split(",").map((s) => s.trim()).filter(Boolean);
+      }
+      if (list.some((s) => s.length === 0)) return { ok: false, message: "worker_extensions must be non-empty strings" };
+      fleet.spec.config.worker_extensions = list;
+      break;
+    }
     case "model": {
       const r = resolveModelReference(registry, value);
       if (!r.ok) return { ok: false, message: r.error };
@@ -99,7 +118,7 @@ export async function editConfig(
       break;
     }
     default:
-      return { ok: false, message: `unknown config key "${String(key)}" (keys: max_concurrent, warn_cost_usd, model, effort)` };
+      return { ok: false, message: `unknown config key "${String(key)}" (keys: max_concurrent, warn_cost_usd, max_cost_usd, worker_extensions, model, effort)` };
   }
   await persistFleetJson(fleet);
   return { ok: true, message: `config.${key} updated` };

package/src/runner.ts

@@ -1,4 +1,4 @@
-import { createAgentSession, SessionManager, type CreateAgentSessionOptions } from "@earendil-works/pi-coding-agent";
+import { createAgentSession, SessionManager, DefaultResourceLoader, type CreateAgentSessionOptions } from "@earendil-works/pi-coding-agent";
 import type { Api, Model } from "@earendil-works/pi-ai";
 import type { ThinkingLevelName, WorkerSpec } from "./types.js";
 import { WORKER_TYPE_TOOLS } from "./types.js";
@@ -25,16 +25,52 @@ export interface SessionOpts {
   tools: string[];
   model?: string;
   thinkingLevel?: ThinkingLevelName;
+  extensionAllowlist?: string[];
 }
 
 export type SessionFactory = (opts: SessionOpts) => Promise<AgentSessionLike>;
 
+// Fleet workers must not load user extensions/skills: reading global skill files
+// burns tokens mid-task, and extensions like pi-web-access run background async work
+// that can crash the pi process after the session is disposed.
+// Exception: some model providers are registered BY extensions (e.g. opencode-pi
+// registers the opencode-cli provider). worker_extensions allowlists exactly those.
+export function filterExtensionsByAllowlist<T extends { path: string }>(
+  extensions: T[],
+  allowlist: string[] | undefined,
+): T[] {
+  if (!allowlist || allowlist.length === 0) return extensions;
+  return extensions.filter((e) => allowlist.some((a) => e.path.includes(a)));
+}
+
+async function createLeanResourceLoader(cwd: string, extensionAllowlist?: string[]): Promise<DefaultResourceLoader> {
+  const allow = extensionAllowlist && extensionAllowlist.length > 0;
+  const loader = new DefaultResourceLoader({
+    cwd,
+    agentDir: cwd,
+    noExtensions: !allow,
+    extensionsOverride: allow
+      ? (base) => ({ ...base, extensions: filterExtensionsByAllowlist(base.extensions, extensionAllowlist) })
+      : undefined,
+    noSkills: true,
+    noPromptTemplates: true,
+    noThemes: true,
+    noContextFiles: true,
+    systemPromptOverride: () => undefined,
+    appendSystemPromptOverride: () => [],
+  });
+  await loader.reload();
+  return loader;
+}
+
 export const defaultSessionFactory: SessionFactory = async (opts) => {
+  const resourceLoader = await createLeanResourceLoader(opts.cwd, opts.extensionAllowlist);
   const { session } = await createAgentSession({
     cwd: opts.cwd,
     tools: opts.tools,
     sessionManager: SessionManager.create(opts.cwd, opts.sessionDir),
     thinkingLevel: opts.thinkingLevel as ThinkingLevelOption,
+    resourceLoader,
   });
   return session as unknown as AgentSessionLike;
 };
@@ -49,6 +85,7 @@ export interface RunWorkerOpts {
   onSession?: (session: AgentSessionLike) => void;
   sessionFactory?: SessionFactory;
   thinkingLevel?: ThinkingLevelName;
+  extensionAllowlist?: string[];
 }
 
 export interface RunWorkerResult {
@@ -69,6 +106,7 @@ export async function runWorker(opts: RunWorkerOpts): Promise<RunWorkerResult> {
       tools: WORKER_TYPE_TOOLS[opts.worker.type],
       model: opts.worker.model,
       thinkingLevel: opts.thinkingLevel,
+      extensionAllowlist: opts.extensionAllowlist,
     });
   } catch (err) {
     const message = err instanceof Error ? err.message : String(err);
@@ -79,13 +117,29 @@ export async function runWorker(opts: RunWorkerOpts): Promise<RunWorkerResult> {
   let turns = 0;
   let tokens = 0;
   let cost = 0;
+  // pi resolves session.prompt() normally even when the model run ends in an error
+  // (e.g. provider usage limit) — the failure is only visible on the final assistant
+  // message's stopReason/errorMessage. Track the last assistant message so a resolved
+  // prompt that actually errored is reported as ok:false instead of running the output
+  // contract against files that were never written.
+  let lastStopReason: string | undefined;
+  let lastErrorMessage: string | undefined;
   const unsub = session.subscribe((e) => {
     if (e.type === "turn_end") {
       turns++;
       opts.onEvent({ type: "turn", nodeId: opts.nodeId, turns });
     }
     if (e.type === "message_end") {
-      const msg = e.message as { role?: string; usage?: { totalTokens?: number; cost?: { total?: number } } } | undefined;
+      const msg = e.message as {
+        role?: string;
+        stopReason?: string;
+        errorMessage?: string;
+        usage?: { totalTokens?: number; cost?: { total?: number } };
+      } | undefined;
+      if (msg?.role === "assistant") {
+        lastStopReason = msg.stopReason;
+        lastErrorMessage = msg.errorMessage;
+      }
       if (msg?.role === "assistant" && msg.usage?.totalTokens) {
         tokens += msg.usage.totalTokens;
         opts.onEvent({ type: "tokens", nodeId: opts.nodeId, tokens });
@@ -98,6 +152,11 @@ export async function runWorker(opts: RunWorkerOpts): Promise<RunWorkerResult> {
   });
   try {
     await session.prompt(opts.prompt);
+    if (lastStopReason === "error") {
+      const message = lastErrorMessage ?? "worker model run ended with an error";
+      opts.onEvent({ type: "error", nodeId: opts.nodeId, message });
+      return { ok: false, turns, tokens, cost, error: message };
+    }
     opts.onEvent({ type: "done", nodeId: opts.nodeId });
     return { ok: true, turns, tokens, cost };
   } catch (err) {
@@ -112,12 +171,14 @@ export async function runWorker(opts: RunWorkerOpts): Promise<RunWorkerResult> {
 
 export function sessionFactoryForModel(model: Model<Api>): SessionFactory {
   return async (opts) => {
+    const resourceLoader = await createLeanResourceLoader(opts.cwd, opts.extensionAllowlist);
     const { session } = await createAgentSession({
       cwd: opts.cwd,
       tools: opts.tools,
       sessionManager: SessionManager.create(opts.cwd, opts.sessionDir),
       model,
       thinkingLevel: opts.thinkingLevel as ThinkingLevelOption,
+      resourceLoader,
     });
     return session as unknown as AgentSessionLike;
   };

package/src/scheduler.ts

@@ -25,6 +25,15 @@ export interface RunFleetOpts {
   continuePass?: boolean;
   onIterationEnd?: (snap: IterationSnapshot) => void;
   prepareIteration?: (n: number, state: FleetState) => Promise<void>;
+  retryDelayMs?: (attempt: number) => number;
+}
+
+const MAX_RETRY_ATTEMPTS = 3;
+const DEFAULT_RETRY_DELAY_MS = (attempt: number): number => 1000 * 2 ** attempt;
+const RETRYABLE_ERROR_RE = /usage limit|rate.?limit|429|overloaded|502|503|timed? ?out|timeout|econnreset|etimedout|econnrefused|fetch failed/i;
+
+export function isRetryableError(message: string): boolean {
+  return RETRYABLE_ERROR_RE.test(message);
 }
 
 const FAILED: ReadonlySet<string> = new Set(["failed", "contract_failed", "killed", "blocked"]);
@@ -52,6 +61,19 @@ export async function runFleet(opts: RunFleetOpts): Promise<FleetState> {
   let state: FleetState;
   if (opts.resumeFrom) {
     state = { ...opts.resumeFrom, paused: false, status: "running" };
+    // Crash recovery: nodes left "running" on disk by a dead process have no live
+    // session in this runFleet call — reset them to pending so they get dispatched.
+    // Without this, the scheduler can neither dispatch nor terminate them and spins
+    // forever (nothing runnable, not all nodes terminal).
+    for (const w of spec.workers) {
+      if (state.nodes[w.id]?.status === "running") {
+        state = patchNode(fleetRoot, state, w.id, {
+          status: "pending",
+          started_at: undefined,
+          status_note: "recovered stale running state from a previous crashed/killed process",
+        });
+      }
+    }
     await writeState(fleetRoot, state);
     if (allNodesTerminal(state, spec) && !opts.continuePass) {
       state = resetForIteration(state, spec);
@@ -71,6 +93,15 @@ export async function runFleet(opts: RunFleetOpts): Promise<FleetState> {
   };
 
   const running = new Set<Promise<void>>();
+  const circuitErrors = new Map<string, Set<string>>();
+  let circuitOpen = false;
+  function recordCircuitError(nodeId: string, error: string | undefined) {
+    if (!error) return;
+    const set = circuitErrors.get(error) ?? new Set<string>();
+    set.add(nodeId);
+    circuitErrors.set(error, set);
+    if (set.size >= 2) circuitOpen = true;
+  }
 
   const repoCwdFor = (nodeId: string): string =>
     typeof opts.repoCwd === "function" ? opts.repoCwd(nodeId) : opts.repoCwd;
@@ -179,6 +210,23 @@ export async function runFleet(opts: RunFleetOpts): Promise<FleetState> {
           await patch(w.id, { status: "killed", ended_at: new Date().toISOString() });
         }
       }
+      // circuit breaker: two distinct nodes failed with the identical error
+      if (circuitOpen) {
+        const [tripError, tripSet] = [...circuitErrors.entries()].find(([_, ids]) => ids.size >= 2) ?? ["", new Set<string>()];
+        const tripCount = tripSet.size;
+        const note = `circuit breaker: ${tripCount} nodes failed with identical error: ${tripError.slice(0, 80)}`;
+        for (const w of spec.workers) {
+          const n = state.nodes[w.id];
+          if (!n || (n.status !== "pending" && n.status !== "ready")) continue;
+          await patch(w.id, { status: "blocked", ended_at: new Date().toISOString(), status_note: note });
+        }
+        if (running.size > 0) {
+          await Promise.race(running);
+          continue;
+        }
+        break;
+      }
+
       // dispatch ready
       const activeCount = running.size;
       let slots = spec.config.max_concurrent - activeCount;
@@ -251,16 +299,55 @@ export async function runFleet(opts: RunFleetOpts): Promise<FleetState> {
 
         const dispatchMs = Date.now();
         await patch(w.id, { status: "running", started_at: new Date().toISOString() });
-        const p = opts.spawn(w.id).then(async (res) => {
+        const p = (async () => {
+          let totals = { turns: 0, tokens: 0, cost: 0 };
+          let lastRes: Awaited<ReturnType<typeof opts.spawn>> | undefined;
+          let finalError: string | undefined;
+
+          for (let attempt = 0; attempt < MAX_RETRY_ATTEMPTS; attempt++) {
+            if (opts.killSwitch?.killed) return;
+            if (opts.nodeKills?.has(w.id)) {
+              await patch(w.id, { status: "killed", ended_at: new Date().toISOString(), turns: totals.turns, tokens: totals.tokens, cost_usd_estimate: totals.cost });
+              return;
+            }
+            const res = await opts.spawn(w.id);
+            lastRes = res;
+            totals.turns += res.turns;
+            totals.tokens += res.tokens;
+            totals.cost += res.cost ?? 0;
+            if (opts.killSwitch?.killed) return;
+            if (opts.nodeKills?.has(w.id)) {
+              await patch(w.id, { status: "killed", ended_at: new Date().toISOString(), turns: totals.turns, tokens: totals.tokens, cost_usd_estimate: totals.cost });
+              return;
+            }
+            if (res.ok) {
+              finalError = undefined;
+              break;
+            }
+            finalError = res.error;
+            if (!res.error || !isRetryableError(res.error) || attempt === MAX_RETRY_ATTEMPTS - 1) {
+              break;
+            }
+            await patch(w.id, { status_note: `retry ${attempt + 1}/${MAX_RETRY_ATTEMPTS - 1} after: ${res.error}` });
+            const delayMs = opts.retryDelayMs ? opts.retryDelayMs(attempt) : DEFAULT_RETRY_DELAY_MS(attempt);
+            await new Promise((r) => setTimeout(r, delayMs));
+          }
+
+          const res = lastRes;
+          if (!res) return;
+
           if (opts.killSwitch?.killed) return;
           if (opts.nodeKills?.has(w.id)) {
-            await patch(w.id, { status: "killed", ended_at: new Date().toISOString(), turns: res.turns, tokens: res.tokens, cost_usd_estimate: res.cost ?? 0 });
+            await patch(w.id, { status: "killed", ended_at: new Date().toISOString(), turns: totals.turns, tokens: totals.tokens, cost_usd_estimate: totals.cost });
             return;
           }
+
           if (!res.ok) {
-            await patch(w.id, { status: "failed", ended_at: new Date().toISOString(), turns: res.turns, tokens: res.tokens, cost_usd_estimate: res.cost ?? 0 });
+            await patch(w.id, { status: "failed", ended_at: new Date().toISOString(), turns: totals.turns, tokens: totals.tokens, cost_usd_estimate: totals.cost });
+            recordCircuitError(w.id, finalError ?? res.error);
             return;
           }
+
           if (w.worktree) {
             try {
               await commitWorktree({
@@ -274,9 +361,9 @@ export async function runFleet(opts: RunFleetOpts): Promise<FleetState> {
               await patch(w.id, {
                 status: "failed",
                 ended_at: new Date().toISOString(),
-                turns: res.turns,
-                tokens: res.tokens,
-                cost_usd_estimate: res.cost ?? 0,
+                turns: totals.turns,
+                tokens: totals.tokens,
+                cost_usd_estimate: totals.cost,
                 status_note: `commit failed: ${msg}`,
               });
               return;
@@ -293,9 +380,9 @@ export async function runFleet(opts: RunFleetOpts): Promise<FleetState> {
           await patch(w.id, {
             status: contract.ok ? "completed" : "contract_failed",
             ended_at: new Date().toISOString(),
-            turns: res.turns,
-            tokens: res.tokens,
-            cost_usd_estimate: res.cost ?? 0,
+            turns: totals.turns,
+            tokens: totals.tokens,
+            cost_usd_estimate: totals.cost,
             contract_result: contract,
             produced_outputs: contract.checks.filter((c) => c.ok || c.actualPath).map((c) => c.path),
             status_note: contract.ok ? costNote : [contractFailureNote(contract.checks), costNote].filter(Boolean).join(" · "),
@@ -304,7 +391,7 @@ export async function runFleet(opts: RunFleetOpts): Promise<FleetState> {
             const note = await opts.onNodeCompleted?.(w.id);
             if (note) await patch(w.id, { status_note: note });
           }
-        }).finally(() => running.delete(p));
+        })().finally(() => running.delete(p));
         running.add(p);
       }
       if (running.size > 0) {
@@ -314,6 +401,33 @@ export async function runFleet(opts: RunFleetOpts): Promise<FleetState> {
         return !!n && TERMINAL_NODE_STATUSES.has(n.status);
       })) {
         break;
+      } else {
+        // Defensive: nothing in flight, not all terminal, and nothing dispatchable
+        // would mean a tight infinite loop (busy-spin, event-loop starvation).
+        // Fail the stuck nodes instead of hanging.
+        const dispatchable = spec.workers.some((w) => {
+          const n = state.nodes[w.id];
+          if (!n || (n.status !== "pending" && n.status !== "ready")) return false;
+          if (opts.nodeKills?.has(w.id)) return true; // will be killed next pass
+          return w.depends_on.every((d) => state.nodes[d]?.status === "completed");
+        });
+        const blockingDepsFailed = spec.workers.some((w) => {
+          const n = state.nodes[w.id];
+          if (!n || (n.status !== "pending" && n.status !== "ready")) return false;
+          return w.depends_on.some((d) => FAILED.has(state.nodes[d]?.status ?? ""));
+        });
+        if (!dispatchable && !blockingDepsFailed) {
+          for (const w of spec.workers) {
+            const n = state.nodes[w.id];
+            if (!n || TERMINAL_NODE_STATUSES.has(n.status)) continue;
+            await patch(w.id, {
+              status: "failed",
+              ended_at: new Date().toISOString(),
+              status_note: `stuck in non-terminal status "${n.status}" with no dispatchable path; failed to avoid scheduler hang`,
+            });
+          }
+          break;
+        }
       }
     }
     await Promise.allSettled([...running]);

package/src/state.ts

@@ -32,6 +32,8 @@ export async function readState(fleetRoot: string): Promise<FleetState> {
     lgtm_streak: parsed.lgtm_streak ?? 0,
     paused: parsed.paused ?? false,
     iterations: parsed.iterations ?? [],
+    pid: parsed.pid,
+    heartbeat_at: parsed.heartbeat_at,
   };
 }
 

package/src/tools.ts

@@ -58,6 +58,8 @@ export function registerFleetTools(pi: ExtensionAPI): void {
       model: Type.Optional(Type.String({ description: "Fleet-wide default model" })),
       effort: Type.Optional(EffortSchema),
       warn_cost_usd: Type.Optional(Type.Number()),
+      max_cost_usd: Type.Optional(Type.Number()),
+      worker_extensions: Type.Optional(Type.Array(Type.String())),
       loop: Type.Optional(Type.Object({
         gate: Type.Union([Type.Literal("reviewer"), Type.Literal("none")]),
         max_iterations: Type.Number(),
@@ -335,11 +337,11 @@ export function registerFleetTools(pi: ExtensionAPI): void {
   pi.registerTool({
     name: "fleet_edit",
     label: "Fleet Edit",
-    description: "Edit the active fleet: a pending or relaunchable node's model, effort, or task — or fleet config (max_concurrent, warn_cost_usd, model, effort) when node_id is omitted. Changes persist to fleet.json and apply immediately. Edits to running or completed nodes are refused; pending, blocked, failed, contract_failed, and killed nodes can be edited (blocked nodes have not started — nothing to invalidate).",
+    description: "Edit the active fleet: a pending or relaunchable node's model, effort, or task — or fleet config (max_concurrent, warn_cost_usd, max_cost_usd, model, effort) when node_id is omitted. Changes persist to fleet.json and apply immediately. Edits to running or completed nodes are refused; pending, blocked, failed, contract_failed, and killed nodes can be edited (blocked nodes have not started — nothing to invalidate).",
     promptSnippet: "Edit a pending fleet node or fleet config.",
     parameters: Type.Object({
       node_id: Type.Optional(Type.String({ description: "Worker id to edit; omit for fleet config edits" })),
-      key: Type.String({ description: "Node keys: model, effort, task. Config keys: max_concurrent, warn_cost_usd, model, effort" }),
+      key: Type.String({ description: "Node keys: model, effort, task. Config keys: max_concurrent, warn_cost_usd, max_cost_usd, model, effort" }),
       value: Type.String({ description: "New value" }),
     }),
     async execute(_id, params, _signal, _onUpdate, ctx) {

package/src/types.ts

@@ -44,6 +44,11 @@ export interface FleetConfig {
   model?: string;
   effort?: ThinkingLevelName;
   warn_cost_usd?: number;
+  /** hard cap — fleet is killed when total estimated cost reaches it */
+  max_cost_usd?: number;
+  /** extension path fragments to load inside worker sessions (default: none).
+   *  Needed for extension-provided model providers, e.g. ["opencode-pi"]. */
+  worker_extensions?: string[];
   loop?: LoopConfig;
 }
 
@@ -112,6 +117,10 @@ export interface FleetState {
   lgtm_streak: number;
   paused: boolean;
   iterations: IterationSnapshot[];
+  /** liveness signal written by the running controller */
+  pid?: number;
+  /** ISO timestamp liveness signal written by the running controller */
+  heartbeat_at?: string;
 }
 
 export const WORKER_TYPE_TOOLS: Record<WorkerType, string[]> = {