@iowarp/clio-coder 0.4.6 → 0.4.8

package/dist/fleet-W2AF3TOJ.js

@@ -0,0 +1,919 @@
+import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
+import {
+  SchedulingDomainModule,
+  createPromptsDomainModule
+} from "./chunk-F7Y6QTPL.js";
+import {
+  LifecycleDomainModule
+} from "./chunk-5UG6EZI3.js";
+import "./chunk-P4JS3MH5.js";
+import "./chunk-P7GTE4FX.js";
+import {
+  ConfigDomainModule,
+  loadDomains
+} from "./chunk-2SXGG2IV.js";
+import {
+  ObservabilityDomainModule
+} from "./chunk-XTLJDC2X.js";
+import "./chunk-W7KNI3F5.js";
+import "./chunk-K3W6BF5C.js";
+import {
+  ResourcesDomainModule
+} from "./chunk-H5DPSUBB.js";
+import "./chunk-JCVIL6TY.js";
+import "./chunk-Q32C6AWI.js";
+import {
+  ContextDomainModule,
+  aggregateCostAmounts,
+  capacityDrain,
+  createDispatchDomainModule,
+  executeFleetRun,
+  openLedger,
+  planFleetResume,
+  readFleetRun,
+  renderCostAggregate,
+  renderCostAmount,
+  setCapacityDraining
+} from "./chunk-5W4FRA5Q.js";
+import "./chunk-PECBKCDK.js";
+import {
+  WRITE_BOUNDARY_VIOLATION_REASON,
+  preflightWriteBoundaries
+} from "./chunk-K53E2PTW.js";
+import {
+  bindExecutionPlanEndpoints,
+  compileFleetExecutionPlan
+} from "./chunk-L75H5B3B.js";
+import "./chunk-H77XBUBM.js";
+import "./chunk-FB3KTE2J.js";
+import {
+  SessionDomainModule
+} from "./chunk-BIY22UUK.js";
+import "./chunk-U44YYLVV.js";
+import "./chunk-QYSAZMSH.js";
+import "./chunk-O5F25NIE.js";
+import {
+  configureRunEventJournal
+} from "./chunk-UQIVHSE4.js";
+import "./chunk-STC6CWUZ.js";
+import "./chunk-RKFNU5UA.js";
+import "./chunk-YQ3GFEUY.js";
+import "./chunk-BHJMMCXS.js";
+import "./chunk-WTQGRBHV.js";
+import "./chunk-WWRV5RJI.js";
+import "./chunk-DNHVRBH4.js";
+import "./chunk-Y3JU5RPK.js";
+import "./chunk-V4ZKOKRB.js";
+import "./chunk-UB33F3YW.js";
+import "./chunk-JRA6OBHY.js";
+import "./chunk-PMUUAABD.js";
+import "./chunk-JLBVCROW.js";
+import {
+  ensureClioState
+} from "./chunk-JIMWEYWO.js";
+import "./chunk-O2QJDRWP.js";
+import "./chunk-QH3ZTUOA.js";
+import "./chunk-LQTKDAUO.js";
+import {
+  SafetyDomainModule
+} from "./chunk-2ZWLMA3T.js";
+import "./chunk-SD7SHNDW.js";
+import "./chunk-QJMRYTCX.js";
+import "./chunk-GJBJHJNY.js";
+import "./chunk-PFZJMXIY.js";
+import {
+  AgentsDomainModule
+} from "./chunk-LZDLYSUN.js";
+import "./chunk-RFULVPBX.js";
+import "./chunk-ORRNGQDV.js";
+import "./chunk-OEMFEL26.js";
+import "./chunk-EXKUF426.js";
+import "./chunk-DNCE23JJ.js";
+import "./chunk-YJCCMYYT.js";
+import {
+  FLEET_COMMANDS_REMEDY,
+  FLEET_COMMANDS_REPO_PATH,
+  FleetCommandRegistryMissingError,
+  listFleetContracts,
+  loadFleetCommands,
+  loadFleetContract,
+  renderFleetPrompt
+} from "./chunk-7QQRPB2E.js";
+import "./chunk-6UJ7RDI7.js";
+import "./chunk-WS4FOGLY.js";
+import "./chunk-XC5POIL4.js";
+import "./chunk-K45LHSCI.js";
+import "./chunk-GM4TY6VN.js";
+import {
+  MiddlewareDomainModule
+} from "./chunk-PJ5H5B7A.js";
+import "./chunk-44U2OUSM.js";
+import {
+  formatBudgetPolicy,
+  formatBudgetReasons,
+  formatBudgetRequest,
+  formatEffectiveBudget
+} from "./chunk-MWMW53WW.js";
+import "./chunk-RM3XJX7P.js";
+import "./chunk-WJWNZXRM.js";
+import "./chunk-OH3YYA3B.js";
+import "./chunk-6TKOFFGE.js";
+import "./chunk-2GPGAE5W.js";
+import "./chunk-GEVQNST4.js";
+import {
+  agentRoleFactsResolver,
+  requestExecutionRole,
+  withAttemptRole
+} from "./chunk-FNVPQQYT.js";
+import "./chunk-L4N3DWNW.js";
+import "./chunk-SL2RDHKO.js";
+import "./chunk-YGDMBK7O.js";
+import "./chunk-MEHBW2SP.js";
+import "./chunk-526ABLHD.js";
+import "./chunk-KECNXMDE.js";
+import "./chunk-WXA2CFJO.js";
+import "./chunk-V552WL53.js";
+import "./chunk-5A6XR3RJ.js";
+import "./chunk-EFSEIZE6.js";
+import "./chunk-VQD7NH7Z.js";
+import "./chunk-CKK25WN3.js";
+import "./chunk-MUXNDNMZ.js";
+import {
+  ProvidersDomainModule,
+  foregroundStreamUsage,
+  normalizeCostProvenance
+} from "./chunk-GVU4CXPJ.js";
+import "./chunk-MCJKEGHO.js";
+import "./chunk-OPC4DQD6.js";
+import "./chunk-RAUOKUZV.js";
+import "./chunk-X6FLVUM5.js";
+import "./chunk-5C2OQHLR.js";
+import "./chunk-B5ZTR6KZ.js";
+import "./chunk-QWUSS2QP.js";
+import "./chunk-YXANQGCX.js";
+import "./chunk-UDAK6GR2.js";
+import "./chunk-QLAGXTTV.js";
+import "./chunk-TOPICHGR.js";
+import "./chunk-B6UM3OZC.js";
+import "./chunk-MYI32N4R.js";
+import "./chunk-W5RM7YAH.js";
+import "./chunk-PAQVETLA.js";
+import "./chunk-VNBICSS2.js";
+import "./chunk-DXVMLM3Z.js";
+import "./chunk-ARRUMZ7X.js";
+import "./chunk-XW2UZICE.js";
+import {
+  readSettings
+} from "./chunk-PGEFOTJB.js";
+import "./chunk-DVNAPPXU.js";
+import "./chunk-5EQO5NWP.js";
+import "./chunk-YXFKLMX2.js";
+import "./chunk-E2NSPYLC.js";
+import "./chunk-R2P2U3ZS.js";
+import "./chunk-NTTS3O53.js";
+import "./chunk-KQ6IDQIB.js";
+import "./chunk-M4KFUXS7.js";
+import "./chunk-WLHX3MM5.js";
+import "./chunk-3XE4NRLF.js";
+import "./chunk-U2MSJ57E.js";
+import "./chunk-C27U2TYG.js";
+import "./chunk-B5GGDIHT.js";
+import "./chunk-GJ24ODAX.js";
+import "./chunk-LTR5QCLS.js";
+import "./chunk-6EXUUOSN.js";
+import "./chunk-ZTNFYMIO.js";
+import "./chunk-6R5MBXBJ.js";
+import "./chunk-O3VV6IVK.js";
+import "./chunk-EM2WNQS2.js";
+import "./chunk-36XSBPXL.js";
+import "./chunk-UHW5V7HC.js";
+import "./chunk-DVJL77SO.js";
+import "./chunk-KMF54VH3.js";
+import "./chunk-SER7RRAE.js";
+import "./chunk-GH5ZR6JP.js";
+import "./chunk-TK2BMCBZ.js";
+import "./chunk-XCUDZQLX.js";
+import "./chunk-K2BLQC5E.js";
+import {
+  clioStateDir
+} from "./chunk-CTTI7G3T.js";
+import "./chunk-VHKTOLEW.js";
+import "./chunk-KPRLAMP4.js";
+import "./chunk-W2RJEH6Q.js";
+import "./chunk-CVDAFGPW.js";
+import "./chunk-PPEZJWUG.js";
+import "./chunk-WDV62RKY.js";
+import "./chunk-ZZFWWYLX.js";
+import "./chunk-GD55RTIW.js";
+import "./chunk-E3LEPLQ2.js";
+import "./chunk-SRCEQKQS.js";
+import {
+  init_esm_shims
+} from "./chunk-ECBHH7LU.js";
+
+// src/cli/fleet.ts
+init_esm_shims();
+import { randomBytes } from "node:crypto";
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+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
+  inspect --json                emit a bounded recent-run and event-journal projection
+  decisions --json              emit a bounded window of sealed review and compete gate verdicts
+  view <runId> [--follow]       read one run's ledger entry, event journal, and receipt
+  view <fleetRootId>            list a fleet run's steps and the run id to view for each
+  drain [--json]                deny new execution starts for up to one hour
+  resume [--json]               reopen dispatch admission immediately
+
+Notes:
+  status reads the durable run ledger. Rows started by another process show
+  heartbeat liveness from the recorded worker pid; per-token live meters are
+  only available inside the process that owns the run.
+  view is read-only and shares no memory with the orchestrator, so it follows a
+  run from a second terminal or over SSH. Its transcript comes from the run
+  event journal, written when fleet.history.journal is on (the default). Handed the
+  fleet-<hex> root id that run prints, it lists that run's steps instead.
+  drain preserves running work. Repeat it to renew the one-hour expiry; resume
+  clears it early. The expiry prevents an abandoned drain from wedging Clio.
+`;
+function fail(message) {
+  process.stderr.write(`clio-coder fleet: ${message}
+`);
+  return 2;
+}
+function refuse(message) {
+  process.stderr.write(`clio-coder fleet: ${message}
+`);
+  return 1;
+}
+function parseVars(args) {
+  const vars = {};
+  const rest = [];
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (arg !== "--var") {
+      if (arg !== void 0) rest.push(arg);
+      continue;
+    }
+    const pair = args[i + 1];
+    i += 1;
+    if (pair === void 0 || !pair.includes("=")) {
+      return { vars, rest, error: "--var requires key=value" };
+    }
+    const eq = pair.indexOf("=");
+    const key = pair.slice(0, eq).trim();
+    const value = pair.slice(eq + 1);
+    if (key.length === 0) {
+      return { vars, rest, error: "--var requires a non-empty key" };
+    }
+    vars[key] = value;
+  }
+  return { vars, rest };
+}
+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}]`;
+  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) {
+  return `${entry.name}  ${entry.source}  ${state.padEnd(7)}  ${detail}
+`;
+}
+function runList(args) {
+  const unknown = args[0];
+  if (unknown !== void 0) return fail(`list: unknown flag: ${unknown}`);
+  const listings = listFleetContracts(process.cwd());
+  if (listings.length === 0) {
+    process.stdout.write("no fleet contracts found (.clio-coder/fleets/*.md)\n");
+    return 0;
+  }
+  for (const entry of listings) {
+    if (entry.contract !== null) {
+      const steps = entry.contract.steps.map(renderStep).join(" -> ");
+      process.stdout.write(listingLine(entry, "valid", steps));
+      if (entry.contract.description.length > 0) {
+        process.stdout.write(`  ${entry.contract.description}
+`);
+      }
+      continue;
+    }
+    if (entry.needsCommands !== null) {
+      process.stdout.write(
+        listingLine(entry, "setup", `needs ${FLEET_COMMANDS_REPO_PATH} declaring ${entry.needsCommands.join(", ")}`)
+      );
+      process.stdout.write(`  ${FLEET_COMMANDS_REMEDY}
+`);
+      continue;
+    }
+    process.stdout.write(listingLine(entry, "invalid", entry.error ?? "unknown error"));
+  }
+  return 0;
+}
+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 === "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
+        });
+      }
+      agents.push({
+        id: `${step.id}.repair`,
+        agent: step.repair.agent,
+        scope: step.repair.scope
+      });
+    }
+  }
+  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.fleet?.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')`;
+    }
+    const requested = step.scope === "readonly" ? deps.safety.scopes.readonly : deps.safety.scopes.workspace;
+    if (!deps.safety.isSubset(requested, deps.safety.scopes.workspace)) {
+      return `step '${step.id}' scope '${step.scope}' exceeds the orchestrator scope`;
+    }
+  }
+  if (deps.scheduling) {
+    const budget = deps.scheduling.preflight();
+    if (budget.verdict === "over" || budget.verdict === "at") {
+      return `budget ceiling crossed: $${budget.currentUsd.toFixed(4)} / $${budget.ceilingUsd.toFixed(4)}`;
+    }
+    if (contract.budgetUsd !== null) {
+      const remaining = budget.ceilingUsd - budget.currentUsd;
+      if (contract.budgetUsd > remaining) {
+        return `fleet budget $${contract.budgetUsd.toFixed(2)} exceeds remaining session budget $${remaining.toFixed(2)}`;
+      }
+    }
+  }
+  return null;
+}
+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 ...] [--resume <runId>] [--json]");
+  }
+  let contract;
+  let prompt;
+  let commands;
+  try {
+    contract = loadFleetContract(process.cwd(), name);
+    prompt = renderFleetPrompt(contract.body, vars);
+    commands = loadFleetCommands(process.cwd());
+  } catch (err) {
+    if (err instanceof FleetCommandRegistryMissingError) {
+      process.stderr.write(`clio-coder fleet: ${err.message}
+  ${FLEET_COMMANDS_REMEDY}
+`);
+      return 2;
+    }
+    return fail(err instanceof Error ? err.message : String(err));
+  }
+  ensureClioState();
+  const loaded = await loadDomains([
+    ConfigDomainModule,
+    ResourcesDomainModule,
+    ContextDomainModule,
+    ProvidersDomainModule,
+    SafetyDomainModule,
+    createPromptsDomainModule({ noContextFiles: true }),
+    AgentsDomainModule,
+    MiddlewareDomainModule,
+    ObservabilityDomainModule,
+    SchedulingDomainModule,
+    // A fleet step is dispatched by executeFleetRun, which drains the handle
+    // itself and never builds a dispatch event registry, so the domain is the
+    // only thing that can write each step's durable transcript.
+    createDispatchDomainModule({ journalRunEvents: true }),
+    SessionDomainModule,
+    LifecycleDomainModule
+  ]);
+  const dispatch = loaded.getContract("dispatch");
+  const agents = loaded.getContract("agents");
+  const config = loaded.getContract("config");
+  const safety = loaded.getContract("safety");
+  const scheduling = loaded.getContract("scheduling");
+  if (!dispatch || !agents || !safety) {
+    await loaded.stop();
+    return fail("required domains unavailable (dispatch/agents/safety)");
+  }
+  const fleetSettings = config?.get() ?? readSettings();
+  configureRunEventJournal(fleetSettings.fleet.history.journal);
+  const roleFacts = agentRoleFactsResolver((id) => agents.getSpec(id));
+  const preflightError = preflightFleet(contract, {
+    agents,
+    safety,
+    scheduling,
+    settings: fleetSettings
+  });
+  if (preflightError !== null) {
+    await loaded.stop();
+    return fail(`preflight failed: ${preflightError}`);
+  }
+  const fleetRootId = newFleetRootId();
+  let plan;
+  try {
+    plan = compileFleetExecutionPlan({
+      commands,
+      ...vars ? { vars } : {},
+      contract,
+      task: prompt,
+      resolveAgent(context) {
+        const spec = agents.getSpec(context.agentId);
+        if (spec === null || spec.capabilityClass === "orchestration" || spec.capabilityClass === "internal") {
+          throw new Error(`fleet step '${context.stepId}' has no automatable agent authority`);
+        }
+        const requestRole = requestExecutionRole({
+          agentId: context.agentId,
+          resolveFacts: roleFacts,
+          ...context.gateRole !== void 0 ? { gateRole: context.gateRole } : {}
+        });
+        return {
+          requestedAuthority: spec.capabilityClass,
+          approvedAuthority: spec.capabilityClass,
+          expectedResultContract: context.planRole === true ? "delegation-plan" : context.gateAuthorRole === true ? "artifact-report" : context.gateRole === "reviewer" ? "verifier-report" : spec.resultContract.kind,
+          executionRole: withAttemptRole(requestRole, context.attempt)
+        };
+      }
+    });
+  } catch (err) {
+    await loaded.stop();
+    return fail(err instanceof Error ? err.message : String(err));
+  }
+  if (dispatch.preview !== void 0) {
+    try {
+      const foreground = foregroundStreamUsage();
+      const bindings = {};
+      for (const step of plan.steps) {
+        if (step.kind === "code") continue;
+        const request = {
+          agentId: step.agentId,
+          executionRole: step.executionRole,
+          task: step.task,
+          ...step.scope === "readonly" ? { autonomy: "read-only" } : {},
+          ...step.target !== void 0 ? { target: step.target } : {},
+          ...step.profile !== void 0 ? { workerProfile: step.profile } : {}
+        };
+        const endpoint = dispatch.preview(request).endpoint;
+        if (endpoint === void 0) continue;
+        const foregroundHeld = foreground[endpoint.key] ?? 0;
+        bindings[step.id] = {
+          key: endpoint.key,
+          limit: endpoint.limit,
+          ...foregroundHeld > 0 ? { foregroundHeld } : {}
+        };
+      }
+      plan = bindExecutionPlanEndpoints(plan, bindings);
+    } catch (err) {
+      await loaded.stop();
+      return fail(`route preflight failed: ${err instanceof Error ? err.message : String(err)}`);
+    }
+  }
+  try {
+    preflightWriteBoundaries(plan, process.cwd());
+  } catch (err) {
+    await loaded.stop();
+    return fail(`preflight failed: ${err instanceof Error ? err.message : String(err)}`);
+  }
+  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}
+`
+  );
+  let outcome;
+  try {
+    outcome = await executeFleetRun({
+      plan,
+      contractName: contract.name,
+      commands,
+      workspaceRoot: process.cwd(),
+      fleetRootId,
+      dispatch,
+      agents: { getSpec: (agentId) => agents.getSpec(agentId) },
+      attributionEnabled: config?.get().integrations.git.commitAttribution ?? 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
+                }
+              })}
+`
+            );
+          } else {
+            process.stdout.write(
+              `step ${step.stepId}: replayed terminal-run=${step.result.terminalRunId} receipt=${step.result.receiptDigest}
+`
+            );
+          }
+          return;
+        }
+        if (step.receipt !== void 0) {
+          if (json) process.stdout.write(`${JSON.stringify(step.receipt)}
+`);
+          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=${renderCostAmount(step.costUsd, step.costProvenance)}
+`
+            );
+          }
+          return;
+        }
+        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}
+`
+            );
+          }
+        }
+      },
+      onNotice(text, kind) {
+        if (kind === "write-boundary") process.stderr.write(`${text}
+`);
+        else if (kind === "gate" && !json) process.stdout.write(`${text}
+`);
+      }
+    });
+  } catch (err) {
+    await dispatch.drain();
+    await loaded.stop();
+    return fail(err instanceof Error ? err.message : String(err));
+  }
+  await dispatch.drain();
+  await loaded.stop();
+  if (json) {
+    process.stdout.write(
+      `${JSON.stringify({
+        fleet: contract.name,
+        rootId: fleetRootId,
+        planHash: plan.hash,
+        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 {
+    process.stdout.write(
+      `fleet ${contract.name}: ${outcome.succeededStepCount}/${outcome.requiredStepCount} steps succeeded, ${outcome.resolvedLoopCount}/${outcome.result.loops.length} loops resolved, total cost ${renderCostAggregate(outcome.totalCost)}
+`
+    );
+    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 (outcome.result.revalidated.length > 0) {
+      process.stdout.write(
+        `  staleness: re-ran ${outcome.result.revalidated.join(
+          ", "
+        )} because a workspace step landed after the last green
+`
+      );
+    }
+    for (const message of outcome.result.needsDecision) {
+      process.stdout.write(`  needs operator decision: ${message}
+`);
+    }
+    for (const boundary of outcome.result.writeBoundaries) {
+      if (!boundary.violated) continue;
+      process.stdout.write(`  write boundary ${boundary.window}: ${boundary.detail ?? WRITE_BOUNDARY_VIOLATION_REASON}
+`);
+    }
+    process.stdout.write(`  clio-coder fleet view ${fleetRootId}   step index with each step's run id
+`);
+  }
+  return outcome.cleanRun ? 0 : 1;
+}
+function isProcessAlive(pid) {
+  if (pid === null || !Number.isFinite(pid) || pid <= 0) return false;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (err) {
+    return err.code === "EPERM";
+  }
+}
+function rowHeartbeat(row) {
+  if (row.status === "stale") return "stale";
+  if (row.status === "dead") return "dead";
+  return isProcessAlive(row.pid) ? "alive" : "dead";
+}
+function finiteCount(value) {
+  return typeof value === "number" && Number.isFinite(value) && value >= 0 ? value : 0;
+}
+function receiptTokenSplit(row) {
+  const path = row.receiptPath ?? join(clioStateDir(), "receipts", `${row.id}.json`);
+  try {
+    const parsed = JSON.parse(readFileSync(path, "utf8"));
+    return {
+      input: finiteCount(parsed.inputTokenCount),
+      output: finiteCount(parsed.outputTokenCount)
+    };
+  } catch {
+    return null;
+  }
+}
+function rowTokenSplit(row) {
+  if (row.inputTokenCount !== void 0 || row.outputTokenCount !== void 0) {
+    return {
+      input: finiteCount(row.inputTokenCount),
+      output: finiteCount(row.outputTokenCount)
+    };
+  }
+  if (row.endedAt !== null) {
+    return receiptTokenSplit(row) ?? { input: 0, output: 0 };
+  }
+  return { input: 0, output: 0 };
+}
+function admissionStatus(drain) {
+  if (drain === null) return { state: "open" };
+  return { state: "draining", ...drain };
+}
+function statusSnapshot() {
+  const ledger = openLedger();
+  const nowMs = Date.now();
+  const rows = ledger.list();
+  const running = rows.filter((row) => row.endedAt === null && (row.status === "running" || row.status === "stale")).map((row) => {
+    const startedMs = Date.parse(row.startedAt);
+    return {
+      runId: row.id,
+      agentId: row.agentId,
+      budget: row.budget ?? null,
+      runtimeKind: row.runtimeKind,
+      outcomePhase: row.status,
+      heartbeat: rowHeartbeat(row),
+      lineage: row.lineage ?? { parentRunId: null, rootRunId: row.id, attempt: 0, depth: 0 },
+      startedAt: row.startedAt,
+      elapsedMs: Number.isFinite(startedMs) ? Math.max(0, nowMs - startedMs) : 0,
+      tokens: { input: 0, output: 0, total: row.tokenCount },
+      costUsd: row.costUsd,
+      // Absent on pre-provenance ledger rows, which readers must treat as
+      // unknown; `renderCostAmount` normalizes it rather than assuming free.
+      costProvenance: row.costProvenance,
+      node: row.node?.id ?? "local"
+    };
+  });
+  const totals = { inputTokens: 0, outputTokens: 0, totalTokens: 0, costUsd: 0, runtimeSeconds: 0 };
+  const cost = aggregateCostAmounts(
+    rows.map((row) => ({ usd: row.costUsd, provenance: normalizeCostProvenance(row.costProvenance) }))
+  );
+  for (const row of rows) {
+    const split = rowTokenSplit(row);
+    totals.inputTokens += split.input;
+    totals.outputTokens += split.output;
+    totals.totalTokens += row.tokenCount;
+    totals.costUsd += row.costUsd;
+    const startedMs = Date.parse(row.startedAt);
+    const endedMs = row.endedAt !== null ? Date.parse(row.endedAt) : nowMs;
+    if (Number.isFinite(startedMs) && Number.isFinite(endedMs)) {
+      totals.runtimeSeconds += Math.max(0, endedMs - startedMs) / 1e3;
+    }
+  }
+  return {
+    generatedAt: new Date(nowMs).toISOString(),
+    admission: admissionStatus(capacityDrain(nowMs)),
+    running,
+    retrying: [],
+    totals: { ...totals, cost }
+  };
+}
+function runStatus(args) {
+  const unknown = args.find((arg) => arg !== "--json");
+  if (unknown) return fail(`status: unknown flag: ${unknown}`);
+  const snapshot = statusSnapshot();
+  if (args.includes("--json")) {
+    process.stdout.write(`${JSON.stringify(snapshot, null, 2)}
+`);
+    return 0;
+  }
+  process.stdout.write(`dispatch status @ ${snapshot.generatedAt} (ledger: ${clioStateDir()})
+`);
+  process.stdout.write(
+    snapshot.admission.state === "draining" ? `admission: draining until ${snapshot.admission.expiresAt} (requested by pid ${snapshot.admission.requestedByPid} at ${snapshot.admission.requestedAt})
+` : "admission: open\n"
+  );
+  if (snapshot.running.length === 0) {
+    process.stdout.write("running: none\n");
+  } else {
+    process.stdout.write("running:\n");
+    for (const row of snapshot.running) {
+      const lineage = row.lineage;
+      process.stdout.write(
+        `  ${row.runId}  ${row.agentId}  node=${row.node}  ${row.heartbeat}  attempt=${lineage.attempt} depth=${lineage.depth}  ${Math.round(row.elapsedMs / 1e3)}s  ${renderCostAmount(row.costUsd, row.costProvenance)}
+`
+      );
+      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) {
+    process.stdout.write("retrying: none (retry queue is in-memory and only visible in the owning process)\n");
+  } else {
+    process.stdout.write("retrying:\n");
+    for (const row of snapshot.retrying) {
+      process.stdout.write(`  ${row.runId}  ${row.agentId}  attempt=${row.attempt} due=${row.dueAt}  ${row.reason}
+`);
+    }
+  }
+  const t = snapshot.totals;
+  process.stdout.write(
+    `totals: tokens=${t.totalTokens} (in=${t.inputTokens} out=${t.outputTokens}) cost=${renderCostAggregate(t.cost)} runtime=${Math.round(t.runtimeSeconds)}s
+`
+  );
+  return 0;
+}
+function runAdmissionControl(command, args) {
+  const unknown = args.find((arg) => arg !== "--json");
+  if (unknown) return fail(`${command}: unknown flag: ${unknown}`);
+  ensureClioState();
+  const admission = admissionStatus(setCapacityDraining(command === "drain"));
+  if (args.includes("--json")) {
+    process.stdout.write(`${JSON.stringify({ admission }, null, 2)}
+`);
+    return 0;
+  }
+  if (admission.state === "draining") {
+    process.stdout.write(
+      `dispatch admission is draining until ${admission.expiresAt}; running work continues (requested by pid ${admission.requestedByPid})
+`
+    );
+  } else {
+    process.stdout.write("dispatch admission is open\n");
+  }
+  return 0;
+}
+async function runFleetCommand(args) {
+  const sub = args[0];
+  if (sub === "view" && (args.includes("--help") || args.includes("-h"))) {
+    return (await import("./fleet-view-XC7WMKSS.js")).runFleetView(args.slice(1));
+  }
+  if (sub === "help" || args.includes("--help") || args.includes("-h")) {
+    process.stdout.write(HELP);
+    return 0;
+  }
+  if (sub === void 0) {
+    process.stderr.write(HELP);
+    return 2;
+  }
+  switch (sub) {
+    case "list":
+      return runList(args.slice(1));
+    case "new":
+      return (await import("./fleet-new-RCKGSRDV.js")).runFleetNew(args.slice(1));
+    case "validate":
+      return (await import("./fleet-validate-VG4JBLA4.js")).runFleetValidate(args.slice(1));
+    case "graph":
+      return (await import("./fleet-graph-ELTBXBAV.js")).runFleetGraph(args.slice(1));
+    case "commands":
+      return (await import("./fleet-commands-WS56G26H.js")).runFleetCommands(args.slice(1));
+    case "run":
+      return runFleet(args.slice(1));
+    case "status":
+      return runStatus(args.slice(1));
+    case "inspect":
+      return (await import("./fleet-inspect-45IK73L4.js")).runFleetInspect(args.slice(1));
+    case "decisions":
+      return (await import("./fleet-decisions-MYGZ3JW7.js")).runFleetDecisions(args.slice(1));
+    case "verify":
+      return (await import("./fleet-verify-VTSABAYO.js")).runFleetVerify(args.slice(1));
+    case "view":
+      return (await import("./fleet-view-XC7WMKSS.js")).runFleetView(args.slice(1));
+    case "drain":
+      return runAdmissionControl("drain", args.slice(1));
+    case "resume":
+      return runAdmissionControl("resume", args.slice(1));
+    default:
+      process.stderr.write(`clio-coder fleet: unknown subcommand '${sub}'
+`);
+      process.stderr.write(HELP);
+      return 2;
+  }
+}
+export {
+  runFleetCommand
+};
+//# sourceMappingURL=fleet-W2AF3TOJ.js.map