pi-agent-fleet 0.2.0 → 0.3.0

package/src/command.ts

@@ -0,0 +1,247 @@
+import { writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { activeFleet, currentState, ensureCanvas, killFleet, prepareRelaunch, startLoop, stopCanvas, updateWidget } from "./controller.js";
+import { openInBrowser, listFleetRoots } from "./canvas.js";
+import { insertWorkers } from "./insert.js";
+import { editConfig, editNode, type ConfigEditKey, type NodeEditKey } from "./edits.js";
+import { resolveModelReference } from "./model-resolution.js";
+import { clearPreference, loadPreferences, PREFERENCE_KEYS, savePreferences, setPreference } from "./preferences.js";
+import { resetForRelaunch, writeState } from "./state.js";
+import { buildWidgetLines } from "./ui.js";
+import { renderDag } from "./viz.js";
+
+export function registerFleetCommand(pi: ExtensionAPI): void {
+  pi.registerCommand("fleet", {
+    description: "Fleet commands: /fleet viz, /fleet status, /fleet canvas [stop], /fleet configure [show|set k v], /fleet add <json>, /fleet edit <node_id>|config ..., /fleet clear, /fleet kill all|<node_id>, /fleet pause, /fleet resume, /fleet relaunch <node_id> [model]",
+    handler: async (args, ctx) => {
+      const [cmd, target] = args.trim().split(/\s+/);
+      if (cmd === "configure") {
+        const parts = args.trim().split(/\s+/).filter((s) => s.length > 0);
+        const sub = parts[1];
+        if (sub === "show") {
+          const prefs = await loadPreferences();
+          ctx.ui.notify(JSON.stringify(prefs, null, 2), "info");
+          return;
+        }
+        if (sub === "set") {
+          const key = parts[2];
+          const value = parts.slice(3).join(" ");
+          if (!key || !value) {
+            ctx.ui.notify("usage: /fleet configure set <key> <value>", "warning");
+            return;
+          }
+          const prefs = await loadPreferences();
+          const r = setPreference(prefs, key, value);
+          if (!r.ok) {
+            ctx.ui.notify(r.error, "error");
+            return;
+          }
+          await savePreferences(r.prefs);
+          ctx.ui.notify(`preference ${key} saved`, "info");
+          return;
+        }
+        // interactive wizard
+        while (true) {
+          const prefs = await loadPreferences();
+          const options = PREFERENCE_KEYS.map((k) => `${k}: ${prefs[k] ?? "—"}`);
+          const field = await ctx.ui.select("Fleet preferences (empty input clears a field):", [...options, "done"]);
+          if (!field || field === "done") break;
+          const key = field.split(":")[0] as (typeof PREFERENCE_KEYS)[number];
+          const input = await ctx.ui.input(`${key} (current: ${prefs[key] ?? "—"}):`, "empty clears");
+          if (input === undefined) break;
+          const next = input.trim().length === 0
+            ? clearPreference(prefs, key)
+            : (() => {
+                const r = setPreference(prefs, key, input.trim());
+                if (!r.ok) return undefined;
+                return r.prefs;
+              })();
+          if (next === undefined) {
+            ctx.ui.notify(`invalid value for ${key}`, "error");
+            continue;
+          }
+          await savePreferences(next);
+        }
+        ctx.ui.notify("preferences saved", "info");
+        return;
+      }
+      if (cmd === "canvas") {
+        const sub = args.trim().split(/\s+/)[1];
+        if (sub === "stop") {
+          await stopCanvas();
+          ctx.ui.notify("fleet canvas stopped", "info");
+          return;
+        }
+        const server = await ensureCanvas(ctx);
+        let url = server.url;
+        if (sub) {
+          const roots = await listFleetRoots(ctx.cwd);
+          if (!roots.some((r) => r.name === sub)) {
+            ctx.ui.notify(`unknown fleet "${sub}" (see /api/fleets on the canvas server)`, "error");
+            return;
+          }
+          url = `${url}?fleet=${encodeURIComponent(sub)}`;
+        }
+        await openInBrowser(url);
+        ctx.ui.notify(`fleet canvas: ${url}`, "info");
+        return;
+      }
+      const active = activeFleet.current;
+      if (!active) {
+        ctx.ui.notify("no fleet planned yet", "warning");
+        return;
+      }
+      if (cmd === "viz") {
+        const lines = renderDag(active.spec, active.state).split("\n");
+        ctx.ui.setWidget("fleet", lines);
+        return;
+      }
+      if (cmd === "status" || cmd === "") {
+        ctx.ui.setWidget("fleet", buildWidgetLines(active.spec, active.state));
+        return;
+      }
+      if (cmd === "clear") {
+        ctx.ui.setWidget("fleet", []);
+        return;
+      }
+      if (cmd === "kill") {
+        const text = await killFleet(target ?? "");
+        const severity = text.includes("kill") && !text.startsWith("unknown") && !text.includes("already") ? "warning" : "error";
+        ctx.ui.notify(text, severity);
+        return;
+      }
+      if (cmd === "pause") {
+        if (!active.spec.config.loop) {
+          ctx.ui.notify("fleet has no loop; pause is a loop-fleet operation", "warning");
+          return;
+        }
+        if (!active.running) {
+          ctx.ui.notify("fleet not running", "warning");
+          return;
+        }
+        active.pauseSwitch.paused = true;
+        active.state = { ...active.state, paused: true };
+        await writeState(active.fleetRoot, active.state);
+        updateWidget(ctx, active);
+        ctx.ui.notify("pause requested (takes effect at next iteration boundary)", "warning");
+        return;
+      }
+      if (cmd === "resume") {
+        if (active.state.status !== "paused") {
+          ctx.ui.notify("fleet is not paused", "warning");
+          return;
+        }
+        if (active.running) {
+          ctx.ui.notify("fleet already running", "warning");
+          return;
+        }
+        active.pauseSwitch.paused = false;
+        void startLoop(active, ctx, true);
+        ctx.ui.notify("fleet resumed", "info");
+        return;
+      }
+      if (cmd === "relaunch") {
+        if (!target) {
+          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 writeFile(join(active.fleetRoot, "fleet.json"), `${JSON.stringify(active.spec, null, 2)}\n`, "utf-8");
+        }
+        active.state = resetForRelaunch(active.state, active.spec, target);
+        await writeState(active.fleetRoot, active.state);
+        prepareRelaunch(active, target);
+        void startLoop(active, ctx, false, true);
+        ctx.ui.notify(`fleet relaunch requested for ${target}`, "info");
+        return;
+      }
+      if (cmd === "add") {
+        const body = args.trim().replace(/^add\s*/, "");
+        if (!body) {
+          ctx.ui.notify("usage: /fleet add <json>", "warning");
+          return;
+        }
+        let parsed: unknown;
+        try {
+          parsed = JSON.parse(body);
+        } catch (e) {
+          ctx.ui.notify(`invalid JSON: ${(e as Error).message}`, "error");
+          return;
+        }
+        await currentState(active);
+        const r = await insertWorkers(active, parsed, ctx.modelRegistry);
+        ctx.ui.notify(r.message, r.ok ? "info" : "error");
+        if (r.ok) updateWidget(ctx, active);
+        return;
+      }
+      if (cmd === "edit") {
+        const parts = args.trim().split(/\s+/).filter((s) => s.length > 0);
+        const target = parts[1];
+        const key = parts[2];
+        let value = parts.slice(3).join(" ");
+        if (!target || !key) {
+          ctx.ui.notify("usage: /fleet edit <node_id> model|effort <value> | /fleet edit <node_id> task [text] | /fleet edit config <key> <value>", "warning");
+          return;
+        }
+        await currentState(active);
+        if (target === "config") {
+          if (!value) {
+            ctx.ui.notify("usage: /fleet edit config max_concurrent|warn_cost_usd|model|effort <value>", "warning");
+            return;
+          }
+          const r = await editConfig(active, key as ConfigEditKey, value, ctx.modelRegistry);
+          ctx.ui.notify(r.message, r.ok ? "info" : "error");
+          if (r.ok) updateWidget(ctx, active);
+          return;
+        }
+        if (key === "task" && !value) {
+          const current = active.spec.workers.find((w) => w.id === target)?.task ?? "";
+          const edited = await ctx.ui.editor(`task for ${target}:`, current);
+          if (edited === undefined) {
+            ctx.ui.notify("edit cancelled", "warning");
+            return;
+          }
+          value = edited;
+        }
+        if (!value) {
+          ctx.ui.notify("usage: /fleet edit <node_id> model|effort <value> | /fleet edit <node_id> task [text]", "warning");
+          return;
+        }
+        const r = await editNode(active, target, key as NodeEditKey, value, ctx.modelRegistry);
+        ctx.ui.notify(r.message, r.ok ? "info" : "error");
+        if (r.ok) updateWidget(ctx, active);
+        return;
+      }
+      ctx.ui.notify("usage: /fleet viz | /fleet status | /fleet canvas [stop] | /fleet configure [show|set k v] | /fleet add <json> | /fleet edit <node_id>|config ... | /fleet clear | /fleet kill all|<node_id> | /fleet pause | /fleet resume | /fleet relaunch <node_id> [model]", "warning");
+    },
+  });
+}

package/src/controller.ts

@@ -0,0 +1,296 @@
+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 { 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 type { FleetSpec, FleetState } from "./types.js";
+import { TERMINAL_NODE_STATUSES } from "./types.js";
+import { buildWidgetLines } from "./ui.js";
+import { dagNeedsFileFallback, renderDag } from "./viz.js";
+import { startCanvasServer, type CanvasServer } from "./canvas.js";
+
+export interface ActiveFleet {
+  spec: FleetSpec;
+  fleetRoot: string;
+  state: FleetState;
+  killSwitch: { killed: boolean };
+  pauseSwitch: { paused: boolean };
+  running: boolean;
+  costWarned?: boolean;
+  sessions: Map<string, AgentSessionLike>;
+  killedNodes: Set<string>;
+}
+
+export interface ActiveFleetCell {
+  current: ActiveFleet | undefined;
+}
+
+export const activeFleet: ActiveFleetCell = { current: undefined };
+
+export function updateWidget(ctx: ExtensionContext, fleet: ActiveFleet, spinnerFrame?: number): void {
+  if (ctx.hasUI) ctx.ui.setWidget("fleet", buildWidgetLines(fleet.spec, fleet.state, { spinnerFrame }));
+}
+
+export function startSpinner(ctx: ExtensionContext, fleet: ActiveFleet, intervalMs = 150): () => void {
+  if (!ctx.hasUI) return () => {};
+  let frame = 0;
+  const timer = setInterval(() => {
+    frame++;
+    updateWidget(ctx, fleet, frame);
+  }, intervalMs);
+  if (typeof timer.unref === "function") timer.unref();
+  return () => clearInterval(timer);
+}
+
+export async function currentState(fleet: ActiveFleet): Promise<FleetState> {
+  if (fleet.running) return fleet.state;
+  try {
+    fleet.state = await readState(fleet.fleetRoot);
+  } catch {
+    // keep in-memory state
+  }
+  return fleet.state;
+}
+
+export async function statusText(fleet: ActiveFleet): Promise<string> {
+  const state = await currentState(fleet);
+  return renderDag(fleet.spec, state);
+}
+
+export async function dagPreview(spec: FleetSpec, state: FleetState | undefined, fleetRoot: string): Promise<string> {
+  const out = renderDag(spec, state);
+  const width = process.stdout.columns ?? 120;
+  if (dagNeedsFileFallback(spec, width)) {
+    const p = join(fleetRoot, "dag.txt");
+    await writeFile(p, out, "utf-8");
+    return `${out}\n\nDAG preview saved: ${p}`;
+  }
+  return out;
+}
+
+export function prepareRelaunch(fleet: ActiveFleet, nodeId: string): void {
+  fleet.killedNodes.delete(nodeId);
+  fleet.killSwitch.killed = false;
+  fleet.pauseSwitch.paused = false;
+}
+
+export function registerNodeSession(fleet: ActiveFleet, nodeId: string, session: AgentSessionLike): void {
+  fleet.sessions.set(nodeId, session);
+  if (fleet.killedNodes.has(nodeId)) void session.abort().catch(() => {});
+}
+
+export async function drainNodeRequests(
+  fleet: ActiveFleet,
+  nodeId: string,
+  registry: ModelRegistryLike,
+): Promise<string | undefined> {
+  const p = join(fleet.fleetRoot, "workers", nodeId, "output", "node-requests.json");
+  let raw: string;
+  try {
+    raw = await readFile(p, "utf-8");
+  } catch {
+    return undefined;
+  }
+  let parsed: unknown;
+  try {
+    parsed = JSON.parse(raw);
+  } catch (e) {
+    return `node-requests.json invalid JSON: ${(e as Error).message}`;
+  }
+  const r = await insertWorkers(fleet, parsed, registry);
+  if (!r.ok) {
+    const detail = r.message.replace("invalid node insertion:\n", "").split("\n")[0];
+    return `node-requests rejected: ${detail}`;
+  }
+  return undefined;
+}
+
+export async function startLoop(fleet: ActiveFleet, ctx: ExtensionContext, resume = false, continuePass = false): Promise<void> {
+  let resumeFrom: FleetState | undefined;
+  try {
+    if (continuePass) {
+      resumeFrom = fleet.state;
+    } else if (resume) {
+      resumeFrom = await readState(fleet.fleetRoot);
+    }
+  } catch (err: unknown) {
+    fleet.running = false;
+    const error = err instanceof Error ? err.message : String(err);
+    if (ctx.hasUI) ctx.ui.notify(`fleet failed: ${error}`, "error");
+    return;
+  }
+
+  fleet.running = true;
+  fleet.costWarned = false;
+  fleet.state = { ...fleet.state, status: "running" };
+  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");
+    }
+  };
+
+  const spawn = async (nodeId: string) => {
+    try {
+      const worker = fleet.spec.workers.find((w) => w.id === nodeId);
+      if (!worker) return { ok: false, turns: 0, tokens: 0, error: `unknown worker "${nodeId}"` };
+
+      let resolvedModel: Model<Api> | undefined;
+      let modelNote: string | undefined;
+      if (worker.model) {
+        const resolved = resolveModelReference(ctx.modelRegistry, worker.model);
+        if (!resolved.ok) return { ok: false, turns: 0, tokens: 0, error: resolved.error };
+        resolvedModel = resolved.model;
+      } else if (fleet.spec.config.model) {
+        const resolved = resolveModelReference(ctx.modelRegistry, fleet.spec.config.model);
+        if (resolved.ok) resolvedModel = resolved.model;
+        else modelNote = `config.model "${fleet.spec.config.model}" not found, using session default`;
+      }
+      if (modelNote) {
+        fleet.state = patchNode(fleet.fleetRoot, fleet.state, nodeId, { status_note: modelNote });
+        updateWidget(ctx, fleet);
+      }
+
+      const prompt = await readFile(join(fleet.fleetRoot, "workers", nodeId, "prompt.md"), "utf-8");
+      const sessionDir = join(fleet.fleetRoot, "workers", nodeId);
+      const effort = worker.effort ?? fleet.spec.config.effort ?? "medium";
+      try {
+        return await runWorker({
+          nodeId,
+          worker: workerWithResolvedModel(worker, resolvedModel),
+          prompt,
+          repoCwd: ctx.cwd,
+          sessionDir,
+          thinkingLevel: effort,
+          sessionFactory: resolvedModel ? sessionFactoryForModel(resolvedModel) : undefined,
+          onSession: (s) => registerNodeSession(fleet, nodeId, s),
+          onEvent: (e) => {
+            if (e.type === "turn") fleet.state = patchNode(fleet.fleetRoot, fleet.state, nodeId, { turns: e.turns });
+            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();
+            }
+            if (e.type === "error") fleet.state = patchNode(fleet.fleetRoot, fleet.state, nodeId, { status_note: e.message });
+            updateWidget(ctx, fleet);
+          },
+        });
+      } finally {
+        fleet.sessions.delete(nodeId);
+      }
+    } catch (err) {
+      const error = err instanceof Error ? err.message : String(err);
+      return { ok: false, turns: 0, tokens: 0, error };
+    }
+  };
+
+  try {
+    const state = await runFleet({
+      spec: fleet.spec,
+      fleetRoot: fleet.fleetRoot,
+      repoCwd: (nodeId) => {
+        const worker = fleet.spec.workers.find((w) => w.id === nodeId);
+        return worker?.worktree ? join(fleet.fleetRoot, "worktrees", nodeId) : ctx.cwd;
+      },
+      spawn,
+      killSwitch: fleet.killSwitch,
+      pauseSwitch: fleet.pauseSwitch,
+      nodeKills: fleet.killedNodes,
+      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();
+        updateWidget(ctx, fleet);
+      },
+      onNodeAdded: (w) => {
+        fleet.state = {
+          ...fleet.state,
+          nodes: {
+            ...fleet.state.nodes,
+            [w.id]: { status: "pending", turns: 0, tokens: 0, cost_usd_estimate: 0, produced_outputs: [] },
+          },
+        };
+        updateWidget(ctx, fleet);
+      },
+      onNodeCompleted: async (nodeId) => {
+        const note = await drainNodeRequests(fleet, nodeId, ctx.modelRegistry);
+        if (!note) updateWidget(ctx, fleet);
+        return note;
+      },
+      prepareIteration: async (_n, state) => {
+        fleet.state = state;
+        await writeWorkerPrompts(fleet);
+      },
+      resumeFrom,
+      continuePass,
+    });
+    fleet.state = state;
+    fleet.running = false;
+    stopSpinner();
+    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 });
+    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");
+    } else if (ctx.hasUI) {
+      ctx.ui.notify(`fleet ${state.status}; report: ${join(fleet.fleetRoot, "report.md")}`, state.status === "completed" ? "info" : "warning");
+    }
+  } catch (err: unknown) {
+    fleet.running = false;
+    stopSpinner();
+    updateWidget(ctx, fleet);
+    const error = err instanceof Error ? err.message : String(err);
+    if (ctx.hasUI) ctx.ui.notify(`fleet failed: ${error}`, "error");
+  }
+}
+
+export async function killFleet(target: string): Promise<string> {
+  const active = activeFleet.current;
+  if (!active) return "no fleet planned yet";
+  if (target === "all") {
+    active.killSwitch.killed = true;
+    return "fleet kill requested";
+  }
+  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}`;
+  active.killedNodes.add(target);
+  const session = active.sessions.get(target);
+  if (session) {
+    void session.abort().catch(() => {});
+    return `node "${target}" kill requested`;
+  }
+  if (!active.running) {
+    active.state = patchNode(active.fleetRoot, active.state, target, { status: "killed", ended_at: new Date().toISOString() });
+    await writeState(active.fleetRoot, active.state);
+    return `node "${target}" killed`;
+  }
+  return `node "${target}" kill requested`;
+}
+
+let canvas: Promise<CanvasServer> | undefined;
+
+export async function ensureCanvas(ctx: ExtensionContext): Promise<CanvasServer> {
+  canvas ??= startCanvasServer({ getFleet: () => activeFleet.current, cwd: ctx.cwd });
+  return canvas;
+}
+
+export async function stopCanvas(): Promise<void> {
+  const current = canvas;
+  canvas = undefined;
+  if (current) (await current).close();
+}

package/src/dag.ts

@@ -1,4 +1,5 @@
-import type { FleetSpec, GateKind, LoopConfig, OutputKind, WorkerSpec, WorkerType } from "./types.js";
+import type { FleetSpec, GateKind, LoopConfig, OutputKind, ThinkingLevelName, WorkerSpec, WorkerType } from "./types.js";
+import { THINKING_LEVELS } from "./types.js";
 
 export class CycleError extends Error {
   constructor(public remaining: string[]) {
@@ -9,6 +10,7 @@ export class CycleError extends Error {
 
 const WORKER_TYPES: WorkerType[] = ["research", "code-run", "reviewer", "write", "read-only"];
 const KINDS: OutputKind[] = ["markdown", "file-exists", "verdict", "json", "yaml"];
+
 const ID_RE = /^[a-z0-9][a-z0-9-]*$/;
 
 export function topoLayers(spec: FleetSpec): string[][] {
@@ -59,7 +61,11 @@ export function validateFleetSpec(
   const cfg = (r?.config ?? {}) as Record<string, unknown>;
   const maxConcurrent = typeof cfg.max_concurrent === "number" ? cfg.max_concurrent : 4;
   if (maxConcurrent < 1) errors.push("config.max_concurrent must be >= 1");
-  const model = typeof cfg.model === "string" ? cfg.model : "gpt-5.4";
+  const model = typeof cfg.model === "string" ? cfg.model : undefined;
+  const effort = typeof cfg.effort === "string" ? cfg.effort as ThinkingLevelName : undefined;
+  if (effort !== undefined && !THINKING_LEVELS.includes(effort)) {
+    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 rawWorkers = Array.isArray(r?.workers) ? (r.workers as Record<string, unknown>[]) : [];
@@ -86,11 +92,16 @@ export function validateFleetSpec(
         }
       }
     }
+    const wEffort = typeof w.effort === "string" ? w.effort as ThinkingLevelName : undefined;
+    if (wEffort !== undefined && !THINKING_LEVELS.includes(wEffort)) {
+      errors.push(`worker "${id}": bad effort "${String(w.effort)}"`);
+    }
     workers.push({
       id,
       type,
       task: String(w.task ?? ""),
       model: typeof w.model === "string" ? w.model : undefined,
+      effort: wEffort,
       depends_on: Array.isArray(w.depends_on) ? (w.depends_on as string[]) : [],
       outputs: outputs.map((o) => ({ path: String(o.path), kind: o.kind as OutputKind, required: o.required !== false })),
       iterate: w.iterate !== false,
@@ -172,7 +183,7 @@ export function validateFleetSpec(
   const spec: FleetSpec = {
     fleet_name: String(r?.fleet_name ?? ""),
     type: "dag",
-    config: { max_concurrent: maxConcurrent, model, warn_cost_usd: warnCost, loop: loopConfig },
+    config: { max_concurrent: maxConcurrent, model, effort, warn_cost_usd: warnCost, loop: loopConfig },
     workers,
   };