pi-agent-fleet 0.4.0 → 0.5.0

package/src/tools.ts

@@ -1,4 +1,3 @@
-import { writeFile } from "node:fs/promises";
 import { join } from "node:path";
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import { Type } from "typebox";
@@ -8,8 +7,9 @@ import { loadPreferences, mergeFleetConfig } from "./preferences.js";
 import { activeFleet, currentState, dagPreview, ensureCanvas, killFleet, prepareRelaunch, 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 { ensureFleetGitignore, fleetRootFor, isInsideGitRepo, persistFleetJson, writePlanFiles, writeWorkerPrompts } from "./fleet-store.js";
+import { recoverLatestFleet } from "./fleet-recovery.js";
+import { listModelRefs, resolveModelReference, validateFleetModels } from "./model-resolution.js";
 import { runFleetDesign, slugifyFleetName } from "./planner.js";
 import { writeReport } from "./report.js";
 import { initFleetState, resetForRelaunch, writeState } from "./state.js";
@@ -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(), 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,6 +212,33 @@ 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",
@@ -216,10 +267,11 @@ export function registerFleetTools(pi: ExtensionAPI): void {
         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");
+        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}`);
@@ -289,7 +341,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 +353,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, completed, or blocked nodes are refused; failed, contract_failed, and killed nodes can be edited so relaunch uses the updated task.",
     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(() => {});
+}