@iowarp/clio-coder 0.3.9 → 0.4.1

package/dist/fleet-decisions-OTHB6KRL.js

@@ -0,0 +1,157 @@
+import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
+import {
+  gateDecisionsDirectory,
+  verifyGateDecisionArtifact
+} from "./chunk-GPPB3JBE.js";
+import "./chunk-IG7BCQBA.js";
+import "./chunk-GCSMB2KY.js";
+import "./chunk-UL3WSD3F.js";
+import "./chunk-ECH6PKUQ.js";
+import "./chunk-K6BSR66V.js";
+import "./chunk-MQXIVJ35.js";
+import "./chunk-R346GLFC.js";
+import "./chunk-BTK3SSSK.js";
+import "./chunk-IWHMRKLL.js";
+import {
+  clioStateDir
+} from "./chunk-BYP5D4HI.js";
+import "./chunk-WEPFGWHJ.js";
+import {
+  init_esm_shims
+} from "./chunk-3R73A4XB.js";
+
+// src/cli/fleet-decisions.ts
+init_esm_shims();
+
+// src/domains/dispatch/gate-topology.ts
+init_esm_shims();
+import { existsSync, readdirSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+var GATE_TOPOLOGY_MAX_DECISIONS = 8;
+var GATE_TOPOLOGY_MAX_SUBJECTS = 6;
+var GATE_TOPOLOGY_MAX_SCAN = 128;
+var REASON_RULES = [
+  ["every candidate builder failed", "all-candidates-failed"],
+  ["builder ended ", "builder-run-failed"],
+  ["reviewer ended ", "reviewer-run-failed"],
+  ["reviewer reported ", "reviewer-checks-failed"],
+  ["reviewer did not return a valid verifier report", "reviewer-report-invalid"],
+  ["judge ended ", "judge-run-failed"],
+  ["judge result must", "judge-result-invalid"],
+  ["judge result has unknown fields", "judge-result-invalid"],
+  ["judge winner must be an integer", "judge-winner-out-of-range"],
+  ["judge picked failed or missing candidate", "judge-picked-failed-candidate"],
+  ["judge-selected candidate ", "winner-touches-protected-artifact"],
+  ["operator confirmation ", "operator-confirmed-winner"],
+  ["full-auto applied ", "full-auto-applied-winner"]
+];
+var SAFE_GATE_IDENTIFIER = /^[A-Za-z0-9._:-]{1,128}$/u;
+function classifyReason(detail) {
+  if (typeof detail !== "string" || detail.length === 0) return null;
+  return REASON_RULES.find(([prefix]) => detail.startsWith(prefix))?.[1] ?? "unclassified";
+}
+function safeIdentifier(value) {
+  return typeof value === "string" && SAFE_GATE_IDENTIFIER.test(value) ? value : null;
+}
+function byNewest(a, b) {
+  return (Date.parse(b.createdAt) || 0) - (Date.parse(a.createdAt) || 0);
+}
+function readDecisionWindow(stateDir) {
+  const directory = gateDecisionsDirectory(stateDir);
+  if (!existsSync(directory)) return { present: false, artifacts: [], unverifiable: 0 };
+  let entries;
+  try {
+    entries = readdirSync(directory).filter((name) => name.endsWith(".json"));
+  } catch {
+    return { present: true, artifacts: [], unverifiable: 0 };
+  }
+  const artifacts = [];
+  let unverifiable = 0;
+  for (const name of entries.slice(0, GATE_TOPOLOGY_MAX_SCAN)) {
+    let artifact;
+    try {
+      artifact = JSON.parse(readFileSync(join(directory, name), "utf8"));
+    } catch {
+      unverifiable += 1;
+      continue;
+    }
+    if (verifyGateDecisionArtifact(artifact).ok) artifacts.push(artifact);
+    else unverifiable += 1;
+  }
+  artifacts.sort(byNewest);
+  return { present: true, artifacts, unverifiable };
+}
+function projectDecision(artifact) {
+  const id = safeIdentifier(artifact.id);
+  const group = safeIdentifier(artifact.group);
+  if (id === null || group === null) return null;
+  const allSubjects = artifact.subjects.map((subject) => safeIdentifier(subject.runId));
+  if (allSubjects.some((runId) => runId === null)) return null;
+  const subjects = allSubjects.slice(0, GATE_TOPOLOGY_MAX_SUBJECTS);
+  const decider = artifact.decider === void 0 ? null : safeIdentifier(artifact.decider.runId);
+  if (artifact.decider !== void 0 && decider === null) return null;
+  let winner = null;
+  if (artifact.winner !== void 0) {
+    const runId = safeIdentifier(artifact.winner.subject.runId);
+    if (runId === null) return null;
+    winner = { index: artifact.winner.index, runId };
+  }
+  return {
+    id,
+    group,
+    topology: artifact.topology,
+    cycle: artifact.cycle,
+    outcome: artifact.outcome,
+    decidedAt: new Date(artifact.createdAt).toISOString(),
+    subjects,
+    subjectsTruncated: allSubjects.length > subjects.length,
+    decider,
+    correlation: artifact.correlation === void 0 ? null : { ...artifact.correlation },
+    winner,
+    confirms: artifact.confirmation === void 0 ? null : safeIdentifier(artifact.confirmation.id),
+    reason: classifyReason(artifact.detail)
+  };
+}
+function gateTopology(stateDir = clioStateDir()) {
+  const { present, artifacts, unverifiable } = readDecisionWindow(stateDir);
+  const window = artifacts.slice(0, GATE_TOPOLOGY_MAX_DECISIONS);
+  const decisions = [];
+  for (const artifact of window) {
+    const decision = projectDecision(artifact);
+    if (decision !== null) decisions.push(decision);
+  }
+  return {
+    present,
+    decisions,
+    truncated: artifacts.length > window.length || decisions.length !== window.length,
+    unverifiable
+  };
+}
+
+// src/cli/fleet-decisions.ts
+function fleetDecisionsSnapshot(now = Date.now) {
+  const topology = gateTopology();
+  return {
+    version: 1,
+    generatedAt: new Date(now()).toISOString(),
+    available: topology.present,
+    decisions: topology.decisions,
+    truncated: topology.truncated,
+    unverifiable: topology.unverifiable
+  };
+}
+function runFleetDecisions(args) {
+  if (args.length !== 1 || args[0] !== "--json") {
+    process.stderr.write("clio-coder fleet decisions: usage: clio-coder fleet decisions --json\n");
+    return 2;
+  }
+  process.stdout.write(`${JSON.stringify(fleetDecisionsSnapshot(), null, 2)}
+`);
+  return 0;
+}
+export {
+  GATE_TOPOLOGY_MAX_DECISIONS as FLEET_DECISIONS_MAX,
+  GATE_TOPOLOGY_MAX_SUBJECTS as FLEET_DECISIONS_MAX_SUBJECTS,
+  runFleetDecisions
+};
+//# sourceMappingURL=fleet-decisions-OTHB6KRL.js.map

package/dist/{fleet-graph-2J3OOIPO.js → fleet-graph-YTEZUCUT.js}

@@ -1,35 +1,38 @@
 import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
 import {
   inspectFleet
-} from "./chunk-EBOC7MT3.js";
-import "./chunk-YSEHGPCT.js";
-import "./chunk-HCBCAYZU.js";
+} from "./chunk-MOPSG2X7.js";
+import "./chunk-THYWACCR.js";
+import "./chunk-MA3H6DM5.js";
+import "./chunk-ZJLUDYFY.js";
 import "./chunk-DR52UMZW.js";
-import "./chunk-AD7Y7STJ.js";
-import "./chunk-AMKHQW3C.js";
-import "./chunk-HKO36JWF.js";
-import "./chunk-HPCTNZM2.js";
+import "./chunk-HUAS7ITX.js";
+import "./chunk-NDDGJUXD.js";
+import "./chunk-FEFIFZTL.js";
+import "./chunk-CTJ4RNAA.js";
 import "./chunk-RKKLTLYB.js";
-import "./chunk-5QKCQQ3E.js";
+import "./chunk-SUW5DORT.js";
 import "./chunk-H7IXIC72.js";
-import "./chunk-S4COXYBG.js";
-import "./chunk-MV3K5QF2.js";
+import "./chunk-HHV2GANA.js";
+import "./chunk-IG7BCQBA.js";
+import "./chunk-GCSMB2KY.js";
 import "./chunk-UL3WSD3F.js";
 import "./chunk-ECH6PKUQ.js";
 import "./chunk-5B2AEOW5.js";
-import "./chunk-CGKSTWHD.js";
+import "./chunk-K6BSR66V.js";
 import "./chunk-XPLRXC72.js";
 import "./chunk-IHXBNWMM.js";
-import "./chunk-PNY46YEY.js";
-import "./chunk-FQ4SKYE4.js";
+import "./chunk-EIMVLWB3.js";
+import "./chunk-D7E7WCDF.js";
+import "./chunk-EBY63B7G.js";
 import "./chunk-IWHMRKLL.js";
-import "./chunk-XDOQXGFO.js";
+import "./chunk-BWW4HLO4.js";
 import "./chunk-LL4KHSZI.js";
-import "./chunk-4ZG3XFUR.js";
+import "./chunk-NLFAQR7Z.js";
 import "./chunk-IKCO5N3L.js";
 import "./chunk-3I7MS7N2.js";
 import "./chunk-APJ265NV.js";
-import "./chunk-BNAZZHFG.js";
+import "./chunk-BYP5D4HI.js";
 import "./chunk-WEPFGWHJ.js";
 import {
   init_esm_shims
@@ -124,4 +127,4 @@ function runFleetGraph(args) {
 export {
   runFleetGraph
 };
-//# sourceMappingURL=fleet-graph-2J3OOIPO.js.map
+//# sourceMappingURL=fleet-graph-YTEZUCUT.js.map

package/dist/fleet-inspect-SS6YMDCK.js

@@ -0,0 +1,445 @@
+import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
+import {
+  loadFleetRunViewModel,
+  loadRunViewModel
+} from "./chunk-7RY5VZPH.js";
+import {
+  truncateToWidth
+} from "./chunk-YAKGTXEV.js";
+import {
+  listFleetRuns,
+  openLedger
+} from "./chunk-XKA2ICR3.js";
+import "./chunk-GPPB3JBE.js";
+import "./chunk-6NJQITNH.js";
+import "./chunk-TVH4ONAM.js";
+import "./chunk-TD3PGPQA.js";
+import "./chunk-THYWACCR.js";
+import "./chunk-RVG5JXAL.js";
+import "./chunk-3DPEIQKN.js";
+import "./chunk-6CCS4G3W.js";
+import "./chunk-6VC4OV3Z.js";
+import "./chunk-T56WDKA5.js";
+import "./chunk-W6GROXXM.js";
+import "./chunk-AFKWHWXF.js";
+import "./chunk-TXOTCRLG.js";
+import "./chunk-HVDIIIQW.js";
+import "./chunk-CTJ4RNAA.js";
+import "./chunk-RKKLTLYB.js";
+import "./chunk-SUW5DORT.js";
+import {
+  COUNCIL_MAX_MEMBERS
+} from "./chunk-2VG7KLYV.js";
+import "./chunk-7EPLI7VL.js";
+import "./chunk-6DWBAZ5U.js";
+import "./chunk-PVAMAVBB.js";
+import "./chunk-IXJT6DCX.js";
+import {
+  sanitizeCallTargetText
+} from "./chunk-TVHHYFHE.js";
+import "./chunk-42FMPA75.js";
+import "./chunk-H7IXIC72.js";
+import "./chunk-VN3SHNBN.js";
+import "./chunk-OQE5J4C6.js";
+import "./chunk-FSP7CMNU.js";
+import "./chunk-R23Z6K6I.js";
+import "./chunk-OZNBF4L3.js";
+import "./chunk-4BJ5BYCE.js";
+import "./chunk-6XLNIQDB.js";
+import "./chunk-U2WB7TZS.js";
+import "./chunk-VAVR4IJY.js";
+import "./chunk-2LEAKD4C.js";
+import "./chunk-HHV2GANA.js";
+import "./chunk-IG7BCQBA.js";
+import "./chunk-GCSMB2KY.js";
+import "./chunk-UL3WSD3F.js";
+import "./chunk-ECH6PKUQ.js";
+import "./chunk-5B2AEOW5.js";
+import "./chunk-K6BSR66V.js";
+import "./chunk-XAKHZX5N.js";
+import "./chunk-33YXPOE3.js";
+import "./chunk-7CR24IG7.js";
+import "./chunk-XPLRXC72.js";
+import "./chunk-UEDMSP56.js";
+import "./chunk-CFGTUFWB.js";
+import "./chunk-72GZI5EV.js";
+import "./chunk-CWVRRIEI.js";
+import "./chunk-MQXIVJ35.js";
+import "./chunk-R346GLFC.js";
+import "./chunk-PMZVFWSR.js";
+import "./chunk-HLW2MRKE.js";
+import "./chunk-BTK3SSSK.js";
+import "./chunk-IHXBNWMM.js";
+import "./chunk-EIMVLWB3.js";
+import "./chunk-D7E7WCDF.js";
+import "./chunk-HJWWJ6IL.js";
+import "./chunk-JIEGK6UF.js";
+import "./chunk-EBY63B7G.js";
+import "./chunk-6EJMN2Y3.js";
+import "./chunk-IWHMRKLL.js";
+import "./chunk-QKIFBZKT.js";
+import "./chunk-BWW4HLO4.js";
+import "./chunk-LL4KHSZI.js";
+import "./chunk-NLFAQR7Z.js";
+import "./chunk-CDNVLKUX.js";
+import "./chunk-WNP7O5WZ.js";
+import "./chunk-336NSSKI.js";
+import "./chunk-IKCO5N3L.js";
+import "./chunk-3I7MS7N2.js";
+import "./chunk-APJ265NV.js";
+import "./chunk-BYP5D4HI.js";
+import "./chunk-WEPFGWHJ.js";
+import "./chunk-NUGM5KR6.js";
+import "./chunk-O42A54GG.js";
+import "./chunk-VXMFAE2W.js";
+import "./chunk-YXLYO42X.js";
+import {
+  init_esm_shims
+} from "./chunk-3R73A4XB.js";
+
+// src/cli/fleet-inspect.ts
+init_esm_shims();
+
+// src/domains/dispatch/council-topology.ts
+init_esm_shims();
+var COUNCIL_TOPOLOGY_MAX_COUNCILS = 4;
+var COUNCIL_TOPOLOGY_MAX_MEMBERS = COUNCIL_MAX_MEMBERS;
+var COUNCIL_TOPOLOGY_MAX_TURNS = 3;
+var COUNCIL_TOPOLOGY_MAX_SCAN = 256;
+var SYNTHESIS_LABEL = "synthesis";
+var SEALED_REPORT_AGENT_ID = "council-synthesis";
+var SEALED_REPORT_TASKS = [
+  ["Council none synthesis", "none"],
+  ["Council vote synthesis", "vote"],
+  ["Council judge synthesis", "judge"]
+];
+var COUNCIL_MEMBER_LABEL = /^[a-z][a-z0-9_-]{0,31}$/u;
+function isRunStatus(value) {
+  return value === "queued" || value === "running" || value === "completed" || value === "failed" || value === "interrupted" || value === "stale" || value === "dead";
+}
+function isRunOutcome(value) {
+  return value === "succeeded" || value === "failed" || value === "timed_out" || value === "stalled" || value === "canceled" || value === "denied_by_policy" || value === "spawn_failed";
+}
+function outcomeOf(row) {
+  return isRunOutcome(row.outcome) ? row.outcome : null;
+}
+function statusOf(row) {
+  return isRunStatus(row.status) ? row.status : "stale";
+}
+function synthesisKindOf(task) {
+  return SEALED_REPORT_TASKS.find(([text]) => text === task)?.[1] ?? null;
+}
+function byRound(a, b) {
+  return a.round - b.round || (a.runId < b.runId ? -1 : a.runId > b.runId ? 1 : 0);
+}
+function partition(group, rows) {
+  const members = [];
+  const judges = [];
+  const sealed = [];
+  for (const row of rows) {
+    if (row.council?.label !== SYNTHESIS_LABEL) {
+      members.push(row);
+      continue;
+    }
+    if (row.agentId === SEALED_REPORT_AGENT_ID) sealed.push(row);
+    else judges.push(row);
+  }
+  return { group, members, judges, sealed };
+}
+function projectMembers(rows) {
+  const byLabel = /* @__PURE__ */ new Map();
+  let rejected = 0;
+  for (const row of rows) {
+    const label = row.council?.label ?? "";
+    if (!COUNCIL_MEMBER_LABEL.test(label)) {
+      rejected += 1;
+      continue;
+    }
+    const bucket = byLabel.get(label);
+    if (bucket === void 0) byLabel.set(label, [row]);
+    else bucket.push(row);
+  }
+  const labels = [...byLabel.keys()].sort();
+  const named = labels.slice(0, COUNCIL_TOPOLOGY_MAX_MEMBERS);
+  const members = [];
+  for (const label of named) {
+    const bucket = byLabel.get(label) ?? [];
+    const head = bucket[0];
+    if (head === void 0) continue;
+    const turns = bucket.map(
+      (row) => ({
+        round: row.council?.round ?? 1,
+        runId: row.id,
+        status: statusOf(row),
+        outcome: outcomeOf(row),
+        terminal: row.endedAt !== null
+      })
+    ).sort(byRound);
+    const visible = turns.slice(0, COUNCIL_TOPOLOGY_MAX_TURNS);
+    members.push({
+      label,
+      agentId: head.agentId,
+      targetId: head.targetId,
+      wireModelId: head.wireModelId,
+      executionRole: head.executionRole,
+      turns: visible,
+      turnsTruncated: turns.length > visible.length
+    });
+  }
+  return { members, truncated: labels.length > named.length, rejected };
+}
+function projectSynthesis(rows) {
+  const sealed = rows.sealed[0] ?? null;
+  const judge = rows.judges[0] ?? null;
+  return {
+    kind: sealed === null ? null : synthesisKindOf(sealed.task),
+    sealedRunId: sealed?.id ?? null,
+    judge: judge === null ? null : {
+      runId: judge.id,
+      agentId: judge.agentId,
+      targetId: judge.targetId,
+      wireModelId: judge.wireModelId,
+      status: statusOf(judge),
+      outcome: outcomeOf(judge)
+    }
+  };
+}
+function originOf(rows) {
+  const value = rows.find((row) => row.requestOrigin !== void 0)?.requestOrigin;
+  return value === "user" || value === "agent" || value === "internal" ? value : null;
+}
+function approvalOf(rows) {
+  const value = rows.find((row) => row.plan !== void 0)?.plan?.approval;
+  return value === "operator" || value === "full-auto" ? value : null;
+}
+function firstStart(rows) {
+  let earliest = rows[0]?.startedAt ?? (/* @__PURE__ */ new Date(0)).toISOString();
+  for (const row of rows) if (row.startedAt < earliest) earliest = row.startedAt;
+  return earliest;
+}
+function lastEnd(rows) {
+  let latest = null;
+  for (const row of rows) {
+    if (row.endedAt === null) return null;
+    if (latest === null || row.endedAt > latest) latest = row.endedAt;
+  }
+  return latest;
+}
+function councilTopologies(rows) {
+  const grouped = /* @__PURE__ */ new Map();
+  for (const row of rows.slice(0, COUNCIL_TOPOLOGY_MAX_SCAN)) {
+    const group = row.council?.group;
+    if (typeof group !== "string" || group.length === 0) continue;
+    const bucket = grouped.get(group);
+    if (bucket === void 0) grouped.set(group, [row]);
+    else bucket.push(row);
+  }
+  const groups = [...grouped.entries()];
+  const window = groups.slice(0, COUNCIL_TOPOLOGY_MAX_COUNCILS);
+  const councils = [];
+  for (const [group, rowsInGroup] of window) {
+    const parts = partition(group, rowsInGroup);
+    const { members, truncated, rejected } = projectMembers(parts.members);
+    const synthesis = projectSynthesis(parts);
+    const roundsObserved = members.reduce(
+      (highest, member) => member.turns.reduce((inner, turn) => Math.max(inner, turn.round), highest),
+      0
+    );
+    const sealedRound = parts.sealed[0]?.council?.round;
+    const roundsPlanned = typeof sealedRound === "number" && Number.isInteger(sealedRound) && sealedRound > 0 ? sealedRound : null;
+    councils.push({
+      group,
+      startedAt: firstStart(rowsInGroup),
+      endedAt: lastEnd(rowsInGroup),
+      running: rowsInGroup.some((row) => row.endedAt === null),
+      // A sealed report stamps the configured round count, so a member seen in
+      // a later round than the report claims means the two disagree about the
+      // same council. Reporting the higher of the two keeps the invariant that
+      // observed never exceeds planned without hiding the member row.
+      roundsPlanned: roundsPlanned === null ? null : Math.max(roundsPlanned, roundsObserved),
+      roundsObserved,
+      origin: originOf(rowsInGroup),
+      approval: approvalOf(rowsInGroup),
+      members,
+      membersTruncated: truncated,
+      membersRejected: rejected,
+      synthesis
+    });
+  }
+  return { councils, truncated: groups.length > window.length };
+}
+
+// src/cli/fleet-inspect.ts
+var FLEET_INSPECT_MAX_RUNS = 8;
+var FLEET_INSPECT_MAX_EVENTS = 32;
+var FLEET_INSPECT_MAX_ROOTS = 4;
+var FLEET_INSPECT_MAX_STEPS = 24;
+var FLEET_INSPECT_MAX_COUNCILS = COUNCIL_TOPOLOGY_MAX_COUNCILS;
+var FLEET_INSPECT_MAX_COUNCIL_MEMBERS = COUNCIL_TOPOLOGY_MAX_MEMBERS;
+var FLEET_INSPECT_MAX_COUNCIL_TURNS = COUNCIL_TOPOLOGY_MAX_TURNS;
+var IDENTITY_WIDTH = 128;
+var TASK_WIDTH = 400;
+var EVENT_LABEL_WIDTH = 96;
+var EVENT_DETAIL_WIDTH = 240;
+var OUTCOME_WIDTH = 160;
+var STEP_ID_WIDTH = 96;
+function bounded(value, width) {
+  const sanitized = sanitizeCallTargetText(value);
+  if (sanitized.length === 0) return "unavailable";
+  return sanitizeCallTargetText(truncateToWidth(sanitized, width, "\u2026", false));
+}
+function evidenceProjection(text) {
+  if (text.startsWith("receipt pending;")) {
+    return {
+      state: "pending",
+      summary: "Receipt pending; this run has not finalized."
+    };
+  }
+  if (text.startsWith("RECEIPT INTEGRITY FAILED:")) {
+    return {
+      state: "failed",
+      summary: "Clio Coder rejected the stored receipt's integrity."
+    };
+  }
+  if (text.startsWith("receipt unavailable:")) {
+    return {
+      state: "unavailable",
+      summary: "The durable receipt is unavailable."
+    };
+  }
+  if (text.startsWith("trust v")) {
+    return { state: "verified", summary: bounded(text, EVENT_DETAIL_WIDTH) };
+  }
+  return {
+    state: "unavailable",
+    summary: "Receipt trust could not be classified."
+  };
+}
+function fleetInspectSnapshot(now = Date.now) {
+  const ledgerRows = openLedger().list();
+  const selected = ledgerRows.slice(0, FLEET_INSPECT_MAX_RUNS);
+  const topology = councilTopologies(ledgerRows.slice(0, COUNCIL_TOPOLOGY_MAX_SCAN));
+  const runs = [];
+  for (const row of selected) {
+    const model = loadRunViewModel(row.id, { now });
+    if (model === null) continue;
+    const visibleEvents = model.transcript.slice(-FLEET_INSPECT_MAX_EVENTS);
+    runs.push({
+      runId: bounded(model.runId, IDENTITY_WIDTH),
+      agentId: bounded(model.agentId, IDENTITY_WIDTH),
+      model: bounded(model.model, IDENTITY_WIDTH),
+      target: bounded(model.target, IDENTITY_WIDTH),
+      node: bounded(model.node, IDENTITY_WIDTH),
+      phase: bounded(model.phase, IDENTITY_WIDTH),
+      startedAt: model.startedAt,
+      elapsedMs: model.elapsedMs,
+      task: model.task === void 0 ? null : bounded(model.task, TASK_WIDTH),
+      journal: model.journalPresent ? "available" : "missing",
+      events: visibleEvents.map((event) => ({
+        at: event.at,
+        label: bounded(event.label, EVENT_LABEL_WIDTH),
+        detail: event.detail === void 0 ? null : bounded(event.detail, EVENT_DETAIL_WIDTH)
+      })),
+      eventsTruncated: model.transcriptTruncated || model.transcript.length > visibleEvents.length,
+      evidence: evidenceProjection(model.evidence),
+      outcome: model.outcome === null ? null : bounded(model.outcome, OUTCOME_WIDTH),
+      outcomeDetail: model.outcomeDetail === null ? null : bounded(model.outcomeDetail, OUTCOME_WIDTH),
+      terminal: model.terminal
+    });
+  }
+  const rootRecords = listFleetRuns();
+  const selectedRoots = rootRecords.slice(0, FLEET_INSPECT_MAX_ROOTS);
+  const roots = [];
+  for (const record of selectedRoots) {
+    const model = loadFleetRunViewModel(record.id, { now });
+    if (model === null) continue;
+    const visibleSteps = model.steps.slice(0, FLEET_INSPECT_MAX_STEPS);
+    roots.push({
+      rootId: bounded(model.rootId, IDENTITY_WIDTH),
+      fleet: bounded(model.fleet, IDENTITY_WIDTH),
+      startedAt: model.startedAt,
+      elapsedMs: model.elapsedMs,
+      running: model.running,
+      resumedFrom: model.resumedFrom === null ? null : bounded(model.resumedFrom, IDENTITY_WIDTH),
+      plannedSteps: model.plannedSteps,
+      recordedSteps: model.recordedSteps,
+      steps: visibleSteps.map((step) => ({
+        stepId: bounded(step.stepId, STEP_ID_WIDTH),
+        runId: step.runId === null ? null : bounded(step.runId, IDENTITY_WIDTH),
+        agentId: step.agentId === null ? null : bounded(step.agentId, IDENTITY_WIDTH),
+        outcome: bounded(step.outcome, OUTCOME_WIDTH),
+        detail: step.detail === void 0 ? null : bounded(step.detail, OUTCOME_WIDTH)
+      })),
+      stepsTruncated: model.steps.length > visibleSteps.length
+    });
+  }
+  const councils = topology.councils.map((council) => ({
+    group: bounded(council.group, IDENTITY_WIDTH),
+    startedAt: council.startedAt,
+    endedAt: council.endedAt,
+    running: council.running,
+    roundsPlanned: council.roundsPlanned,
+    roundsObserved: council.roundsObserved,
+    origin: council.origin,
+    approval: council.approval,
+    members: council.members.map((member) => ({
+      label: bounded(member.label, IDENTITY_WIDTH),
+      agentId: bounded(member.agentId, IDENTITY_WIDTH),
+      target: bounded(member.targetId, IDENTITY_WIDTH),
+      model: bounded(member.wireModelId, IDENTITY_WIDTH),
+      executionRole: member.executionRole,
+      turns: member.turns.map((turn) => ({
+        round: turn.round,
+        runId: bounded(turn.runId, IDENTITY_WIDTH),
+        status: turn.status,
+        outcome: turn.outcome,
+        terminal: turn.terminal
+      })),
+      turnsTruncated: member.turnsTruncated
+    })),
+    membersTruncated: council.membersTruncated,
+    membersRejected: council.membersRejected,
+    synthesis: {
+      kind: council.synthesis.kind,
+      sealedRunId: council.synthesis.sealedRunId === null ? null : bounded(council.synthesis.sealedRunId, IDENTITY_WIDTH),
+      judge: council.synthesis.judge === null ? null : {
+        runId: bounded(council.synthesis.judge.runId, IDENTITY_WIDTH),
+        agentId: bounded(council.synthesis.judge.agentId, IDENTITY_WIDTH),
+        target: bounded(council.synthesis.judge.targetId, IDENTITY_WIDTH),
+        model: bounded(council.synthesis.judge.wireModelId, IDENTITY_WIDTH),
+        status: council.synthesis.judge.status,
+        outcome: council.synthesis.judge.outcome
+      }
+    }
+  }));
+  return {
+    version: 1,
+    generatedAt: new Date(now()).toISOString(),
+    runs,
+    truncated: ledgerRows.length > selected.length || runs.length !== selected.length,
+    roots,
+    rootsTruncated: rootRecords.length > selectedRoots.length || roots.length !== selectedRoots.length,
+    councils,
+    councilsTruncated: topology.truncated || ledgerRows.length > COUNCIL_TOPOLOGY_MAX_SCAN
+  };
+}
+function runFleetInspect(args) {
+  if (args.length !== 1 || args[0] !== "--json") {
+    process.stderr.write("clio-coder fleet inspect: usage: clio-coder fleet inspect --json\n");
+    return 2;
+  }
+  process.stdout.write(`${JSON.stringify(fleetInspectSnapshot(), null, 2)}
+`);
+  return 0;
+}
+export {
+  FLEET_INSPECT_MAX_COUNCILS,
+  FLEET_INSPECT_MAX_COUNCIL_MEMBERS,
+  FLEET_INSPECT_MAX_COUNCIL_TURNS,
+  FLEET_INSPECT_MAX_EVENTS,
+  FLEET_INSPECT_MAX_ROOTS,
+  FLEET_INSPECT_MAX_RUNS,
+  FLEET_INSPECT_MAX_STEPS,
+  runFleetInspect
+};
+//# sourceMappingURL=fleet-inspect-SS6YMDCK.js.map

package/dist/{fleet-preflight-CZRJ4JP5.js → fleet-preflight-PBY4VYOM.js}

@@ -2,24 +2,21 @@ import { createRequire as __clioCreateRequire } from "node:module"; const requir
 import {
   fleetPreflightVerdict,
   readFleetPreflightRecords,
-  recordFleetPreflight,
   routeFactVerdict,
   runFleetNodePreflight
-} from "./chunk-5HFBWUMU.js";
+} from "./chunk-AFKWHWXF.js";
 import "./chunk-TXOTCRLG.js";
-import "./chunk-CMZWFGD2.js";
-import "./chunk-I4HZDVNP.js";
-import "./chunk-KV2AOLDF.js";
+import "./chunk-VAVR4IJY.js";
+import "./chunk-2LEAKD4C.js";
+import "./chunk-BTK3SSSK.js";
 import "./chunk-6EJMN2Y3.js";
 import "./chunk-IWHMRKLL.js";
-import "./chunk-BNAZZHFG.js";
-import "./chunk-WEPFGWHJ.js";
+import "./chunk-BYP5D4HI.js";
 import "./chunk-3R73A4XB.js";
 export {
   fleetPreflightVerdict,
   readFleetPreflightRecords,
-  recordFleetPreflight,
   routeFactVerdict,
   runFleetNodePreflight
 };
-//# sourceMappingURL=fleet-preflight-CZRJ4JP5.js.map
+//# sourceMappingURL=fleet-preflight-PBY4VYOM.js.map