pi-agent-fleet 0.5.0 → 0.7.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-agent-fleet",
-  "version": "0.5.0",
+  "version": "0.7.0",
   "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

@@ -16,6 +16,7 @@ import {
   useReactFlow,
 } from "@xyflow/react";
 import type { Edge, Node, NodeProps } from "@xyflow/react";
+import { computePositions, excerptText, NODE_W } from "./canvas-layout.js";
 
 /* ---------- payload types (mirror canvas.ts) ---------- */
 interface CanvasNodeView {
@@ -76,7 +77,6 @@ type TimelineEvent =
 interface SessionResp { entries: SessionEntry[]; actions: ActionView[]; events: TimelineEvent[]; task?: string }
 
 /* ---------- helpers ---------- */
-const NODE_W = 284;
 function statusClass(s: string): string {
   return "st-" + s.replace(/\s+/g, "_");
 }
@@ -97,47 +97,6 @@ function j<T>(u: string): Promise<T> {
   });
 }
 
-/* topo-layer layout, ported from the legacy canvas */
-function topoLayers(nodes: CanvasNodeView[], edges: Array<{ from: string; to: string }>): string[][] {
-  const ids = nodes.map((n) => n.id);
-  const indeg: Record<string, number> = {};
-  const rev: Record<string, string[]> = {};
-  ids.forEach((i) => { indeg[i] = 0; rev[i] = []; });
-  edges.forEach((e) => { if (e.from in indeg) { indeg[e.to]++; rev[e.from].push(e.to); } });
-  const layers: string[][] = [];
-  let cur = ids.filter((i) => indeg[i] === 0);
-  const seen: Record<string, boolean> = {};
-  while (cur.length) {
-    layers.push(cur);
-    cur.forEach((i) => { seen[i] = true; });
-    const next: string[] = [];
-    cur.forEach((i) => rev[i].forEach((m) => { if (--indeg[m] === 0) next.push(m); }));
-    cur = next;
-  }
-  ids.forEach((i) => { if (!seen[i]) { layers.push([i]); seen[i] = true; } });
-  return layers;
-}
-function median(arr: number[]): number {
-  const s = arr.slice().sort((a, b) => a - b);
-  const m = Math.floor(s.length / 2);
-  return s.length % 2 ? s[m] : (s[m - 1] + s[m]) / 2;
-}
-function reduceCrossings(layers: string[][], edges: Array<{ from: string; to: string }>): string[][] {
-  for (let li = 1; li < layers.length; li++) {
-    const prevPos: Record<string, number> = {};
-    layers[li - 1].forEach((id, i) => { prevPos[id] = i; });
-    const key = (id: string) => median(edges.filter((e) => e.to === id).map((e) => prevPos[e.from] ?? 0));
-    layers[li].sort((a, b) => key(a) - key(b));
-  }
-  return layers;
-}
-function computePositions(p: CanvasPayload): Record<string, { x: number; y: number }> {
-  const layers = reduceCrossings(topoLayers(p.nodes, p.edges), p.edges);
-  const pos: Record<string, { x: number; y: number }> = {};
-  layers.forEach((layer, li) => layer.forEach((id, ni) => { pos[id] = { x: li * 360, y: ni * 170 }; }));
-  return pos;
-}
-
 /* ---------- custom node ---------- */
 type FleetNodeData = {
   view: CanvasNodeView;
@@ -179,8 +138,8 @@ function FleetNode({ data }: NodeProps<Node<FleetNodeData>>) {
       onClick={activate}
       onKeyDown={(e) => { if (e.key === "Enter" || e.key === " ") { e.preventDefault(); activate(); } }}
     >
-      <Handle type="target" position={Position.Left} />
-      <Handle type="target" position={Position.Bottom} id="loopIn" />
+      <Handle type="target" position={Position.Top} />
+      <Handle type="target" position={Position.Top} id="loopIn" />
       <div className="card-body">
         <div className="node-header">
           <span className={"node-dot" + (running ? " pulse" : "")} style={{ background: minimapColor(n.status) }} aria-hidden="true" />
@@ -210,10 +169,10 @@ function FleetNode({ data }: NodeProps<Node<FleetNodeData>>) {
             ))}
           </div>
         )}
-        {n.status_note && <div className="note">{n.status_note}</div>}
-        {failReason && <div className="fail-reason">{failReason}</div>}
+        {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.Right} />
+      <Handle type="source" position={Position.Bottom} />
       <Handle type="source" position={Position.Bottom} id="loop" />
     </div>
   );
@@ -222,7 +181,7 @@ const nodeTypes = { fleet: FleetNode };
 
 /* ---------- side panel ---------- */
 function CollapsiblePrompt({ title, text }: { title: string; text: string }) {
-  const [open, setOpen] = useState(true);
+  const [open, setOpen] = useState(false);
   if (!text) return null;
   return (
     <div className={"collapsible" + (open ? "" : " collapsed")}>
@@ -247,15 +206,23 @@ function formatActionDetail(a: { arguments?: Record<string, unknown> }): string
 
 function TimelineItem({ event }: { event: TimelineEvent }) {
   const [open, setOpen] = useState(event.isError ? true : false);
+  const [expanded, setExpanded] = useState(false);
   const ts = event.timestamp ? new Date(event.timestamp).toLocaleTimeString([], { hour12: false, hour: "2-digit", minute: "2-digit", second: "2-digit" }) : "";
   if (event.type === "message") {
+    const { excerpt, truncated } = excerptText(event.text, 240);
+    const text = truncated && !expanded ? excerpt : event.text;
     return (
       <div className={"timeline-msg" + (event.role === "assistant" ? " assistant" : event.role === "user" ? " user" : "")}>
         <div className="timeline-meta">
           <span className="role">{event.role}</span>
           {ts && <span className="ts">{ts}</span>}
         </div>
-        <div className="timeline-text">{event.text}</div>
+        <div className="timeline-text">{text}</div>
+        {truncated && (
+          <button className="timeline-more" onClick={() => setExpanded((v) => !v)}>
+            {expanded ? "show less" : "show more"}
+          </button>
+        )}
       </div>
     );
   }
@@ -410,12 +377,12 @@ function SidePanel({ fleet, demo, selected, task, onClose }: { fleet: string | n
         )}
       </div>
       <div className="side-body" ref={boxRef} tabIndex={-1}>
-        <CollapsiblePrompt title="Instructions" text={resp?.task || task || ""} />
         {resp === null ? (
           <div className="timeline-loading"><span className="spinner" aria-hidden="true" /> Loading session…</div>
         ) : (
           <Timeline events={resp.events ?? []} />
         )}
+        <CollapsiblePrompt title="Instructions (task prompt)" text={resp?.task || task || ""} />
       </div>
     </div>
   );
@@ -602,7 +569,7 @@ function Flow() {
   // so drag positions and measured sizes (needed by the minimap) survive polling.
   useEffect(() => {
     if (!payload) { setNodes([]); return; }
-    const pos = computePositions(payload);
+    const pos = computePositions(payload.nodes, payload.edges);
     const gateId = payload.loop
       ? (payload.nodes.find((n) => n.id === payload.loop!.gate) ?? payload.nodes.find((n) => n.type === payload.loop!.gate))?.id
       : undefined;

package/src/canvas-layout.ts

@@ -0,0 +1,83 @@
+export const NODE_W = 284;
+export const NODE_H_GAP = 200;
+export const NODE_W_GAP = 40;
+
+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 topoLayers(ids: string[], edges: Array<{ from: string; to: string }>): string[][] {
+  const indeg: Record<string, number> = {};
+  const nextById: Record<string, string[]> = {};
+  for (const id of ids) {
+    indeg[id] = 0;
+    nextById[id] = [];
+  }
+  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 layers: string[][] = [];
+  const seen = new Set<string>();
+  let cur = ids.filter((id) => indeg[id] === 0);
+  while (cur.length) {
+    layers.push(cur);
+    const next: string[] = [];
+    for (const id of cur) {
+      seen.add(id);
+      for (const to of nextById[id]) {
+        indeg[to]--;
+        if (indeg[to] === 0) next.push(to);
+      }
+    }
+    cur = next;
+  }
+
+  for (const id of ids) {
+    if (seen.has(id)) continue;
+    layers.push([id]);
+    seen.add(id);
+  }
+  return layers;
+}
+
+function median(values: number[]): number {
+  if (!values.length) return 0;
+  const sorted = values.slice().sort((a, b) => a - b);
+  const mid = Math.floor(sorted.length / 2);
+  return sorted.length % 2 ? sorted[mid] : (sorted[mid - 1] + sorted[mid]) / 2;
+}
+
+export function reduceCrossings(layers: string[][], edges: Array<{ from: string; to: string }>): string[][] {
+  const ordered = layers.map((layer) => layer.slice());
+  for (let li = 1; li < ordered.length; li++) {
+    const prevPos: Record<string, number> = {};
+    ordered[li - 1].forEach((id, i) => {
+      prevPos[id] = i;
+    });
+    const key = (id: string) => median(edges.filter((edge) => edge.to === id).map((edge) => prevPos[edge.from] ?? 0));
+    ordered[li].sort((a, b) => key(a) - key(b) || a.localeCompare(b));
+  }
+  return ordered;
+}
+
+export function computePositions(
+  nodes: Array<{ id: string }>,
+  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 stepX = NODE_W + NODE_W_GAP;
+  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 };
+    });
+  });
+  return pos;
+}

package/src/canvas.ts

@@ -628,7 +628,7 @@ async function buildClientBundle(): Promise<string> {
     platform: "browser",
     target: "es2020",
     jsx: "automatic",
-    minify: true,
+    minify: false,
     write: false,
     logLevel: "silent",
     define: { "process.env.NODE_ENV": '"production"' },
@@ -726,6 +726,7 @@ main { display:flex; flex:1 1 auto; min-height:0; }
 .flags { margin-top:6px; 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; }
 #side { width:420px; flex:0 0 auto; border-left:1px solid var(--line); overflow:hidden; display:flex; flex-direction:column; background:var(--bg); }
 #side:focus, #side:focus-visible { outline:none; }
 .side-head { display:flex; flex-wrap:wrap; justify-content:space-between; align-items:center; flex-shrink:0; gap:6px; padding:12px 12px 8px; border-bottom:1px solid var(--line); background:var(--bg); }
@@ -756,19 +757,21 @@ main { display:flex; flex:1 1 auto; min-height:0; }
 .timeline-row .action-detail { flex:1; min-width:0; color:var(--muted); overflow:hidden; text-overflow:ellipsis; white-space:nowrap; font-size:12px; }
 .timeline-row .action-error { color:var(--bad); }
 .timeline-row .ts { flex-shrink:0; color:var(--wire); font-size:11px; font-variant-numeric:tabular-nums; }
-.timeline-msg { padding:8px; margin-bottom:6px; border-radius:5px; background:var(--panel); font-size:13px; }
+.timeline-msg { padding:4px 8px; margin-bottom:6px; border-radius:5px; background:var(--panel); font-size:13px; }
 .timeline-msg.user { border-left:1px solid var(--accent); background:color-mix(in srgb, var(--accent) 5%, var(--panel)); }
 .timeline-msg.assistant { border-left:1px solid var(--ok); background:color-mix(in srgb, var(--ok) 5%, var(--panel)); }
 .timeline-msg .role { font-weight:700; margin-bottom:4px; }
 .timeline-msg .timeline-meta { display:flex; justify-content:space-between; align-items:center; margin-bottom:3px; }
 .timeline-msg .timeline-meta .ts { color:var(--wire); font-size:11px; }
-.timeline-msg .timeline-text { white-space:pre-wrap; word-break:break-word; }
+.timeline-msg .timeline-text { font-size:12px; line-height:1.45; white-space:pre-wrap; word-break:break-word; user-select:text; }
 .timeline-loading { display:flex; align-items:center; justify-content:center; gap:8px; padding:16px 8px; color:var(--muted); font-size:13px; }
 .timeline-empty { padding:16px 8px; color:var(--muted); font-size:13px; text-align:center; }
 .activity-toggle { flex-shrink:0; width:18px; height:18px; padding:0; background:transparent; border:1px solid var(--line); border-radius:4px; color:var(--muted); cursor:pointer; font-size:11px; line-height:1; }
 .activity-toggle:hover { background:var(--bg); color:var(--fg); }
-.activity-body { padding:8px; border-top:1px solid var(--line); font-size:12px; color:var(--muted); font-family:var(--mono); white-space:pre-wrap; word-break:break-word; }
+.activity-body { padding:8px; border-top:1px solid var(--line); font-size:12px; color:var(--muted); font-family:var(--mono); white-space:pre-wrap; word-break:break-word; user-select:text; }
 .activity-body pre { margin:0; background:var(--bg); padding:8px; border-radius:4px; overflow:auto; font-size:11px; }
+.timeline-more { margin-top:4px; padding:0; min-height:auto; border:none; background:none; color:var(--accent); font-size:11px; }
+.timeline-more:hover { text-decoration:underline; }
 .react-flow__minimap-node.st-completed { fill:var(--ok); }
 .react-flow__minimap-node.st-running { fill:var(--accent); }
 .react-flow__minimap-node.st-failed, .react-flow__minimap-node.st-contract_failed { fill:var(--bad); }
@@ -812,6 +815,7 @@ button.toggled { border-color:var(--accent); color:var(--accent); }
 .empty-cta:hover { background:var(--panel); }
 /* failure reason surfaced on failed cards */
 .fail-reason { margin-top:6px; font-size:13px; color:var(--bad); }
+.action-detail { user-select:text; }
 /* respect reduced-motion: keep the state, drop the perpetual movement */
 @media (prefers-reduced-motion: reduce) {
   .spinner { animation:none; border-top-color:var(--accent); opacity:0.6; }

package/src/command.ts

@@ -1,13 +1,13 @@
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
-import { activeFleet, currentState, ensureCanvas, killFleet, prepareRelaunch, startLoop, statusText, stopCanvas, updateWidget } from "./controller.js";
-import { persistFleetJson, writeWorkerPrompts } from "./fleet-store.js";
+import { activeFleet, currentState, ensureCanvas, killFleet, requestRelaunch, startLoop, statusText, stopCanvas, updateWidget } from "./controller.js";
+import { writeWorkerPrompts } from "./fleet-store.js";
 import { openInBrowser, listFleetRoots } from "./canvas.js";
 import { insertWorkers } from "./insert.js";
 import { editConfig, editNode, type ConfigEditKey, type NodeEditKey } from "./edits.js";
-import { listModelRefs, resolveModelReference } from "./model-resolution.js";
+import { listModelRefs } from "./model-resolution.js";
 import { clearPreference, loadPreferences, PREFERENCE_KEYS, savePreferences, setPreference } from "./preferences.js";
 import { recoverLatestFleet } from "./fleet-recovery.js";
-import { resetForRelaunch, writeState } from "./state.js";
+import { writeState } from "./state.js";
 import { buildWidgetLines } from "./ui.js";
 import { renderDag } from "./viz.js";
 
@@ -187,43 +187,15 @@ export function registerFleetCommand(pi: ExtensionAPI): void {
           ctx.ui.notify("usage: /fleet relaunch <node_id> [model]", "warning");
           return;
         }
-        if (active.running) {
-          ctx.ui.notify("fleet is running", "warning");
-          return;
-        }
         await currentState(active);
         if (active.state.status === "completed") {
           ctx.ui.notify("fleet completed, nothing to relaunch", "warning");
           return;
         }
-        const worker = active.spec.workers.find((w) => w.id === target);
-        if (!worker) {
-          ctx.ui.notify(`unknown node "${target}"`, "warning");
-          return;
-        }
-        const node = active.state.nodes[target];
-        const relaunchable: ReadonlySet<string> = new Set(["failed", "contract_failed", "killed"]);
-        if (!node || !relaunchable.has(node.status)) {
-          ctx.ui.notify(`node "${target}" status ${node?.status ?? "missing"} cannot be relaunched; must be failed, contract_failed, or killed`, "warning");
-          return;
-        }
         const model = args.trim().split(/\s+/).slice(2).join(" ") || undefined;
-        if (model) {
-          const resolved = resolveModelReference(ctx.modelRegistry, model);
-          if (!resolved.ok) {
-            ctx.ui.notify(resolved.error, "error");
-            return;
-          }
-          const canonical = `${resolved.model.provider}/${resolved.model.id}`;
-          active.spec.workers = active.spec.workers.map((w) => w.id === target ? { ...w, model: canonical } : w);
-          await persistFleetJson(active);
-        }
-        active.state = resetForRelaunch(active.state, active.spec, target);
-        await writeState(active.fleetRoot, active.state);
-        await writeWorkerPrompts(active);
-        prepareRelaunch(active, target);
-        void startLoop(active, ctx, false, true);
-        ctx.ui.notify(`fleet relaunch requested for ${target}`, "info");
+        const result = await requestRelaunch(active, target, model, ctx.modelRegistry);
+        if (result.startNow) void startLoop(active, ctx, false, true);
+        ctx.ui.notify(result.message, result.startNow ? "info" : result.message.startsWith("relaunch queued") ? "info" : "warning");
         return;
       }
       if (cmd === "add") {

package/src/contracts.ts

@@ -20,7 +20,7 @@ function firstLines(content: string, n = 5): string {
     .join(" / ");
 }
 
-async function checkOne(workerDir: string, repoCwd: string, o: ContractOutput): Promise<ContractCheck> {
+async function checkOne(workerDir: string, repoCwd: string, o: ContractOutput, notBeforeMs?: number): Promise<ContractCheck> {
   const full = resolvePath(workerDir, repoCwd, o.path);
   const base: Omit<ContractCheck, "ok" | "error"> = { path: o.path, kind: o.kind, required: o.required, actualPath: full };
   const fail = (error: string): ContractCheck => ({ ...base, ok: false, error });
@@ -28,9 +28,12 @@ async function checkOne(workerDir: string, repoCwd: string, o: ContractOutput):
   try {
     const s = await stat(full);
     if (o.kind === "file-exists") {
-      return s.size > 0
-        ? { ...base, ok: true }
-        : fail("empty file");
+      if (s.size === 0) return fail("empty file");
+      const repoRelative = !isAbsolute(o.path) && !o.path.startsWith("output/");
+      if (repoRelative && notBeforeMs !== undefined && s.mtimeMs < notBeforeMs) {
+        return fail("pre-existing repo file not modified since worker start");
+      }
+      return { ...base, ok: true };
     }
     content = await readFile(full, "utf-8");
   } catch {
@@ -99,8 +102,9 @@ export async function verifyOutputs(opts: {
   workerDir: string;
   repoCwd: string;
   outputs: ContractOutput[];
+  notBeforeMs?: number;
 }): Promise<ContractResult> {
-  const checks = await Promise.all(opts.outputs.map((o) => checkOne(opts.workerDir, opts.repoCwd, o)));
+  const checks = await Promise.all(opts.outputs.map((o) => checkOne(opts.workerDir, opts.repoCwd, o, opts.notBeforeMs)));
   const ok = checks.every((c) => !c.required || c.ok);
 
   const verdictCheck = checks.find((c) => c.kind === "verdict" && c.ok);

package/src/controller.ts

@@ -2,14 +2,14 @@ import { readFile, writeFile } from "node:fs/promises";
 import { join } from "node:path";
 import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
 import type { Api, Model } from "@earendil-works/pi-ai";
-import { writeWorkerPrompts } from "./fleet-store.js";
+import { persistFleetJson, writeWorkerPrompts } from "./fleet-store.js";
 import { recoverLatestFleet } from "./fleet-recovery.js";
 import { resolveModelReference, type ModelRegistryLike } from "./model-resolution.js";
 import { insertWorkers } from "./insert.js";
 import { writeReport } from "./report.js";
 import { runWorker, sessionFactoryForModel, workerWithResolvedModel, type AgentSessionLike } from "./runner.js";
 import { runFleet } from "./scheduler.js";
-import { patchNode, readState, writeState } from "./state.js";
+import { patchNode, readState, resetForRelaunch, writeState } from "./state.js";
 import type { FleetSpec, FleetState } from "./types.js";
 import { TERMINAL_NODE_STATUSES } from "./types.js";
 import { buildWidgetLines } from "./ui.js";
@@ -26,6 +26,7 @@ export interface ActiveFleet {
   costWarned?: boolean;
   sessions: Map<string, AgentSessionLike>;
   killedNodes: Set<string>;
+  relaunchRequests: Set<string>;
   widgetVisible?: boolean;
 }
 
@@ -69,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> {
@@ -89,6 +120,48 @@ export function prepareRelaunch(fleet: ActiveFleet, nodeId: string): void {
   fleet.pauseSwitch.paused = false;
 }
 
+export interface RelaunchRequestResult {
+  message: string;
+  startNow: boolean;
+}
+
+export async function requestRelaunch(
+  fleet: ActiveFleet,
+  nodeId: string,
+  model: string | undefined,
+  registry: ModelRegistryLike,
+): Promise<RelaunchRequestResult> {
+  const worker = fleet.spec.workers.find((w) => w.id === nodeId);
+  if (!worker) return { message: `unknown node "${nodeId}"`, startNow: false };
+  const node = fleet.state.nodes[nodeId];
+  const relaunchable: ReadonlySet<string> = new Set(["failed", "contract_failed", "killed"]);
+  if (!node || !relaunchable.has(node.status)) {
+    return {
+      message: `node "${nodeId}" status ${node?.status ?? "missing"} cannot be relaunched; must be failed, contract_failed, or killed`,
+      startNow: false,
+    };
+  }
+  if (model) {
+    const resolved = resolveModelReference(registry, model);
+    if (!resolved.ok) return { message: resolved.error, startNow: false };
+    const canonical = `${resolved.model.provider}/${resolved.model.id}`;
+    fleet.spec.workers = fleet.spec.workers.map((w) => (w.id === nodeId ? { ...w, model: canonical } : w));
+    await persistFleetJson(fleet);
+  }
+  prepareRelaunch(fleet, nodeId);
+  if (fleet.running) {
+    fleet.relaunchRequests.add(nodeId);
+    return {
+      message: `relaunch queued for ${nodeId} (fleet running; dispatches on next scheduler pass)`,
+      startNow: false,
+    };
+  }
+  fleet.state = resetForRelaunch(fleet.state, fleet.spec, nodeId);
+  await writeState(fleet.fleetRoot, fleet.state);
+  await writeWorkerPrompts(fleet);
+  return { message: `fleet relaunch requested for ${nodeId}`, startNow: true };
+}
+
 export function registerNodeSession(fleet: ActiveFleet, nodeId: string, session: AgentSessionLike): void {
   fleet.sessions.set(nodeId, session);
   if (fleet.killedNodes.has(nodeId)) void session.abort().catch(() => {});
@@ -137,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
     }
   };
 
@@ -186,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) => {
@@ -193,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);
@@ -223,11 +320,12 @@ export async function startLoop(fleet: ActiveFleet, ctx: ExtensionContext, resum
       killSwitch: fleet.killSwitch,
       pauseSwitch: fleet.pauseSwitch,
       nodeKills: fleet.killedNodes,
+      relaunchRequests: fleet.relaunchRequests,
       onNodeChange: (nodeId, nodeState) => {
         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) => {
@@ -254,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");
@@ -265,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");
   }
@@ -294,7 +394,7 @@ export async function killFleet(target: string, cwd?: string): Promise<string> {
   const worker = active.spec.workers.find((w) => w.id === target);
   const node = active.state.nodes[target];
   if (!worker || !node) return `unknown node "${target}"`;
-  if (TERMINAL_NODE_STATUSES.has(node.status)) return `node "${target}" already ${node.status}`;
+  if (TERMINAL_NODE_STATUSES.has(node.status) && node.status !== "blocked") return `node "${target}" already ${node.status}`;
   active.killedNodes.add(target);
   const session = active.sessions.get(target);
   if (session) {

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,
   };