@iowarp/clio-coder 0.3.6 → 0.3.8

package/dist/{fleet-S5R4ZOQY.js → fleet-7WZEWRFA.js}

@@ -2,54 +2,66 @@ import { createRequire as __clioCreateRequire } from "node:module"; const requir
 import {
   SchedulingDomainModule,
   createPromptsDomainModule
-} from "./chunk-XF5N4U5A.js";
+} from "./chunk-5DHKRSMQ.js";
 import {
-  AgentsDomainModule,
   SafetyDomainModule
-} from "./chunk-LYF7OHWH.js";
+} from "./chunk-EMYUUSFG.js";
 import {
   LifecycleDomainModule
-} from "./chunk-6XXKFVSN.js";
+} from "./chunk-5Q2VVUKB.js";
 import {
   ensureClioState
-} from "./chunk-KHSFENX2.js";
+} from "./chunk-WWCZ5F23.js";
 import {
   ConfigDomainModule,
   loadDomains
-} from "./chunk-R46L2BIR.js";
+} from "./chunk-FHJEP5SW.js";
+import {
+  ResourcesDomainModule
+} from "./chunk-U6MBIEMB.js";
+import {
+  AgentsDomainModule
+} from "./chunk-FBVTI2TJ.js";
+import "./chunk-DR52UMZW.js";
+import "./chunk-TANS5ZJS.js";
+import "./chunk-DGSYXYMX.js";
 import {
   ObservabilityDomainModule
-} from "./chunk-K7T3E2SR.js";
-import "./chunk-HC4CLZ2Y.js";
+} from "./chunk-WNIJTQQK.js";
+import "./chunk-GWS3VEIW.js";
 import "./chunk-HFSBBKSQ.js";
-import "./chunk-E25LMLRW.js";
+import "./chunk-26LEYJZH.js";
+import "./chunk-WXY7KU3G.js";
 import {
   ContextDomainModule
-} from "./chunk-CYQKWTG3.js";
+} from "./chunk-WSB3FPX7.js";
 import "./chunk-LCGCVYZ4.js";
 import "./chunk-5WIGXA4T.js";
-import "./chunk-6US73PDB.js";
+import "./chunk-TYPGUK6W.js";
+import "./chunk-NDINPTJ4.js";
+import "./chunk-MVVUPGPW.js";
 import {
   DispatchDomainModule,
-  WRITE_BOUNDARY_VIOLATION_REASON,
   capacityDrain,
-  codeStepDir,
-  compileFleetExecutionPlan,
-  createWriteBoundaryEnforcer,
-  decideReviewGate,
-  executePlan,
-  executionPlanAncestors,
-  materializePendingGateDecision,
+  executeFleetRun,
   openLedger,
-  preflightWriteBoundaries,
-  runCodeStep,
-  setCapacityDraining,
-  stagePendingGateDecision,
-  writeCodeStepRecord
-} from "./chunk-QM3F2GKX.js";
+  planFleetResume,
+  readFleetRun,
+  setCapacityDraining
+} from "./chunk-TLQJPP24.js";
 import {
   SessionDomainModule
-} from "./chunk-CJUB2JJ2.js";
+} from "./chunk-YS5VLNH5.js";
+import "./chunk-K4XHGFR5.js";
+import {
+  WRITE_BOUNDARY_VIOLATION_REASON,
+  preflightWriteBoundaries
+} from "./chunk-MXKJU4JB.js";
+import {
+  compileFleetExecutionPlan
+} from "./chunk-J3YUBZWY.js";
+import "./chunk-RVG5JXAL.js";
+import "./chunk-W6GROXXM.js";
 import {
   FLEET_COMMANDS_REMEDY,
   FLEET_COMMANDS_REPO_PATH,
@@ -58,105 +70,95 @@ import {
   loadFleetCommands,
   loadFleetContract,
   renderFleetPrompt
-} from "./chunk-QKMUKYO7.js";
-import {
-  RUN_RECEIPT_INTEGRITY_ALGORITHM,
-  RUN_RECEIPT_INTEGRITY_VERSION,
-  verifyReceiptIntegrity
-} from "./chunk-OH3TOQTB.js";
-import "./chunk-TSHXZTOQ.js";
+} from "./chunk-E77JEWSD.js";
+import "./chunk-DYIM5TJT.js";
+import "./chunk-JVCV3ICN.js";
+import "./chunk-2HEJ2F35.js";
 import "./chunk-TXOTCRLG.js";
 import "./chunk-HVDIIIQW.js";
-import "./chunk-NDINPTJ4.js";
-import "./chunk-MVVUPGPW.js";
-import {
-  ResourcesDomainModule
-} from "./chunk-MFFY33HR.js";
-import "./chunk-4BPJXDWC.js";
-import "./chunk-2SFS6XQE.js";
-import "./chunk-ZWLZP4ZT.js";
-import "./chunk-W6GROXXM.js";
 import {
   MiddlewareDomainModule
-} from "./chunk-ZXF4XRKW.js";
-import "./chunk-IR4CFBFN.js";
+} from "./chunk-7RGZWPB6.js";
+import "./chunk-VCBR6CU7.js";
 import "./chunk-UOV2BYIW.js";
-import "./chunk-WHGPSPT5.js";
+import "./chunk-ZVJ5BLO2.js";
+import "./chunk-VG7TBQIY.js";
 import {
   formatBudgetPolicy,
   formatBudgetReasons,
   formatBudgetRequest,
   formatEffectiveBudget
-} from "./chunk-XXQNGV4M.js";
-import "./chunk-43AOLP7E.js";
-import {
-  resultContractAuthorship
-} from "./chunk-EKY57CSP.js";
+} from "./chunk-A3WNZD3P.js";
+import "./chunk-5FR74PWO.js";
+import "./chunk-P43ETTHK.js";
 import {
   agentRoleFactsResolver,
-  gateRouteCorrelation,
   requestExecutionRole,
   withAttemptRole
-} from "./chunk-22NAGB7X.js";
-import "./chunk-AOCYTWAV.js";
-import "./chunk-MV3K5QF2.js";
-import "./chunk-CMZWFGD2.js";
-import "./chunk-I4HZDVNP.js";
-import "./chunk-FYYLNIL5.js";
-import "./chunk-UL3WSD3F.js";
-import "./chunk-VG7TBQIY.js";
+} from "./chunk-H7IXIC72.js";
+import "./chunk-5H3GB5BO.js";
+import "./chunk-A2NJGIB3.js";
 import "./chunk-OQE5J4C6.js";
-import "./chunk-ECH6PKUQ.js";
 import "./chunk-GOXNB3AO.js";
 import "./chunk-HWUFFB6L.js";
+import "./chunk-TTHACPOM.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-CMZWFGD2.js";
+import "./chunk-I4HZDVNP.js";
 import "./chunk-6XLNIQDB.js";
 import "./chunk-5B2AEOW5.js";
 import "./chunk-CGKSTWHD.js";
 import "./chunk-M6L6IDJG.js";
-import "./chunk-XAKHZX5N.js";
 import "./chunk-UUVG37B4.js";
 import "./chunk-LBMZMYH2.js";
+import "./chunk-XAKHZX5N.js";
 import "./chunk-33YXPOE3.js";
+import "./chunk-7CR24IG7.js";
 import "./chunk-XPLRXC72.js";
-import "./chunk-RD5U66HV.js";
-import "./chunk-KOHPCX4K.js";
+import "./chunk-GPIEI3LY.js";
+import "./chunk-XWSF374K.js";
 import {
   ProvidersDomainModule
-} from "./chunk-DJVECN66.js";
+} from "./chunk-7RFXX52T.js";
 import "./chunk-CFGTUFWB.js";
-import "./chunk-AD2SYQYC.js";
-import "./chunk-4OC57DA6.js";
-import "./chunk-LL4KHSZI.js";
-import "./chunk-4VP4KH3K.js";
+import "./chunk-LU7P4LHA.js";
+import "./chunk-RWSI4YD7.js";
+import "./chunk-IHXBNWMM.js";
+import "./chunk-B5CSFE7B.js";
 import {
-  attributeCommitMessage
-} from "./chunk-VEZEGCGW.js";
+  readSettings
+} from "./chunk-IJ7RPIYJ.js";
 import "./chunk-FQ4SKYE4.js";
-import "./chunk-IKCO5N3L.js";
-import "./chunk-3I7MS7N2.js";
-import "./chunk-IHXBNWMM.js";
-import "./chunk-GEYXPTRF.js";
-import "./chunk-SST6Z5JA.js";
-import "./chunk-FO5ZOVUY.js";
+import "./chunk-ZGVHUX3M.js";
+import "./chunk-TT36MB5S.js";
+import "./chunk-3BINW3FP.js";
 import "./chunk-R346GLFC.js";
+import "./chunk-6EJMN2Y3.js";
+import "./chunk-IWHMRKLL.js";
+import "./chunk-NMPKI6XL.js";
+import "./chunk-4DGYLA73.js";
+import "./chunk-LL4KHSZI.js";
 import "./chunk-4ZG3XFUR.js";
-import "./chunk-FCSXB6T2.js";
+import "./chunk-IIZWH4XA.js";
+import "./chunk-EQ63NRB7.js";
+import "./chunk-SST6Z5JA.js";
+import "./chunk-IKCO5N3L.js";
+import "./chunk-3I7MS7N2.js";
 import "./chunk-APJ265NV.js";
-import "./chunk-YXLYO42X.js";
 import {
   clioStateDir
 } from "./chunk-BNAZZHFG.js";
-import "./chunk-6EJMN2Y3.js";
 import "./chunk-WEPFGWHJ.js";
-import "./chunk-XE2VEJHX.js";
-import "./chunk-ZGVHUX3M.js";
-import "./chunk-G7MUEIGA.js";
-import "./chunk-JVCV3ICN.js";
-import "./chunk-7CR24IG7.js";
-import "./chunk-IWHMRKLL.js";
+import "./chunk-NUGM5KR6.js";
+import "./chunk-PT7HYKEM.js";
+import "./chunk-FCSXB6T2.js";
+import "./chunk-YXLYO42X.js";
 import {
   init_esm_shims
 } from "./chunk-3R73A4XB.js";
@@ -166,48 +168,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
@@ -225,6 +197,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 = [];
@@ -247,28 +224,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) {
@@ -309,7 +273,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 });
       }
@@ -319,6 +287,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')`;
@@ -346,8 +336,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;
@@ -390,13 +384,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({
@@ -415,9 +413,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)
         };
       }
@@ -432,233 +428,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) {
@@ -668,53 +527,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;
@@ -884,6 +735,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-72PC4SLA.js")).runFleetValidate(args.slice(1));
+    case "graph":
+      return (await import("./fleet-graph-6ULH7PES.js")).runFleetGraph(args.slice(1));
+    case "commands":
+      return (await import("./fleet-commands-UVHWM76J.js")).runFleetCommands(args.slice(1));
     case "run":
       return runFleet(args.slice(1));
     case "status":
@@ -903,4 +762,4 @@ export {
   runFleetCommand,
   statusSnapshot
 };
-//# sourceMappingURL=fleet-S5R4ZOQY.js.map
+//# sourceMappingURL=fleet-7WZEWRFA.js.map