pi-agent-fleet 0.5.0 → 0.6.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-agent-fleet",
-  "version": "0.5.0",
+  "version": "0.6.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;
 }
 
@@ -89,6 +90,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(() => {});
@@ -223,6 +266,7 @@ 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)
@@ -294,7 +338,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/edits.ts

@@ -15,7 +15,7 @@ export interface EditResult {
   message: string;
 }
 
-const EDITABLE_NODE_STATUSES: ReadonlySet<NodeStatus> = new Set(["pending", "ready", "failed", "contract_failed", "killed"]);
+const EDITABLE_NODE_STATUSES: ReadonlySet<NodeStatus> = new Set(["pending", "ready", "failed", "contract_failed", "killed", "blocked"]);
 
 export async function editNode(
   fleet: ActiveFleet,
@@ -28,8 +28,8 @@ export async function editNode(
   const node = fleet.state.nodes[nodeId];
   if (!worker || !node) return { ok: false, message: `unknown node "${nodeId}"` };
   if (!EDITABLE_NODE_STATUSES.has(node.status)) {
-      return { ok: false, message: `node "${nodeId}" is ${node.status}; only pending, failed, contract_failed, or killed nodes can be edited` };
-    }
+    return { ok: false, message: `node "${nodeId}" is ${node.status}; only pending, blocked, failed, contract_failed, or killed nodes can be edited` };
+  }
   switch (key) {
     case "model": {
       const r = resolveModelReference(registry, value);

package/src/fleet-recovery.ts

@@ -1,7 +1,7 @@
 import { readdir, readFile, stat } from "node:fs/promises";
 import { join } from "node:path";
 import type { ActiveFleet } from "./controller.js";
-import { readState } from "./state.js";
+import { initFleetState, readState } from "./state.js";
 import type { FleetSpec, FleetState } from "./types.js";
 
 export interface FleetRootInfo {
@@ -13,7 +13,16 @@ export interface FleetRootInfo {
 
 export async function readDiskFleet(fleetRoot: string): Promise<ActiveFleet> {
   const spec = JSON.parse(await readFile(join(fleetRoot, "fleet.json"), "utf-8")) as FleetSpec;
-  const state = await readState(fleetRoot);
+  // Bare fleet.json-only root (e.g. hand-copied spec, never planned/launched):
+  // synthesize a fresh pending state so the canvas can still render the DAG.
+  let state: FleetState;
+  try {
+    state = await readState(fleetRoot);
+  } catch (e: unknown) {
+    const err = e as { code?: string };
+    if (err.code !== "ENOENT") throw e;
+    state = initFleetState(spec);
+  }
   return {
     spec,
     fleetRoot,
@@ -23,6 +32,7 @@ export async function readDiskFleet(fleetRoot: string): Promise<ActiveFleet> {
     running: false,
     sessions: new Map(),
     killedNodes: new Set(),
+    relaunchRequests: new Set(),
   };
 }
 

package/src/prompts.ts

@@ -17,6 +17,17 @@ export function buildWorkerPrompt(opts: {
   const dependents = getDependents(spec, workerId);
   const out: string[] = [];
 
+  out.push(
+    "## Autonomy contract (read first)",
+    "",
+    "You are an unattended fleet worker — there is no human watching this session and nobody will answer questions.",
+    "- Everything in this prompt is PRE-APPROVED. Do not ask for approval; do the work.",
+    "- Do NOT invoke any skill or workflow with a human approval gate (e.g. brainstorming hard-gates). Skip gated steps and execute the task directly.",
+    "- Do not end your turn with a question, a plan awaiting approval, or an 'Approve?' prompt. End your turn only when every REQUIRED output below exists on disk.",
+    "- Ambiguity is yours to resolve: decide, record the decision in your output, and continue.",
+    "",
+  );
+
   const fleetTs = basename(fleetRoot);
 
   out.push(`# Fleet worker: ${workerId}`, "", `Type: ${worker.type}`, "", `## Task`, "", worker.task, "");

package/src/scheduler.ts

@@ -1,7 +1,7 @@
 import { mkdir, rm } from "node:fs/promises";
 import { join } from "node:path";
 import { contractFailureNote, verifyOutputs } from "./contracts.js";
-import { archiveIteration, initFleetState, patchNode, resetForIteration, snapshotIteration, writeState } from "./state.js";
+import { archiveIteration, initFleetState, patchNode, relaunchResetIds, resetForIteration, snapshotIteration, writeState } from "./state.js";
 import { TERMINAL_NODE_STATUSES } from "./types.js";
 import type { FleetSpec, FleetState, IterationSnapshot, NodeState, Verdict, WorkerSpec } from "./types.js";
 import { commitWorktree, createWorktree, prepareIntegratorWorktree } from "./worktree.js";
@@ -20,6 +20,7 @@ export interface RunFleetOpts {
   killSwitch?: { killed: boolean };
   pauseSwitch?: { paused: boolean };
   nodeKills?: ReadonlySet<string>;
+  relaunchRequests?: Set<string>;
   resumeFrom?: FleetState;
   continuePass?: boolean;
   onIterationEnd?: (snap: IterationSnapshot) => void;
@@ -111,6 +112,31 @@ export async function runFleet(opts: RunFleetOpts): Promise<FleetState> {
 
   const runPass = async (): Promise<void> => {
     while (true) {
+      // apply queued relaunch requests (lost-wakeup fix, issue #1 bug 2)
+      if (opts.relaunchRequests && opts.relaunchRequests.size > 0) {
+        for (const id of [...opts.relaunchRequests]) {
+          opts.relaunchRequests.delete(id);
+          const n = state.nodes[id];
+          if (!n || !FAILED.has(n.status)) continue;
+          for (const rid of relaunchResetIds(spec, state, id)) {
+            const rn = state.nodes[rid];
+            if (!rn) continue;
+            if (rid === id && !FAILED.has(rn.status)) continue;
+            if (rid !== id && rn.status !== "blocked") continue;
+            await patch(rid, {
+              status: "pending",
+              started_at: undefined,
+              ended_at: undefined,
+              turns: 0,
+              tokens: 0,
+              cost_usd_estimate: 0,
+              produced_outputs: [],
+              contract_result: undefined,
+              status_note: undefined,
+            });
+          }
+        }
+      }
       // auto-initialize workers inserted into the spec after the run started
       for (const w of spec.workers) {
         if (!state.nodes[w.id]) {
@@ -144,6 +170,15 @@ export async function runFleet(opts: RunFleetOpts): Promise<FleetState> {
         }
         break;
       }
+      // honor kill requests for not-yet-running nodes (incl. blocked, issue #1 bug 3)
+      for (const w of spec.workers) {
+        const n = state.nodes[w.id];
+        if (!n) continue;
+        if (!opts.nodeKills?.has(w.id)) continue;
+        if (n.status === "pending" || n.status === "ready" || n.status === "blocked") {
+          await patch(w.id, { status: "killed", ended_at: new Date().toISOString() });
+        }
+      }
       // dispatch ready
       const activeCount = running.size;
       let slots = spec.config.max_concurrent - activeCount;
@@ -214,6 +249,7 @@ 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) => {
           if (opts.killSwitch?.killed) return;
@@ -250,7 +286,10 @@ export async function runFleet(opts: RunFleetOpts): Promise<FleetState> {
             workerDir: `${fleetRoot}/workers/${w.id}`,
             repoCwd: repoCwdFor(w.id),
             outputs: w.outputs,
+            notBeforeMs: dispatchMs,
           });
+          const costUnknown = res.tokens > 0 && res.cost === 0;
+          const costNote = costUnknown ? `cost unavailable: no pricing for model (${res.tokens} tokens used)` : undefined;
           await patch(w.id, {
             status: contract.ok ? "completed" : "contract_failed",
             ended_at: new Date().toISOString(),
@@ -259,7 +298,7 @@ export async function runFleet(opts: RunFleetOpts): Promise<FleetState> {
             cost_usd_estimate: res.cost ?? 0,
             contract_result: contract,
             produced_outputs: contract.checks.filter((c) => c.ok || c.actualPath).map((c) => c.path),
-            status_note: contract.ok ? undefined : contractFailureNote(contract.checks),
+            status_note: contract.ok ? costNote : [contractFailureNote(contract.checks), costNote].filter(Boolean).join(" · "),
           });
           if (contract.ok) {
             const note = await opts.onNodeCompleted?.(w.id);
@@ -280,8 +319,14 @@ export async function runFleet(opts: RunFleetOpts): Promise<FleetState> {
     await Promise.allSettled([...running]);
   };
 
+  const runPassUntilDrained = async () => {
+    do {
+      await runPass();
+    } while (opts.relaunchRequests && opts.relaunchRequests.size > 0);
+  };
+
   if (!loop) {
-    await runPass();
+    await runPassUntilDrained();
     const anyFailed = spec.workers.some((w) =>
       ["failed", "contract_failed"].includes(state.nodes[w.id]?.status ?? ""));
     const finalStatus = opts.killSwitch?.killed ? "killed" : anyFailed ? "failed" : "completed";
@@ -311,7 +356,7 @@ export async function runFleet(opts: RunFleetOpts): Promise<FleetState> {
 
     await opts.prepareIteration?.(n, state);
 
-    await runPass();
+    await runPassUntilDrained();
 
     let verdict: Verdict | null = null;
     let verdictBody: string | null = null;

package/src/state.ts

@@ -121,34 +121,34 @@ export function patchNode(
   return { ...state, nodes, cost_usd_estimate: cost };
 }
 
-export function resetForRelaunch(state: FleetState, spec: FleetSpec, nodeId: string): FleetState {
+export function relaunchResetIds(spec: FleetSpec, state: FleetState, nodeId: string): string[] {
   if (!state.nodes[nodeId]) throw new Error(`unknown node "${nodeId}"`);
-
   const dependents: Record<string, string[]> = {};
   for (const w of spec.workers) {
     for (const dep of w.depends_on) {
       (dependents[dep] ??= []).push(w.id);
     }
   }
-
-  const downstream = new Set<string>();
-  const walk = (id: string) => {
-    for (const d of dependents[id] ?? []) {
-      if (!downstream.has(d)) {
-        downstream.add(d);
-        walk(d);
-      }
+  const out = [nodeId];
+  const seen = new Set(out);
+  const queue = [nodeId];
+  while (queue.length) {
+    for (const d of dependents[queue.shift()!] ?? []) {
+      if (seen.has(d)) continue;
+      seen.add(d);
+      if (state.nodes[d]?.status === "blocked") out.push(d);
+      queue.push(d);
     }
-  };
-  walk(nodeId);
+  }
+  return out;
+}
 
+export function resetForRelaunch(state: FleetState, spec: FleetSpec, nodeId: string): FleetState {
   const fresh: NodeState = { status: "pending", turns: 0, tokens: 0, cost_usd_estimate: 0, produced_outputs: [] };
   const nodes = { ...state.nodes };
-  nodes[nodeId] = fresh;
-  for (const id of downstream) {
-    if (state.nodes[id].status === "blocked") {
-      nodes[id] = fresh;
-    }
+  for (const id of relaunchResetIds(spec, state, nodeId)) {
+    if (id !== nodeId && state.nodes[id]?.status !== "blocked") continue;
+    nodes[id] = fresh;
   }
 
   const cost = fleetCost({ ...state, nodes });

package/src/tools.ts

@@ -4,15 +4,15 @@ import { Type } from "typebox";
 import { validateFleetSpec } from "./dag.js";
 import { insertWorkers } from "./insert.js";
 import { loadPreferences, mergeFleetConfig } from "./preferences.js";
-import { activeFleet, currentState, dagPreview, ensureCanvas, killFleet, prepareRelaunch, startLoop, statusText, stopCanvas, updateWidget } from "./controller.js";
+import { activeFleet, currentState, dagPreview, ensureCanvas, killFleet, requestRelaunch, startLoop, statusText, stopCanvas, updateWidget } from "./controller.js";
 import { openInBrowser, listFleetRoots } from "./canvas.js";
 import { editConfig, editNode, type ConfigEditKey, type NodeEditKey } from "./edits.js";
-import { ensureFleetGitignore, fleetRootFor, isInsideGitRepo, persistFleetJson, writePlanFiles, writeWorkerPrompts } from "./fleet-store.js";
+import { ensureFleetGitignore, fleetRootFor, isInsideGitRepo, writePlanFiles, writeWorkerPrompts } from "./fleet-store.js";
 import { recoverLatestFleet } from "./fleet-recovery.js";
-import { listModelRefs, resolveModelReference, validateFleetModels } from "./model-resolution.js";
+import { listModelRefs, validateFleetModels } from "./model-resolution.js";
 import { runFleetDesign, slugifyFleetName } from "./planner.js";
 import { writeReport } from "./report.js";
-import { initFleetState, resetForRelaunch, writeState } from "./state.js";
+import { initFleetState, writeState } from "./state.js";
 import { renderDag } from "./viz.js";
 
 export function textResult(text: string, details: Record<string, unknown> = {}) {
@@ -88,7 +88,7 @@ export function registerFleetTools(pi: ExtensionAPI): void {
       const state = initFleetState(v.spec);
       await ensureFleetGitignore(ctx.cwd);
       await writePlanFiles(fleetRoot, v.spec, state);
-      const active = activeFleet.current = { spec: v.spec, fleetRoot, state, killSwitch: { killed: false }, pauseSwitch: { paused: false }, running: false, costWarned: false, sessions: new Map(), killedNodes: new Set(), widgetVisible: false };
+      const active = activeFleet.current = { spec: v.spec, fleetRoot, state, killSwitch: { killed: false }, pauseSwitch: { paused: false }, running: false, costWarned: false, sessions: new Map(), killedNodes: new Set(), relaunchRequests: new Set(), widgetVisible: false };
       updateWidget(ctx, active);
 
       const dag = await dagPreview(v.spec, undefined, fleetRoot);
@@ -242,7 +242,7 @@ export function registerFleetTools(pi: ExtensionAPI): void {
   pi.registerTool({
     name: "fleet_relaunch",
     label: "Fleet Relaunch",
-    description: "Relaunch a failed node and any blocked downstream dependents. Optionally override the worker model for this run.",
+    description: "Relaunch a failed node and any blocked downstream dependents. Works while the fleet is running (queued for the next scheduler pass) and after it stops. Optionally override the worker model for this run.",
     promptSnippet: "Relaunch a failed fleet node.",
     parameters: Type.Object({
       node_id: Type.String({ description: "Worker id to relaunch" }),
@@ -251,30 +251,12 @@ export function registerFleetTools(pi: ExtensionAPI): void {
     async execute(_id, params, _signal, _onUpdate, ctx) {
       const active = activeFleet.current;
       if (!active) return textResult("no fleet planned yet");
-      if (active.running) return textResult("fleet is running");
       const fleet = active;
       await currentState(fleet);
       if (fleet.state.status === "completed") return textResult("fleet completed, nothing to relaunch");
-      const worker = fleet.spec.workers.find((w) => w.id === params.node_id);
-      if (!worker) return textResult(`unknown node "${params.node_id}"`);
-      const node = fleet.state.nodes[params.node_id];
-      const relaunchable: ReadonlySet<string> = new Set(["failed", "contract_failed", "killed"]);
-      if (!node || !relaunchable.has(node.status)) {
-        return textResult(`node "${params.node_id}" status ${node?.status ?? "missing"} cannot be relaunched; must be failed, contract_failed, or killed`);
-      }
-      if (params.model) {
-        const resolved = resolveModelReference(ctx.modelRegistry, params.model);
-        if (!resolved.ok) return textResult(resolved.error);
-        const canonical = `${resolved.model.provider}/${resolved.model.id}`;
-        fleet.spec.workers = fleet.spec.workers.map((w) => w.id === params.node_id ? { ...w, model: canonical } : w);
-        await persistFleetJson(fleet);
-      }
-      fleet.state = resetForRelaunch(fleet.state, fleet.spec, params.node_id);
-      await writeState(fleet.fleetRoot, fleet.state);
-      await writeWorkerPrompts(fleet);
-      prepareRelaunch(fleet, params.node_id);
-      void startLoop(fleet, ctx, false, true);
-      return textResult(`fleet relaunch requested for ${params.node_id}`);
+      const result = await requestRelaunch(fleet, params.node_id, params.model, ctx.modelRegistry);
+      if (result.startNow) void startLoop(fleet, ctx, false, true);
+      return textResult(result.message);
     },
   });
 
@@ -353,7 +335,7 @@ 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, completed, or blocked nodes are refused; failed, contract_failed, and killed nodes can be edited so relaunch uses the updated task.",
+    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).",
     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" })),