pi-agent-fleet 0.4.0 → 0.6.0

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, "");
@@ -100,6 +111,16 @@ export function buildWorkerPrompt(opts: {
   } else {
     for (const o of worker.outputs) {
       out.push(`- ${o.path} (${o.kind}${o.required ? ", REQUIRED" : ", optional"})`);
+      if (o.kind === "json" && o.schema) {
+        const bits: string[] = [];
+        if (o.schema.required_keys && o.schema.required_keys.length > 0) {
+          bits.push(`must be a JSON object containing keys: ${o.schema.required_keys.join(", ")}`);
+        }
+        if (o.schema.number_keys && o.schema.number_keys.length > 0) {
+          bits.push(`these keys must be numbers or arrays of numbers: ${o.schema.number_keys.join(", ")}`);
+        }
+        if (bits.length > 0) out.push(`  - ${bits.join("; ")}`);
+      }
     }
     out.push("");
   }

package/src/report.ts

@@ -1,5 +1,5 @@
 import { execFile } from "node:child_process";
-import { writeFile } from "node:fs/promises";
+import { readFile, writeFile } from "node:fs/promises";
 import { basename, join } from "node:path";
 import { promisify } from "node:util";
 import type { FleetSpec, FleetState } from "./types.js";
@@ -72,6 +72,33 @@ export async function writeReport(opts: {
       if (w.worktree) lines.push(`- fleet/${base}/${w.id}`);
     }
   }
+  lines.push("", "## Next steps", "");
+  const reportPath = join(fleetRoot, "report.md");
+  const failed = Object.entries(state.nodes).find(([, n]) => n.status === "failed" || n.status === "contract_failed");
+  const next = state.status === "planned" ? "fleet_launch"
+    : state.status === "running" ? "fleet_status, fleet_canvas, or fleet_kill <id>|all"
+    : failed ? `fleet_relaunch ${failed[0]}`
+    : state.status === "completed" ? `read report ${reportPath}`
+    : `inspect ${join(fleetRoot, "state.json")}`;
+  lines.push(`- next: ${next}`);
+  lines.push("", "## JSON outputs", "");
+  let anyJson = false;
+  for (const w of spec.workers) {
+    const n = state.nodes[w.id];
+    for (const out of n?.produced_outputs ?? []) {
+      if (!out.startsWith("output/") || !out.endsWith(".json") || out.includes("..")) continue;
+      anyJson = true;
+      let content: string;
+      try {
+        const raw = await readFile(join(fleetRoot, "workers", w.id, out), "utf-8");
+        content = raw.length > 4096 ? `${raw.slice(0, 4096)}\n... (truncated)` : raw;
+      } catch {
+        content = "(unreadable)";
+      }
+      lines.push(`### ${w.id}: ${out}`, "", "```json", content.trimEnd(), "```", "");
+    }
+  }
+  if (!anyJson) lines.push("(none)", "");
   lines.push("", "## Code changes", "", "```", await gitDiffStat(repoCwd, state.created_at), "```", "");
   lines.push("## Artifacts", "", `- state: ${join(fleetRoot, "state.json")}`,
     `- sessions: ${join(fleetRoot, "workers", "<id>", "session.jsonl")}`, "");

package/src/scheduler.ts

@@ -1,7 +1,7 @@
 import { mkdir, rm } from "node:fs/promises";
 import { join } from "node:path";
-import { verifyOutputs } from "./contracts.js";
-import { archiveIteration, initFleetState, patchNode, resetForIteration, snapshotIteration, writeState } from "./state.js";
+import { contractFailureNote, verifyOutputs } from "./contracts.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(),
@@ -258,7 +297,8 @@ export async function runFleet(opts: RunFleetOpts): Promise<FleetState> {
             tokens: res.tokens,
             cost_usd_estimate: res.cost ?? 0,
             contract_result: contract,
-            produced_outputs: contract.checks.filter((c) => c.ok).map((c) => c.path),
+            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(" · "),
           });
           if (contract.ok) {
             const note = await opts.onNodeCompleted?.(w.id);
@@ -279,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";
@@ -310,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

@@ -1,18 +1,18 @@
-import { writeFile } from "node:fs/promises";
 import { join } from "node:path";
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 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, writePlanFiles, writeWorkerPrompts } from "./fleet-store.js";
-import { resolveModelReference, validateFleetModels } from "./model-resolution.js";
+import { recoverLatestFleet } from "./fleet-recovery.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> = {}) {
@@ -27,6 +27,10 @@ export function registerFleetTools(pi: ExtensionAPI): void {
       Type.Literal("verdict"), Type.Literal("json"), Type.Literal("yaml"),
     ]),
     required: Type.Optional(Type.Boolean()),
+    schema: Type.Optional(Type.Object({
+      required_keys: Type.Optional(Type.Array(Type.String(), { description: "JSON object keys that must be present" })),
+      number_keys: Type.Optional(Type.Array(Type.String(), { description: "JSON object keys that must be numbers or arrays of numbers" })),
+    }, { description: "Optional JSON object shape; only valid with kind json" })),
   });
   const EffortSchema = Type.Union([
     Type.Literal("off"), Type.Literal("minimal"), Type.Literal("low"),
@@ -67,7 +71,7 @@ export function registerFleetTools(pi: ExtensionAPI): void {
     name: "fleet_plan",
     label: "Fleet Plan",
     description:
-      "Validate a fleet DAG definition, create its fleet root, and return an ASCII preview. Does NOT launch. PREREQUISITE: if the user's request is prose requirements or a goal rather than an explicit fleet definition, you MUST call fleet_design first and pass its drafted definition here — do not hand-write the fleet JSON yourself. Present the preview to the user; call fleet_launch only after they explicitly confirm. Choose models by task difficulty: cheap/fast models for trivial writers and validators, mid-tier coding models for code-run workers, strongest reasoning models for reviewers and synthesizers. When several models fit a tier, vary providers across nodes instead of defaulting to one family. Set worker.model per node to override config.model. All model refs are validated against the live registry — planning fails if any model is unavailable.",
+      "Validate a fleet DAG definition, create its fleet root, and return an ASCII preview. Does NOT launch. PREREQUISITE: if the user's request is prose requirements or a goal rather than an explicit fleet definition, you MUST call fleet_design first and pass its drafted definition here — do not hand-write the fleet JSON yourself. Present the preview to the user; call fleet_launch only after they explicitly confirm. Choose models by task difficulty: cheap/fast models for trivial writers and validators, mid-tier coding models for code-run workers, strongest reasoning models for reviewers and synthesizers. When several models fit a tier, vary providers across nodes instead of defaulting to one family. Set worker.model per node to override config.model. All model refs are validated against the live registry — planning fails if any model is unavailable. Call fleet_models first if you do not know exact provider/model IDs.",
     promptSnippet: "Plan a DAG-of-agents fleet from a fleet definition without launching it.",
     parameters: Type.Object({
       fleet: FleetSchema,
@@ -84,11 +88,12 @@ 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() };
+      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);
-      return textResult(`${dag}\n\nfleet root: ${fleetRoot}\nShow this preview to the user. Call fleet_launch only after they explicitly confirm.`, { fleetRoot, layers: v.layers });
+      const canvas = ctx.hasUI ? await ensureCanvas(ctx) : undefined;
+      return textResult(`${dag}\n\nfleet root: ${fleetRoot}${canvas ? `\nfleet canvas: ${canvas.url}` : ""}\n\nShow this preview to the user. Call fleet_launch only after they explicitly confirm.`, { fleetRoot, layers: v.layers, canvasUrl: canvas?.url });
     },
   });
 
@@ -117,14 +122,32 @@ export function registerFleetTools(pi: ExtensionAPI): void {
         }
       }
 
+      if (fleet.state.status !== "planned" || Object.values(fleet.state.nodes).some((n) => n.status !== "pending")) {
+        return textResult(
+          `fleet already started (${fleet.state.status}); use fleet_continue to resume pending work, fleet_relaunch <node_id> to retry a failed node, or start a new fleet with fleet_plan`,
+        );
+      }
+
       if (ctx.hasUI && !params.skip_confirm) {
         const ok = await ctx.ui.confirm("Launch fleet?", renderDag(fleet.spec));
         if (!ok) return textResult("fleet launch aborted");
       }
 
       await writeWorkerPrompts(fleet);
+      const canvas = ctx.hasUI ? await ensureCanvas(ctx) : undefined;
       void startLoop(fleet, ctx, false);
-      return textResult("fleet launched");
+      return textResult(`fleet launched${canvas ? `\n\nfleet canvas: ${canvas.url}` : ""}`, { canvasUrl: canvas?.url });
+    },
+  });
+
+  pi.registerTool({
+    name: "fleet_models",
+    label: "Fleet Models",
+    description: "List available model refs (provider/id) from the live registry. Call this before fleet_plan if you do not know exact provider/model IDs.",
+    promptSnippet: "List available fleet model refs.",
+    parameters: Type.Object({}),
+    async execute(_id, _params, _signal, _onUpdate, ctx) {
+      return textResult(`available models:\n${listModelRefs(ctx.modelRegistry).join("\n")}`);
     },
   });
 
@@ -134,8 +157,9 @@ export function registerFleetTools(pi: ExtensionAPI): void {
     description: "Show the current active fleet DAG and live widget lines.",
     promptSnippet: "Show current active fleet status.",
     parameters: Type.Object({}),
-    async execute() {
-      const active = activeFleet.current;
+    async execute(_id, _params, _signal, _onUpdate, ctx) {
+      const active = activeFleet.current ?? await recoverLatestFleet(ctx.cwd);
+      if (active) activeFleet.current ??= active;
       if (!active) return textResult("no fleet planned yet");
       return textResult(await statusText(active));
     },
@@ -147,8 +171,8 @@ export function registerFleetTools(pi: ExtensionAPI): void {
     description: "Request a fleet-wide kill (target \"all\") or kill a single node by worker id. Killing a running node aborts its session; killing a pending node marks it killed at the next dispatch pass. Killed nodes can be revived with fleet_relaunch.",
     promptSnippet: "Kill the whole fleet or a single node by worker id.",
     parameters: Type.Object({ target: Type.String({ description: "all or a worker id" }) }),
-    async execute(_id, params) {
-      return textResult(await killFleet(params.target));
+    async execute(_id, params, _signal, _onUpdate, ctx) {
+      return textResult(await killFleet(params.target, ctx.cwd));
     },
   });
 
@@ -188,10 +212,37 @@ export function registerFleetTools(pi: ExtensionAPI): void {
     },
   });
 
+  pi.registerTool({
+    name: "fleet_continue",
+    label: "Fleet Continue",
+    description: "Continue the active fleet from its current state without restarting completed nodes. Dispatches pending and ready nodes and unblocks downstream as dependencies complete. Use this after a failed/killed fleet to resume work safely.",
+    promptSnippet: "Continue the active fleet from current state.",
+    parameters: Type.Object({}),
+    async execute(_id, _params, _signal, _onUpdate, ctx) {
+      const active = activeFleet.current ?? await recoverLatestFleet(ctx.cwd);
+      if (active) activeFleet.current ??= active;
+      if (!active) return textResult("no fleet planned yet");
+      if (active.running) return textResult("fleet already running");
+      await currentState(active);
+      if (active.state.status === "completed") return textResult("fleet completed, nothing to continue");
+      if (active.state.status === "paused") return textResult("fleet is paused; use fleet_resume for paused loop fleets");
+      if (active.state.status === "planned" && Object.values(active.state.nodes).every((n) => n.status === "pending")) {
+        return textResult("fleet has not started; use fleet_launch");
+      }
+      active.killSwitch.killed = false;
+      active.pauseSwitch.paused = false;
+      active.state = { ...active.state, status: "running", paused: false };
+      await writeState(active.fleetRoot, active.state);
+      await writeWorkerPrompts(active);
+      void startLoop(active, ctx, false, true);
+      return textResult("fleet continue requested");
+    },
+  });
+
   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" }),
@@ -200,29 +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 writeFile(join(fleet.fleetRoot, "fleet.json"), `${JSON.stringify(fleet.spec, null, 2)}\n`, "utf-8");
-      }
-      fleet.state = resetForRelaunch(fleet.state, fleet.spec, params.node_id);
-      await writeState(fleet.fleetRoot, fleet.state);
-      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);
     },
   });
 
@@ -289,7 +323,8 @@ export function registerFleetTools(pi: ExtensionAPI): void {
     promptSnippet: "Regenerate the active fleet report.",
     parameters: Type.Object({}),
     async execute(_id, _params, _signal, _onUpdate, ctx) {
-      const active = activeFleet.current;
+      const active = activeFleet.current ?? await recoverLatestFleet(ctx.cwd);
+      if (active) activeFleet.current ??= active;
       if (!active) return textResult("no fleet planned yet");
       const state = await currentState(active);
       const report = await writeReport({ spec: active.spec, state, fleetRoot: active.fleetRoot, repoCwd: ctx.cwd });
@@ -300,7 +335,7 @@ export function registerFleetTools(pi: ExtensionAPI): void {
   pi.registerTool({
     name: "fleet_edit",
     label: "Fleet Edit",
-    description: "Edit the active fleet: a pending 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 to nodes not yet dispatched. Refuses edits to nodes already running or terminal.",
+    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" })),

package/src/types.ts

@@ -1,9 +1,15 @@
 export type OutputKind = "markdown" | "file-exists" | "verdict" | "json" | "yaml";
 
+export interface JsonOutputSchema {
+  required_keys?: string[];
+  number_keys?: string[];
+}
+
 export interface ContractOutput {
   path: string;
   kind: OutputKind;
   required: boolean;
+  schema?: JsonOutputSchema;
 }
 
 export type WorkerType = "research" | "code-run" | "reviewer" | "write" | "read-only";
@@ -64,6 +70,8 @@ export interface ContractCheck {
   required: boolean;
   ok: boolean;
   error?: string;
+  actualPath?: string;
+  firstLines?: string;
 }
 
 export interface ContractResult {

package/src/worktree.ts

@@ -17,6 +17,7 @@ export async function createWorktree(opts: CreateWorktreeOpts): Promise<string>
   const branch = `fleet/${opts.fleetName}/${opts.nodeId}`;
   await mkdir(path, { recursive: true });
   await removeWorktree(path, opts.baseRepo);
+  await removeBranch(opts.baseRepo, branch);
   await execFileP("git", ["worktree", "add", "-b", branch, path], { cwd: opts.baseRepo });
   return path;
 }
@@ -55,6 +56,7 @@ export async function prepareIntegratorWorktree(
 ): Promise<{ path: string; ok: boolean; conflict?: string }> {
   const path = join(opts.fleetRoot, "worktrees", "fleet-integrator");
   await removeWorktree(path, opts.baseRepo);
+  await removeBranch(opts.baseRepo, `fleet/${opts.fleetName}/fleet-integrator`);
   await mkdir(path, { recursive: true });
   await execFileP("git", ["worktree", "add", "-b", `fleet/${opts.fleetName}/fleet-integrator`, path], {
     cwd: opts.baseRepo,
@@ -73,3 +75,7 @@ export async function prepareIntegratorWorktree(
 export async function removeWorktree(path: string, baseRepo: string): Promise<void> {
   await execFileP("git", ["worktree", "remove", "--force", path], { cwd: baseRepo }).catch(() => {});
 }
+
+export async function removeBranch(baseRepo: string, branch: string): Promise<void> {
+  await execFileP("git", ["branch", "-D", branch], { cwd: baseRepo }).catch(() => {});
+}