@iowarp/clio-coder 0.3.4 → 0.3.7

package/dist/{fleet-7XMJNQNF.js → fleet-BDKYJFCP.js}

@@ -2,140 +2,144 @@ import { createRequire as __clioCreateRequire } from "node:module"; const requir
 import {
   SchedulingDomainModule,
   createPromptsDomainModule
-} from "./chunk-3HZ5RWN2.js";
+} from "./chunk-EBEFWSGL.js";
 import {
-  AgentsDomainModule,
   SafetyDomainModule
-} from "./chunk-X6COSD2O.js";
+} from "./chunk-J7PIKKWC.js";
 import {
   LifecycleDomainModule
-} from "./chunk-K6WL7QZT.js";
+} from "./chunk-JTSEDYVQ.js";
 import {
   ensureClioState
-} from "./chunk-VAWWTKDP.js";
+} from "./chunk-3HAPLH5M.js";
 import {
   ConfigDomainModule,
   loadDomains
-} from "./chunk-KRPY7NTG.js";
+} from "./chunk-BMWK7ZIZ.js";
 import {
   ObservabilityDomainModule
-} from "./chunk-35MKKU5R.js";
-import "./chunk-HC4CLZ2Y.js";
+} from "./chunk-5UJ6ECTS.js";
+import "./chunk-GWS3VEIW.js";
 import "./chunk-HFSBBKSQ.js";
-import "./chunk-E25LMLRW.js";
+import "./chunk-YD734TPH.js";
 import {
   ContextDomainModule
-} from "./chunk-UZHIZC5S.js";
+} from "./chunk-4DWFMQDR.js";
+import "./chunk-LCGCVYZ4.js";
 import "./chunk-5WIGXA4T.js";
-import "./chunk-BRXQQJFP.js";
+import "./chunk-6M7VS3J3.js";
 import {
   DispatchDomainModule,
-  WRITE_BOUNDARY_VIOLATION_REASON,
   capacityDrain,
-  codeStepDir,
-  compileFleetExecutionPlan,
-  createWriteBoundaryEnforcer,
-  decideReviewGate,
-  executePlan,
-  executionPlanAncestors,
-  materializePendingGateDecision,
+  executeFleetRun,
   openLedger,
-  preflightWriteBoundaries,
-  runCodeStep,
-  setCapacityDraining,
-  stagePendingGateDecision,
-  writeCodeStepRecord
-} from "./chunk-QQL5RT5M.js";
+  planFleetResume,
+  readFleetRun,
+  setCapacityDraining
+} from "./chunk-UUANF5CR.js";
 import {
   SessionDomainModule
-} from "./chunk-QQK64KLB.js";
+} from "./chunk-6TUKSZVF.js";
 import {
-  FLEET_COMMANDS_REMEDY,
-  FLEET_COMMANDS_REPO_PATH,
-  FleetCommandRegistryMissingError,
-  listFleetContracts,
-  loadFleetCommands,
-  loadFleetContract,
-  renderFleetPrompt
-} from "./chunk-QKMUKYO7.js";
+  WRITE_BOUNDARY_VIOLATION_REASON,
+  preflightWriteBoundaries
+} from "./chunk-KZ2H5X4G.js";
 import {
-  RUN_RECEIPT_INTEGRITY_ALGORITHM,
-  RUN_RECEIPT_INTEGRITY_VERSION,
-  verifyReceiptIntegrity
-} from "./chunk-3JLKSKD7.js";
-import "./chunk-34475P3I.js";
+  compileFleetExecutionPlan
+} from "./chunk-M4AKACEO.js";
+import "./chunk-RVG5JXAL.js";
+import "./chunk-ZGH7FGS5.js";
+import "./chunk-TSHXZTOQ.js";
 import "./chunk-TXOTCRLG.js";
-import "./chunk-G4BMMOKF.js";
-import "./chunk-X4RCMKVQ.js";
+import "./chunk-HVDIIIQW.js";
+import "./chunk-NDINPTJ4.js";
 import "./chunk-MVVUPGPW.js";
 import {
   ResourcesDomainModule
-} from "./chunk-MFFY33HR.js";
-import "./chunk-4BPJXDWC.js";
+} from "./chunk-THKY7CD7.js";
+import {
+  AgentsDomainModule
+} from "./chunk-UVDSQ6LW.js";
+import "./chunk-DR52UMZW.js";
+import "./chunk-C4JBQ5SR.js";
 import "./chunk-2SFS6XQE.js";
 import "./chunk-ZWLZP4ZT.js";
 import "./chunk-W6GROXXM.js";
+import {
+  FLEET_COMMANDS_REMEDY,
+  FLEET_COMMANDS_REPO_PATH,
+  FleetCommandRegistryMissingError,
+  listFleetContracts,
+  loadFleetCommands,
+  loadFleetContract,
+  renderFleetPrompt
+} from "./chunk-KCMKRQX4.js";
 import {
   MiddlewareDomainModule
-} from "./chunk-2LZI5CAG.js";
+} from "./chunk-XEGB6BCN.js";
 import "./chunk-IR4CFBFN.js";
 import "./chunk-UOV2BYIW.js";
-import "./chunk-2TZWSW76.js";
-import "./chunk-ZYKPLLNQ.js";
-import "./chunk-WPQLXFOZ.js";
+import "./chunk-WHGPSPT5.js";
 import {
-  resultContractAuthorship
-} from "./chunk-7RXG6QRZ.js";
+  formatBudgetPolicy,
+  formatBudgetReasons,
+  formatBudgetRequest,
+  formatEffectiveBudget
+} from "./chunk-CEYBNUGC.js";
+import "./chunk-5FR74PWO.js";
+import "./chunk-OBMAI2DP.js";
+import "./chunk-5C77SEEY.js";
 import {
   agentRoleFactsResolver,
-  gateRouteCorrelation,
   requestExecutionRole,
   withAttemptRole
-} from "./chunk-22NAGB7X.js";
-import "./chunk-AOCYTWAV.js";
-import "./chunk-MV3K5QF2.js";
+} from "./chunk-UND3GU2L.js";
 import "./chunk-CMZWFGD2.js";
 import "./chunk-I4HZDVNP.js";
-import "./chunk-FYYLNIL5.js";
-import "./chunk-UL3WSD3F.js";
+import "./chunk-GH5622CP.js";
 import "./chunk-VG7TBQIY.js";
 import "./chunk-OQE5J4C6.js";
-import "./chunk-ECH6PKUQ.js";
-import "./chunk-BEY543CS.js";
-import "./chunk-5M54SPOL.js";
+import "./chunk-GOXNB3AO.js";
+import "./chunk-HWUFFB6L.js";
+import "./chunk-DJNLUABN.js";
+import "./chunk-AOCYTWAV.js";
+import "./chunk-MV3K5QF2.js";
+import "./chunk-UL3WSD3F.js";
+import "./chunk-ODFEOB4F.js";
 import "./chunk-OZNBF4L3.js";
 import "./chunk-4BJ5BYCE.js";
+import "./chunk-ECH6PKUQ.js";
 import "./chunk-6XLNIQDB.js";
 import "./chunk-5B2AEOW5.js";
 import "./chunk-CGKSTWHD.js";
-import "./chunk-POHLU5DW.js";
-import "./chunk-YHZX5GEU.js";
-import "./chunk-VJWL6YS5.js";
+import "./chunk-M6L6IDJG.js";
+import "./chunk-XAKHZX5N.js";
+import "./chunk-UUVG37B4.js";
 import "./chunk-LBMZMYH2.js";
-import "./chunk-EKMEHE4H.js";
+import "./chunk-33YXPOE3.js";
 import "./chunk-XPLRXC72.js";
-import "./chunk-RD5U66HV.js";
-import "./chunk-KOHPCX4K.js";
+import "./chunk-SROCI7ZU.js";
+import "./chunk-DOOEX22V.js";
 import {
   ProvidersDomainModule
-} from "./chunk-QWU7ZBO7.js";
+} from "./chunk-VQNODYQ4.js";
 import "./chunk-CFGTUFWB.js";
-import "./chunk-AD2SYQYC.js";
-import "./chunk-4OC57DA6.js";
-import "./chunk-LL4KHSZI.js";
-import "./chunk-4VP4KH3K.js";
-import {
-  attributeCommitMessage
-} from "./chunk-VEZEGCGW.js";
-import "./chunk-FQ4SKYE4.js";
-import "./chunk-IKCO5N3L.js";
-import "./chunk-3I7MS7N2.js";
+import "./chunk-JRIO5UD2.js";
 import "./chunk-IHXBNWMM.js";
-import "./chunk-BPGS2WCQ.js";
+import "./chunk-GEYXPTRF.js";
+import {
+  readSettings
+} from "./chunk-UHXRNZ2J.js";
+import "./chunk-4DGYLA73.js";
+import "./chunk-LL4KHSZI.js";
 import "./chunk-SST6Z5JA.js";
 import "./chunk-FO5ZOVUY.js";
 import "./chunk-R346GLFC.js";
+import "./chunk-D4MDIG46.js";
+import "./chunk-FQ4SKYE4.js";
 import "./chunk-4ZG3XFUR.js";
+import "./chunk-IKCO5N3L.js";
+import "./chunk-3I7MS7N2.js";
 import "./chunk-FCSXB6T2.js";
 import "./chunk-APJ265NV.js";
 import "./chunk-YXLYO42X.js";
@@ -144,9 +148,9 @@ import {
 } from "./chunk-BNAZZHFG.js";
 import "./chunk-6EJMN2Y3.js";
 import "./chunk-WEPFGWHJ.js";
-import "./chunk-HXG4IURW.js";
+import "./chunk-X2KV5FXT.js";
 import "./chunk-ZGVHUX3M.js";
-import "./chunk-TTNYS3EA.js";
+import "./chunk-OB5HIGJY.js";
 import "./chunk-JVCV3ICN.js";
 import "./chunk-7CR24IG7.js";
 import "./chunk-IWHMRKLL.js";
@@ -159,48 +163,18 @@ init_esm_shims();
 import { randomBytes } from "node:crypto";
 import { readFileSync } from "node:fs";
 import { join } from "node:path";
-
-// src/domains/dispatch/fleet-commit-attribution.ts
-init_esm_shims();
-function deriveFleetCommitAttribution(input) {
-  const byId = new Map(input.plan.steps.map((step) => [step.id, step]));
-  let materiallyAuthored = false;
-  let receipt;
-  for (const candidate of input.step.commitFrom ?? []) {
-    const source = byId.get(candidate);
-    const result = input.priorResults.get(candidate);
-    if (source?.kind !== "agent" || source.scope !== "workspace" || result?.succeeded !== true || result.integrityValid !== true) {
-      continue;
-    }
-    materiallyAuthored = true;
-    if (/^[0-9a-f]{64}$/u.test(result.receiptDigest)) {
-      receipt = {
-        version: RUN_RECEIPT_INTEGRITY_VERSION,
-        algorithm: RUN_RECEIPT_INTEGRITY_ALGORITHM,
-        digest: result.receiptDigest,
-        integrityValid: true,
-        directlyRelevant: true
-      };
-    }
-    break;
-  }
-  return {
-    materiallyAssisted: materiallyAuthored,
-    materiallyAuthored,
-    validationSucceeded: input.validationFresh,
-    independentReviewPassed: input.independentReviewFresh,
-    ...receipt === void 0 ? {} : { receipt }
-  };
-}
-
-// src/cli/fleet.ts
 var HELP = `clio-coder fleet <subcommand>
 
 Repo-owned fleet contracts and the dispatch status surface.
 
 Subcommands:
   list                          list .clio-coder/fleets/*.md contracts with validation status
+  new <name> --from <builtin>   copy build-review, build-test, or sdlc into this repository
+  validate <name> [--json]      run the fleet execution preflight without side effects
+  graph <name> [--json]         print compiled waves, loops, scopes, and write boundaries
+  commands init                 draft a commented command registry from declared project entries
   run <name> [--var k=v ...]    preflight and execute a fleet contract
+       [--resume <runId>]        replay a completed prefix from a prior run of the same plan
        [--json]                 emit step receipts as JSON
   status [--json]               show running, retrying, and total dispatch state
   drain [--json]                deny new execution starts for up to one hour
@@ -218,6 +192,11 @@ function fail(message) {
 `);
   return 2;
 }
+function refuse(message) {
+  process.stderr.write(`clio-coder fleet: ${message}
+`);
+  return 1;
+}
 function parseVars(args) {
   const vars = {};
   const rest = [];
@@ -240,28 +219,15 @@ function parseVars(args) {
   }
   return { vars, rest };
 }
-function fleetGateCorrelation(subject, decider) {
-  const facts = (receipt) => ({
-    agentId: receipt.agentId,
-    targetId: receipt.targetId,
-    wireModelId: receipt.wireModelId,
-    runtimeId: receipt.runtimeId,
-    nodeId: receipt.node?.id ?? "local"
-  });
-  const { agent, target, modelFamily, runtime, node, independent } = gateRouteCorrelation(
-    facts(subject),
-    facts(decider)
-  );
-  return { agent, target, modelFamily, runtime, node, independent };
-}
-var NO_WORKER_RESERVATION = "fleet-no-worker-reservation";
 function newFleetRootId() {
   return `fleet-${randomBytes(6).toString("hex")}`;
 }
 function renderStep(step) {
   if (step.kind === "code") return `code:${step.command}[${step.scope}]`;
   if (step.kind === "agent") return `${step.agent}[${step.scope}]`;
-  const check = step.check.kind === "code" ? `code:${step.check.command}` : step.check.agent;
+  if (step.kind === "gate") return `gate:${step.path}[${step.run}]`;
+  if (step.kind === "plan") return `plan:${step.agent}[${step.roster.join(",")}; max ${step.maxTasks}]`;
+  const check = step.check.kind === "code" ? `code:${step.check.command}` : step.check.kind === "gate" ? `gate:${step.check.gate}` : step.check.agent;
   return `loop:${step.id}(${check} -> ${step.repair.agent} x${step.maxAttempts})`;
 }
 function listingLine(entry, state, detail) {
@@ -302,7 +268,11 @@ function contractAgents(contract) {
   const agents = [];
   for (const step of contract.steps) {
     if (step.kind === "agent") agents.push({ id: step.id, agent: step.agent, scope: step.scope });
-    else if (step.kind === "loop") {
+    else if (step.kind === "gate") agents.push({ id: step.id, agent: step.agent, scope: "workspace" });
+    else if (step.kind === "plan") {
+      agents.push({ id: step.id, agent: step.agent, scope: step.scope });
+      for (const agent of step.roster) agents.push({ id: `${step.id}.roster`, agent, scope: "readonly" });
+    } else if (step.kind === "loop") {
       if (step.check.kind === "agent") {
         agents.push({ id: `${step.id}.check`, agent: step.check.agent, scope: step.check.scope });
       }
@@ -312,6 +282,28 @@ function contractAgents(contract) {
   return agents;
 }
 function preflightFleet(contract, deps) {
+  const targets = new Set(deps.settings.targets.map((target) => target.id));
+  const profiles = new Set(Object.keys(deps.settings.workers?.profiles ?? {}));
+  const checkRoute = (id, route) => {
+    if (route.target !== void 0 && !targets.has(route.target))
+      return `unknown target '${route.target}' at step '${id}'`;
+    if (route.profile !== void 0 && !profiles.has(route.profile))
+      return `unknown profile '${route.profile}' at step '${id}'`;
+    return null;
+  };
+  for (const step of contract.steps) {
+    if (step.kind === "agent" || step.kind === "gate" || step.kind === "plan") {
+      const error2 = checkRoute(step.id, step);
+      if (error2 !== null) return error2;
+    }
+    if (step.kind !== "loop") continue;
+    if (step.check.kind === "agent") {
+      const error2 = checkRoute(`${step.id}.check`, step.check);
+      if (error2 !== null) return error2;
+    }
+    const error = checkRoute(`${step.id}.repair`, step.repair);
+    if (error !== null) return error;
+  }
   for (const step of contractAgents(contract)) {
     if (!deps.agents.get(step.agent)) {
       return `unknown agent '${step.agent}' (step '${step.id}' must name a recipe from 'clio-coder agents')`;
@@ -339,8 +331,12 @@ async function runFleet(args) {
   const { vars, rest, error } = parseVars(args);
   if (error !== void 0) return fail(error);
   const json = rest.includes("--json");
+  const resumeIndex = rest.indexOf("--resume");
+  const resumeId = resumeIndex === -1 ? void 0 : rest[resumeIndex + 1];
+  if (resumeIndex !== -1 && (resumeId === void 0 || resumeId.startsWith("-")))
+    return fail("--resume requires a run id");
   const name = rest.find((arg) => !arg.startsWith("-"));
-  if (!name) return fail("usage: clio-coder fleet run <name> [--var key=value ...] [--json]");
+  if (!name) return fail("usage: clio-coder fleet run <name> [--var key=value ...] [--resume <runId>] [--json]");
   let contract;
   let prompt;
   let commands;
@@ -383,13 +379,17 @@ async function runFleet(args) {
     return fail("required domains unavailable (dispatch/agents/safety)");
   }
   const roleFacts = agentRoleFactsResolver((id) => agents.getSpec(id));
-  const preflightError = preflightFleet(contract, { agents, safety, scheduling });
+  const preflightError = preflightFleet(contract, {
+    agents,
+    safety,
+    scheduling,
+    settings: config?.get() ?? readSettings()
+  });
   if (preflightError !== null) {
     await loaded.stop();
     return fail(`preflight failed: ${preflightError}`);
   }
   const fleetRootId = newFleetRootId();
-  let planOutcome;
   let plan;
   try {
     plan = compileFleetExecutionPlan({
@@ -408,9 +408,7 @@ async function runFleet(args) {
         return {
           requestedAuthority: spec.capabilityClass,
           approvedAuthority: spec.capabilityClass,
-          // A gate decider answers the coordinator's question, so its
-          // postcondition is the gate result contract, not its recipe's.
-          expectedResultContract: context.gateRole === "reviewer" ? "verifier-report" : spec.resultContract.kind,
+          expectedResultContract: context.planRole === true ? "delegation-plan" : context.gateAuthorRole === true ? "artifact-report" : context.gateRole === "reviewer" ? "verifier-report" : spec.resultContract.kind,
           executionRole: withAttemptRole(requestRole, context.attempt)
         };
       }
@@ -425,233 +423,96 @@ async function runFleet(args) {
     await loaded.stop();
     return fail(`preflight failed: ${err instanceof Error ? err.message : String(err)}`);
   }
-  const boundaryByStep = new Map(plan.steps.map((step) => [step.id, step.writes]));
-  const boundaryEnforcer = createWriteBoundaryEnforcer({
-    root: process.cwd(),
-    rootId: fleetRootId,
-    boundaryFor: (stepId) => boundaryByStep.get(stepId),
-    onVerdict(verdict, path) {
-      if (verdict.reason === null) return;
-      process.stderr.write(`write boundary ${verdict.window}: ${verdict.detail ?? verdict.reason} record=${path}
+  let resume;
+  if (resumeId !== void 0) {
+    const record = readFleetRun(resumeId);
+    if (record === null) {
+      await loaded.stop();
+      return refuse(`resume run '${resumeId}' was not found in the durable fleet ledger`);
+    }
+    const planned = planFleetResume(record, plan, contract, vars);
+    if (!planned.ok) {
+      if (planned.reason === "fleet-name") {
+        await loaded.stop();
+        return refuse(`resume run '${resumeId}' belongs to fleet '${planned.priorFleet}', not '${planned.currentFleet}'`);
+      }
+      if (planned.reason === "vars") {
+        await loaded.stop();
+        return refuse(`resume run '${resumeId}' used different --var values`);
+      }
+      process.stderr.write(
+        `clio-coder fleet: resume plan hash differs: prior=${planned.priorHash} current=${planned.currentHash}
+`
+      );
+      for (const entry of planned.diff) {
+        process.stderr.write(`  step ${entry.index + 1}: ${entry.priorId} -> ${entry.currentId}
+`);
+        process.stderr.write(`    prior: ${JSON.stringify(entry.prior)}
 `);
+        process.stderr.write(`    current: ${JSON.stringify(entry.current)}
+`);
+      }
+      await loaded.stop();
+      return 1;
     }
-  });
+    resume = { record, replayed: planned.replayed };
+  }
   process.stderr.write(
     `fleet ${contract.name}: root=${fleetRootId} plan=${plan.hash} steps=${plan.steps.length} loops=${plan.loops.length}
 `
   );
-  const receipts = [];
-  const receiptsByStep = /* @__PURE__ */ new Map();
-  const planStep = (stepId) => plan.steps.find((entry) => entry.id === stepId);
-  const attributionEnabled = config?.get().attribution.gitCommits ?? true;
-  let validationFresh = false;
-  let independentReviewFresh = false;
-  const commitMessageFor = (step, priorResults) => {
-    for (const candidate of step.commitFrom ?? []) {
-      const source = planStep(candidate);
-      const result = priorResults.get(candidate);
-      if (source === void 0 || source.kind !== "agent" || result === void 0) continue;
-      const resultContract = agents.getSpec(source.agentId)?.resultContract ?? null;
-      if (resultContract === null) continue;
-      const authored = resultContractAuthorship(resultContract, result.output);
-      if (authored.commitMessage !== null) return authored.commitMessage;
-      if (authored.summary !== null) return `clio(${fleetRootId}): ${authored.summary}`;
-    }
-    return `clio(${fleetRootId}): ${contract.name} ${step.id}`;
-  };
+  let outcome;
   try {
-    planOutcome = await executePlan(plan, {
-      preflight(step) {
-        const request = {
-          agentId: step.agentId,
-          executionRole: step.executionRole,
-          task: step.task,
-          requestOrigin: "user",
-          lineage: { parentRunId: fleetRootId, rootRunId: fleetRootId, attempt: 0, depth: 1 },
-          ...step.scope === "readonly" ? { autonomy: "read-only" } : {}
-        };
-        const resolution = dispatch.preview?.(request);
-        if (!resolution) throw new Error(`fleet preflight cannot resolve step '${step.id}'`);
-        return { step, costUpperBoundUsd: resolution.costUpperBoundUsd, nodeId: resolution.node.id };
-      },
-      reserve(_plan, admissions) {
-        if (admissions.length === 0) return { ownerId: NO_WORKER_RESERVATION };
-        const reservation = dispatch.reservations?.prepare({
-          topology: "parallel",
-          tasks: admissions.map((admission) => ({
-            memberId: admission.step.id,
-            wave: plan.waves.findIndex((wave) => wave.includes(admission.step.id)),
-            resolution: dispatch.preview?.({
-              agentId: admission.step.agentId,
-              executionRole: admission.step.executionRole,
-              task: admission.step.task
-            })
-          }))
-        });
-        if (!reservation) throw new Error("fleet whole-plan reservation is unavailable");
-        return { ownerId: reservation.ownerId };
-      },
-      async run(step, handoffs, reservation, ledger) {
-        const attempt = step.loop?.role === "repair" ? step.loop.attempt : 0;
-        const request = {
-          agentId: step.agentId,
-          executionRole: step.executionRole,
-          task: step.task,
-          predecessorHandoffs: handoffs,
-          requestOrigin: "user",
-          lineage: { parentRunId: fleetRootId, rootRunId: fleetRootId, attempt, depth: 1 },
-          reservation,
-          ...ledger !== void 0 ? { ledger } : {},
-          ...step.loop?.role === "check" ? {
-            gate: {
-              role: "reviewer",
-              group: `${fleetRootId}:${step.loop.loopId}`,
-              cycle: step.loop.attempt,
-              subjects: handoffs.map((handoff) => ({
-                runId: handoff.terminalRunId,
-                digest: handoff.receiptDigest
-              }))
-            }
-          } : {},
-          ...step.scope === "readonly" ? { autonomy: "read-only" } : {}
-        };
-        const handle = await dispatch.dispatch(request);
-        void (async () => {
-          for await (const _event of handle.events) {
-          }
-        })().catch(() => {
-        });
-        return {
-          assignmentId: handle.runId,
-          result: handle.finalPromise.then((receipt) => {
-            if (step.scope === "workspace") {
-              validationFresh = false;
-              independentReviewFresh = false;
-            }
-            receipts.push(receipt);
-            receiptsByStep.set(step.id, receipt);
-            const envelope = dispatch.getRun(receipt.runId);
-            const integrityValid = envelope !== null && verifyReceiptIntegrity(receipt, envelope).ok;
-            const succeeded = receipt.exitCode === 0 && (receipt.outcome === void 0 || receipt.outcome === "succeeded");
-            if (json) process.stdout.write(`${JSON.stringify(receipt)}
-`);
-            else
-              process.stdout.write(
-                `step ${step.id} ${step.agentId}: ${succeeded ? "succeeded" : "failed"} assignment=${handle.runId} terminal-run=${receipt.runId} cost=$${receipt.costUsd.toFixed(4)}
+    outcome = await executeFleetRun({
+      plan,
+      contractName: contract.name,
+      commands,
+      workspaceRoot: process.cwd(),
+      fleetRootId,
+      dispatch,
+      agents: { getSpec: (agentId) => agents.getSpec(agentId) },
+      attributionEnabled: config?.get().attribution.gitCommits ?? true,
+      vars,
+      ...resume !== void 0 ? { resume } : {},
+      onStepSettled(step) {
+        if (step.replayed === true && step.result !== void 0) {
+          if (json)
+            process.stdout.write(
+              `${JSON.stringify({ stepId: step.stepId, status: "replayed", receipt: { runId: step.result.terminalRunId, digest: step.result.receiptDigest } })}
 `
-              );
-            return {
-              stepId: step.id,
-              assignmentId: handle.runId,
-              terminalRunId: receipt.runId,
-              receiptDigest: receipt.integrity.digest,
-              output: receipt.output?.state === "final" ? receipt.output.text : "",
-              succeeded,
-              integrityValid
-            };
-          })
-        };
-      },
-      async runCode(step, _handoffs, signal, priorResults) {
-        const command = commands?.commands.get(step.commandId);
-        if (command === void 0) throw new Error(`fleet code step '${step.id}' has no registered command`);
-        const isCommit = step.commitFrom !== void 0;
-        const evidence = isCommit ? deriveFleetCommitAttribution({
-          plan,
-          step,
-          priorResults,
-          validationFresh,
-          independentReviewFresh
-        }) : null;
-        if (!isCommit && step.scope === "workspace" && step.verification !== true) {
-          validationFresh = false;
-          independentReviewFresh = false;
+            );
+          else
+            process.stdout.write(
+              `step ${step.stepId}: replayed terminal-run=${step.result.terminalRunId} receipt=${step.result.receiptDigest}
+`
+            );
+          return;
         }
-        const originalMessage = isCommit ? commitMessageFor(step, priorResults) : null;
-        const outcome = await runCodeStep({
-          stepId: step.id,
-          command,
-          workspaceRoot: process.cwd(),
-          artifactDir: codeStepDir(fleetRootId),
-          signal,
-          ...isCommit && evidence !== null && originalMessage !== null ? {
-            substitutions: {
-              commitMessage: attributeCommitMessage(originalMessage, evidence, attributionEnabled)
-            },
-            requireWorkspaceChanges: true,
-            commitAttribution: { enabled: attributionEnabled, evidence }
-          } : {}
-        });
-        if (step.verification === true) validationFresh = outcome.report.passed;
-        const recordPath = await writeCodeStepRecord(fleetRootId, outcome.record);
-        if (json) process.stdout.write(`${JSON.stringify({ codeStep: outcome.record })}
+        if (step.receipt !== void 0) {
+          if (json) process.stdout.write(`${JSON.stringify(step.receipt)}
 `);
-        else
-          process.stdout.write(
-            `step ${step.id} code:${command.id}: ${outcome.report.passed ? "passed" : "failed"} exit=${outcome.report.exitCode} ${outcome.record.durationMs}ms record=${recordPath}
+          else
+            process.stdout.write(
+              `step ${step.stepId} ${step.agentId}: ${step.succeeded ? "succeeded" : "failed"}${step.failureReason !== void 0 ? ` reason=${step.failureReason}` : ""} assignment=${step.assignmentId} terminal-run=${step.terminalRunId} cost=$${step.costUsd.toFixed(4)}
 `
-          );
-        return {
-          stepId: step.id,
-          assignmentId: outcome.record.runId,
-          terminalRunId: outcome.record.runId,
-          receiptDigest: outcome.record.reportDigest,
-          output: outcome.output,
-          succeeded: outcome.report.passed,
-          // The runner authored this report itself, so its provenance is
-          // valid by construction; only the command's verdict can be red.
-          integrityValid: true
-        };
-      },
-      async decideLoop({ loop, step, attempt, terminalAttempt, result }) {
-        const decider = receiptsByStep.get(step.id);
-        const ancestors = executionPlanAncestors(plan, step.id);
-        let subject;
-        for (const [stepId, receipt] of receiptsByStep) {
-          if (ancestors.has(stepId)) subject = receipt;
+            );
+          return;
         }
-        if (decider === void 0 || subject === void 0) {
-          return {
-            resolved: false,
-            findings: null,
-            needsDecision: `loop '${loop.id}' cycle ${attempt} has no sealed reviewer or subject receipt`
-          };
-        }
-        const correlation = fleetGateCorrelation(subject, decider);
-        const decided = decideReviewGate({
-          group: `${fleetRootId}:${loop.id}`,
-          cycle: attempt,
-          terminalCycle: terminalAttempt,
-          subjects: [{ runId: subject.runId, digest: subject.integrity.digest }],
-          decider: { runId: decider.runId, digest: decider.integrity.digest },
-          correlation,
-          output: result.output
-        });
-        independentReviewFresh = decided.verdict === "pass" && correlation.independent;
-        const staged = stagePendingGateDecision(decided.draft);
-        const { path: decisionPath } = materializePendingGateDecision(staged);
-        if (!json) {
-          process.stdout.write(
-            `loop ${loop.id} cycle ${attempt}: ${decided.draft.outcome}${decided.draft.detail === void 0 ? "" : ` (${decided.draft.detail})`} decision=${decisionPath}
+        if (step.codeStep !== void 0) {
+          if (json) process.stdout.write(`${JSON.stringify({ codeStep: step.codeStep })}
+`);
+          else
+            process.stdout.write(
+              `step ${step.stepId} code:${step.commandId}: ${step.succeeded ? "passed" : "failed"} exit=${step.codeStep.exitCode} ${step.codeStep.durationMs}ms record=${step.recordPath}
 `
-          );
+            );
         }
-        return {
-          resolved: decided.verdict === "pass",
-          findings: decided.findings,
-          needsDecision: decided.needsDecision
-        };
-      },
-      beginWriteBoundary: (window, stepIds) => boundaryEnforcer.begin(window, stepIds),
-      verifyWriteBoundary: (window, stepIds) => boundaryEnforcer.verify(window, stepIds),
-      cancel: (assignmentId) => dispatch.abort(assignmentId),
-      release: (ownerId) => {
-        if (ownerId === NO_WORKER_RESERVATION) return;
-        dispatch.reservations?.rollbackUnconsumed(ownerId);
       },
-      releaseUnconsumed: (ownerId) => {
-        if (ownerId === NO_WORKER_RESERVATION) return;
-        dispatch.reservations?.rollbackUnconsumed(ownerId);
+      onNotice(text, kind) {
+        if (kind === "write-boundary") process.stderr.write(`${text}
+`);
+        else if (kind === "gate" && !json) process.stdout.write(`${text}
+`);
       }
     });
   } catch (err) {
@@ -661,53 +522,45 @@ async function runFleet(args) {
   }
   await dispatch.drain();
   await loaded.stop();
-  const required = plan.steps.filter((step) => step.loop === void 0 && !planOutcome.unneeded.includes(step.id));
-  const failedLoops = planOutcome.loops.filter((loop) => !loop.resolved);
-  const succeededSteps = required.filter((step) => planOutcome.results.get(step.id)?.succeeded === true).length;
-  const resolvedLoops = planOutcome.loops.length - failedLoops.length;
   if (json) {
     process.stdout.write(
       `${JSON.stringify({
         fleet: contract.name,
         rootId: fleetRootId,
         planHash: plan.hash,
-        loops: planOutcome.loops,
-        revalidated: planOutcome.revalidated,
-        unneeded: planOutcome.unneeded,
-        skipped: planOutcome.skipped,
-        needsDecision: planOutcome.needsDecision,
-        writeBoundaries: planOutcome.writeBoundaries
+        loops: outcome.result.loops,
+        revalidated: outcome.result.revalidated,
+        unneeded: outcome.result.unneeded,
+        skipped: outcome.result.skipped,
+        needsDecision: outcome.result.needsDecision,
+        writeBoundaries: outcome.result.writeBoundaries
       })}
 `
     );
   } else {
-    const spentUsd = receipts.reduce((sum, receipt) => sum + receipt.costUsd, 0);
     process.stdout.write(
-      `fleet ${contract.name}: ${succeededSteps}/${required.length} steps succeeded, ${resolvedLoops}/${planOutcome.loops.length} loops resolved, total cost $${spentUsd.toFixed(4)}
+      `fleet ${contract.name}: ${outcome.succeededStepCount}/${outcome.requiredStepCount} steps succeeded, ${outcome.resolvedLoopCount}/${outcome.result.loops.length} loops resolved, total cost $${outcome.totalCostUsd.toFixed(4)}
 `
     );
-    for (const loop of planOutcome.loops) {
+    for (const loop of outcome.result.loops)
       process.stdout.write(
         `  loop ${loop.loopId}: ${loop.reason} after ${loop.attempts} verification(s) and ${loop.repairs} repair(s)
 `
       );
-    }
-    if (planOutcome.revalidated.length > 0) {
+    if (outcome.result.revalidated.length > 0)
       process.stdout.write(
-        `  staleness: re-ran ${planOutcome.revalidated.join(", ")} because a workspace step landed after the last green
+        `  staleness: re-ran ${outcome.result.revalidated.join(", ")} because a workspace step landed after the last green
 `
       );
-    }
-    for (const message of planOutcome.needsDecision) process.stdout.write(`  needs operator decision: ${message}
+    for (const message of outcome.result.needsDecision) process.stdout.write(`  needs operator decision: ${message}
 `);
-    for (const boundary of planOutcome.writeBoundaries) {
+    for (const boundary of outcome.result.writeBoundaries) {
       if (!boundary.violated) continue;
       process.stdout.write(`  write boundary ${boundary.window}: ${boundary.detail ?? WRITE_BOUNDARY_VIOLATION_REASON}
 `);
     }
   }
-  const cleanRun = failedLoops.length === 0 && planOutcome.skipped.length === 0 && required.every((step) => planOutcome.results.get(step.id)?.succeeded === true);
-  return cleanRun ? 0 : 1;
+  return outcome.cleanRun ? 0 : 1;
 }
 function isProcessAlive(pid) {
   if (pid === null || !Number.isFinite(pid) || pid <= 0) return false;
@@ -757,6 +610,7 @@ function statusSnapshot() {
     return {
       runId: row.id,
       agentId: row.agentId,
+      budget: row.budget ?? null,
       runtimeKind: row.runtimeKind,
       outcomePhase: row.status,
       heartbeat: rowHeartbeat(row),
@@ -814,6 +668,17 @@ function runStatus(args) {
         `  ${row.runId}  ${row.agentId}  node=${row.node}  ${row.heartbeat}  attempt=${lineage.attempt} depth=${lineage.depth}  ${Math.round(row.elapsedMs / 1e3)}s  $${row.costUsd.toFixed(4)}
 `
       );
+      const budget = row.budget;
+      if (budget !== null) {
+        process.stdout.write(`    recipe policy: ${formatBudgetPolicy(budget)}
+`);
+        process.stdout.write(`    requested envelope: ${formatBudgetRequest(budget)}
+`);
+        process.stdout.write(`    effective envelope: ${formatEffectiveBudget(budget)}
+`);
+        process.stdout.write(`    clamp or escalation reason: ${formatBudgetReasons(budget)}
+`);
+      }
     }
   }
   if (snapshot.retrying.length === 0) {
@@ -865,6 +730,14 @@ async function runFleetCommand(args) {
   switch (sub) {
     case "list":
       return runList(args.slice(1));
+    case "new":
+      return (await import("./fleet-new-RDVJLHHH.js")).runFleetNew(args.slice(1));
+    case "validate":
+      return (await import("./fleet-validate-BIYREGIK.js")).runFleetValidate(args.slice(1));
+    case "graph":
+      return (await import("./fleet-graph-Y6HPXIVF.js")).runFleetGraph(args.slice(1));
+    case "commands":
+      return (await import("./fleet-commands-ZFIWZSB3.js")).runFleetCommands(args.slice(1));
     case "run":
       return runFleet(args.slice(1));
     case "status":
@@ -884,4 +757,4 @@ export {
   runFleetCommand,
   statusSnapshot
 };
-//# sourceMappingURL=fleet-7XMJNQNF.js.map
+//# sourceMappingURL=fleet-BDKYJFCP.js.map