@iowarp/clio-coder 0.3.0

package/dist/fleet-CA2CRTVG.js

@@ -0,0 +1,760 @@
+import {
+  SchedulingDomainModule,
+  createPromptsDomainModule
+} from "./chunk-3DANZDGR.js";
+import {
+  AgentsDomainModule,
+  SafetyDomainModule
+} from "./chunk-JPOWPFCU.js";
+import {
+  LifecycleDomainModule
+} from "./chunk-NI4DEJMC.js";
+import {
+  ensureClioState
+} from "./chunk-7RBKDI66.js";
+import {
+  ConfigDomainModule,
+  loadDomains
+} from "./chunk-527KG6XR.js";
+import "./chunk-UU3R62TT.js";
+import "./chunk-HMYNFFY4.js";
+import {
+  ContextDomainModule
+} from "./chunk-UWIJNAOB.js";
+import "./chunk-X3BR7HWV.js";
+import "./chunk-VOO7NYPP.js";
+import {
+  DispatchDomainModule,
+  MiddlewareDomainModule,
+  ObservabilityDomainModule,
+  SessionDomainModule,
+  WRITE_BOUNDARY_VIOLATION_REASON,
+  capacityDrain,
+  codeStepDir,
+  compileFleetExecutionPlan,
+  createWriteBoundaryEnforcer,
+  decideReviewGate,
+  executePlan,
+  executionPlanAncestors,
+  materializePendingGateDecision,
+  openLedger,
+  preflightWriteBoundaries,
+  runCodeStep,
+  setCapacityDraining,
+  stagePendingGateDecision,
+  writeCodeStepRecord
+} from "./chunk-GNGDQYDU.js";
+import {
+  ResourcesDomainModule
+} from "./chunk-2J63S4SF.js";
+import "./chunk-RQDWMVRB.js";
+import {
+  agentRoleFactsResolver,
+  gateRouteCorrelation,
+  requestExecutionRole,
+  verifyReceiptIntegrity,
+  withAttemptRole
+} from "./chunk-7BHLZB3A.js";
+import "./chunk-TPOCL34A.js";
+import "./chunk-E3NYWENM.js";
+import {
+  FLEET_COMMANDS_REMEDY,
+  FLEET_COMMANDS_REPO_PATH,
+  FleetCommandRegistryMissingError,
+  listFleetContracts,
+  loadFleetCommands,
+  loadFleetContract,
+  renderFleetPrompt,
+  resultContractAuthorship
+} from "./chunk-XV4ZJ6ZM.js";
+import "./chunk-26BZQOAD.js";
+import "./chunk-WD6AJM35.js";
+import "./chunk-QV47YRF4.js";
+import "./chunk-CLJ5HLUD.js";
+import "./chunk-BBUH4VAA.js";
+import "./chunk-GOTUR54M.js";
+import "./chunk-KBR4MZZR.js";
+import "./chunk-262G75JS.js";
+import "./chunk-TFSSEXL6.js";
+import {
+  ProvidersDomainModule
+} from "./chunk-TKHQ4DGZ.js";
+import "./chunk-D5YD55AR.js";
+import "./chunk-JWHCJDCI.js";
+import "./chunk-UHTSULZS.js";
+import "./chunk-5LDRNKX2.js";
+import "./chunk-UGYAX5YI.js";
+import "./chunk-5N2FG33Q.js";
+import "./chunk-VPAWTYLY.js";
+import {
+  clioStateDir
+} from "./chunk-X3NE4WVW.js";
+import "./chunk-DXQNI4PC.js";
+
+// src/cli/fleet.ts
+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
+  run <name> [--var k=v ...]    preflight and execute a fleet contract
+       [--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
+  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.
+  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 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 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;
+  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() {
+  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 === "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) {
+  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 name = rest.find((arg) => !arg.startsWith("-"));
+  if (!name) return fail("usage: clio-coder fleet run <name> [--var key=value ...] [--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,
+    DispatchDomainModule,
+    SessionDomainModule,
+    LifecycleDomainModule
+  ]);
+  const dispatch = loaded.getContract("dispatch");
+  const agents = loaded.getContract("agents");
+  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 roleFacts = agentRoleFactsResolver((id) => agents.getSpec(id));
+  const preflightError = preflightFleet(contract, { agents, safety, scheduling });
+  if (preflightError !== null) {
+    await loaded.stop();
+    return fail(`preflight failed: ${preflightError}`);
+  }
+  const fleetRootId = newFleetRootId();
+  let planOutcome;
+  let plan;
+  try {
+    plan = compileFleetExecutionPlan({
+      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,
+          // 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,
+          executionRole: withAttemptRole(requestRole, context.attempt)
+        };
+      }
+    });
+  } catch (err) {
+    await loaded.stop();
+    return fail(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)}`);
+  }
+  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}
+`);
+    }
+  });
+  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 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}`;
+  };
+  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) => {
+            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)}
+`
+              );
+            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 outcome = await runCodeStep({
+          stepId: step.id,
+          command,
+          workspaceRoot: process.cwd(),
+          artifactDir: codeStepDir(fleetRootId),
+          signal,
+          ...isCommit ? {
+            substitutions: { commitMessage: commitMessageFor(step, priorResults) },
+            requireWorkspaceChanges: true
+          } : {}
+        });
+        const recordPath = await writeCodeStepRecord(fleetRootId, outcome.record);
+        if (json) process.stdout.write(`${JSON.stringify({ codeStep: outcome.record })}
+`);
+        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}
+`
+          );
+        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;
+        }
+        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 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: fleetGateCorrelation(subject, decider),
+          output: result.output
+        });
+        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}
+`
+          );
+        }
+        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);
+      }
+    });
+  } catch (err) {
+    await dispatch.drain();
+    await loaded.stop();
+    return fail(err instanceof Error ? err.message : String(err));
+  }
+  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
+      })}
+`
+    );
+  } 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)}
+`
+    );
+    for (const loop of planOutcome.loops) {
+      process.stdout.write(
+        `  loop ${loop.loopId}: ${loop.reason} after ${loop.attempts} verification(s) and ${loop.repairs} repair(s)
+`
+      );
+    }
+    if (planOutcome.revalidated.length > 0) {
+      process.stdout.write(
+        `  staleness: re-ran ${planOutcome.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 boundary of planOutcome.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;
+}
+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,
+      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,
+      node: row.node?.id ?? "local"
+    };
+  });
+  const totals = { inputTokens: 0, outputTokens: 0, totalTokens: 0, costUsd: 0, runtimeSeconds: 0 };
+  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
+  };
+}
+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  $${row.costUsd.toFixed(4)}
+`
+      );
+    }
+  }
+  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=$${t.costUsd.toFixed(4)} 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 === "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();
+    case "run":
+      return runFleet(args.slice(1));
+    case "status":
+      return runStatus(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,
+  statusSnapshot
+};
+//# sourceMappingURL=fleet-CA2CRTVG.js.map