@hawkeyexl/manni 4.5.0 → 4.6.0

package/dist/{chunk-OIZ3XMKB.js → chunk-MWBJ3KTF.js}

@@ -5,12 +5,12 @@ import {
   loadTemplateFile,
   resolveLintRun,
   resolveStructureTool
-} from "./chunk-DE7JSWXV.js";
+} from "./chunk-SWSTHZBI.js";
 import {
   parserByName,
   parserForExtension,
   unsupportedFormatMessage
-} from "./chunk-ELZ2IIOF.js";
+} from "./chunk-73TC4DYH.js";
 import {
   BLOCK_KINDS,
   BLOCK_KIND_NODE
@@ -20,7 +20,7 @@ import {
 } from "./chunk-YGFIQ6Y5.js";
 import {
   writeTextAtomic
-} from "./chunk-HVFR66GQ.js";
+} from "./chunk-TUAAR3MM.js";
 import {
   ToolError,
   errorMessage
@@ -298,4 +298,4 @@ export {
   BUILT_IN_DEFAULTS,
   runTools
 };
-//# sourceMappingURL=chunk-OIZ3XMKB.js.map
+//# sourceMappingURL=chunk-MWBJ3KTF.js.map

package/dist/chunk-N7JSEDSC.js

@@ -0,0 +1,233 @@
+#!/usr/bin/env node
+import {
+  pathKey
+} from "./chunk-YLK2J5YK.js";
+import {
+  DEFAULT_CAPTURE_DIR,
+  makeRedactor
+} from "./chunk-CU57HT2E.js";
+
+// src/tracevals/rules/ledger.ts
+import { createHash } from "node:crypto";
+import { mkdir, readFile, rename, rm, writeFile } from "node:fs/promises";
+import { dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
+var LEDGER_ENTRIES = 10;
+var HISTORY_ENTRIES = 5;
+var NOTE_CHARS = 200;
+var FACT_TURNS = 30;
+var COMMAND_CHARS = 120;
+var LIMIT = { commands: 10, wrote: 10, read: 5, skills: 10, agents: 10 };
+var GAP_RUNS = 3;
+var sha256 = (s) => createHash("sha256").update(s).digest("hex");
+function idHash(id) {
+  return sha256(id).slice(0, 32);
+}
+function ledgerPath(projectDir, sessionId, agentId) {
+  const agent = agentId === null ? "" : `.${idHash(agentId)}`;
+  return join(projectDir, DEFAULT_CAPTURE_DIR, `${idHash(sessionId)}${agent}.ledger.json`);
+}
+var emptyLedger = () => ({ version: 1, turns: [], rules: {} });
+var OUTCOMES = /* @__PURE__ */ new Set(["followed", "broken", "needs-review", "not-applicable"]);
+function isEntry(v) {
+  if (typeof v !== "object" || v === null) return false;
+  const e = v;
+  return typeof e.turn === "number" && OUTCOMES.has(e.outcome) && typeof e.note === "string";
+}
+var isStrings = (v) => Array.isArray(v) && v.every((s) => typeof s === "string");
+var FACT_LISTS = ["sources", "commands", "wrote", "read", "skills", "agents"];
+function isFacts(v) {
+  if (typeof v !== "object" || v === null) return false;
+  const f = v;
+  return typeof f.turn === "number" && typeof f.inScope === "boolean" && FACT_LISTS.every((k) => isStrings(f[k]));
+}
+async function readLedger(path) {
+  let parsed;
+  try {
+    parsed = JSON.parse(await readFile(path, "utf-8"));
+  } catch {
+    return emptyLedger();
+  }
+  if (typeof parsed !== "object" || parsed === null) return emptyLedger();
+  const { version, turns, rules } = parsed;
+  if (version !== 1 || typeof rules !== "object" || rules === null) return emptyLedger();
+  const ledger = emptyLedger();
+  if (Array.isArray(turns)) ledger.turns = turns.filter(isFacts);
+  for (const [key, value] of Object.entries(rules)) {
+    if (typeof value !== "object" || value === null) continue;
+    const { text, entries } = value;
+    if (typeof text !== "string" || !Array.isArray(entries)) continue;
+    ledger.rules[key] = { text, entries: entries.filter(isEntry) };
+  }
+  return ledger;
+}
+var sourceOf = (key) => key.slice(0, key.lastIndexOf("#"));
+function keyEntries(entries) {
+  const broken = entries.filter((e) => e.outcome === "broken").reverse();
+  const picked = [entries.at(-1), entries.find((e) => e.outcome === "followed"), ...broken];
+  return [...new Set(picked.filter((e) => e !== void 0))].slice(0, HISTORY_ENTRIES).sort((a, b) => a.turn - b.turn);
+}
+function gaps(turns, source) {
+  const runs = [];
+  let open;
+  for (const t of turns) {
+    if (t.sources.includes(source)) {
+      open = void 0;
+    } else if (open !== void 0) {
+      open.to = t.turn;
+    } else {
+      open = { from: t.turn, to: t.turn };
+      runs.push(open);
+    }
+  }
+  return runs.slice(-GAP_RUNS);
+}
+function historyBlock(ledger, key, text, before) {
+  const rule = ledger.rules[key];
+  if (rule?.text !== sha256(text)) return "";
+  const shown = keyEntries(
+    rule.entries.filter((e) => e.turn < before && e.outcome !== "not-applicable")
+  );
+  if (shown.length === 0) return "";
+  const entries = shown.map((e) => ({
+    turn: e.turn,
+    line: `- turn ${String(e.turn)}: ${e.outcome}.${e.note !== "" ? ` ${e.note}` : ""}`
+  }));
+  const holes = gaps(
+    ledger.turns.filter((t) => t.turn < before),
+    sourceOf(key)
+  ).map((g) => ({
+    turn: g.from,
+    line: g.from === g.to ? `- (turn ${String(g.from)}: not in scope)` : `- (turns ${String(g.from)}\u2013${String(g.to)}: not in scope)`
+  }));
+  const lines = [...entries, ...holes].sort((a, b) => a.turn - b.turn).map((l) => l.line);
+  return `# This rule earlier in this session
+
+${lines.join("\n")}`;
+}
+var posix = (p) => p.split(sep).join("/");
+function projectPath(path, cwd, root) {
+  const abs = resolve(cwd, path);
+  const r = relative(root, abs);
+  return posix(r === "" || r.startsWith("..") || isAbsolute(r) ? abs : r);
+}
+var clipTo = (s, max) => s.length <= max ? s : `${s.slice(0, max - 1)}\u2026`;
+function turnFacts(trace, turn, sources, opts) {
+  const w = turn.window;
+  const scrub = makeRedactor(opts.redact);
+  const take = (items, n = Number.POSITIVE_INFINITY) => [...new Set(items)].slice(0, n);
+  const clip = (s) => clipTo(s, COMMAND_CHARS);
+  const rel = (path) => projectPath(path, opts.cwd, opts.root);
+  const commands = w.toolCalls.flatMap(
+    (c) => c.name === "Bash" && typeof c.input.command === "string" ? [clip(scrub(c.input.command.replace(/\s+/g, " ").trim()))] : []
+  );
+  const reads = new Set(
+    w.fileAccesses.filter((a) => a.op === "read").map((a) => pathKey(resolve(opts.cwd, a.path)))
+  );
+  return {
+    turn: turn.from,
+    inScope: sources.length > 0,
+    sources: take(sources.map((s) => s.displayPath)),
+    commands: take(commands, LIMIT.commands),
+    wrote: take(
+      w.fileAccesses.filter((a) => a.op !== "read").map((a) => scrub(rel(a.path))),
+      LIMIT.wrote
+    ),
+    read: take(
+      // A source with no file (the typed prompts, an inline plan) has path "",
+      // which would resolve to the cwd; it is never read.
+      sources.filter((s) => s.path !== "" && reads.has(pathKey(s.path))).map((s) => s.displayPath),
+      LIMIT.read
+    ),
+    skills: take(
+      w.skillInvocations.map((s) => s.name),
+      LIMIT.skills
+    ),
+    agents: w.empty ? [] : take(
+      trace.agentSpawns.filter((a) => a.index >= turn.from && a.index <= turn.to).map((a) => a.subagentType),
+      LIMIT.agents
+    )
+  };
+}
+function recordFacts(ledger, facts) {
+  const turns = [...ledger.turns.filter((t) => t.turn !== facts.turn), facts].sort((a, b) => a.turn - b.turn).slice(-FACT_TURNS);
+  return { ...ledger, turns };
+}
+function trim(entries) {
+  const first = entries.find((e) => e.outcome === "followed");
+  const out = [...entries];
+  while (out.length > LEDGER_ENTRIES) {
+    const last = out.length - 1;
+    const loose = out.findIndex((e, i) => e !== first && e.outcome !== "broken" && i !== last);
+    out.splice(loose >= 0 ? loose : out.findIndex((e) => e !== first), 1);
+  }
+  return out;
+}
+function recordTurn(ledger, turn, results) {
+  const next = { ...ledger, rules: { ...ledger.rules } };
+  for (const r of results) {
+    const hash = sha256(r.text);
+    const prior = next.rules[r.key];
+    const kept = prior?.text === hash ? prior.entries.filter((e) => e.turn !== turn) : [];
+    const entries = trim(
+      [...kept, { turn, outcome: r.outcome, note: r.note.slice(0, NOTE_CHARS) }].sort(
+        (a, b) => a.turn - b.turn
+      )
+    );
+    next.rules[r.key] = { text: hash, entries };
+  }
+  return next;
+}
+function rollup(ledger) {
+  const keys = Object.keys(ledger.rules);
+  if (ledger.turns.length === 0 && keys.length === 0) return null;
+  const rules = keys.flatMap((key) => {
+    const entries = ledger.rules[key]?.entries ?? [];
+    const last = entries.at(-1);
+    if (last === void 0) return [];
+    const source = sourceOf(key);
+    const n = (o) => entries.filter((e) => e.outcome === o).length;
+    return [
+      {
+        source,
+        rule: key.slice(source.length + 1),
+        followed: n("followed"),
+        broken: n("broken"),
+        repaired: entries.filter(
+          (e, i) => e.outcome === "broken" && entries.slice(i + 1).some((f) => f.outcome === "followed")
+        ).length,
+        needsReview: n("needs-review"),
+        notApplicable: n("not-applicable"),
+        notInScope: ledger.turns.filter((t) => !t.sources.includes(source)).length,
+        last: { turn: last.turn, outcome: last.outcome }
+      }
+    ];
+  });
+  return { turns: ledger.turns.length, rules };
+}
+async function writeLedger(path, ledger) {
+  await mkdir(dirname(path), { recursive: true });
+  const tmp = `${path}.${String(process.pid)}.tmp`;
+  await writeFile(tmp, `${JSON.stringify(ledger, null, 2)}
+`, "utf-8");
+  try {
+    await rename(tmp, path);
+  } catch (err) {
+    await rm(tmp, { force: true });
+    throw err;
+  }
+}
+
+export {
+  idHash,
+  ledgerPath,
+  readLedger,
+  historyBlock,
+  projectPath,
+  clipTo,
+  turnFacts,
+  recordFacts,
+  recordTurn,
+  rollup,
+  writeLedger
+};
+//# sourceMappingURL=chunk-N7JSEDSC.js.map

package/dist/chunk-N7JSEDSC.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/tracevals/rules/ledger.ts"],"sourcesContent":["/**\n * The session ledger (proposal 0079, \"The ledger\"). What each turn of one\n * session did, and what the in-loop judge found for each rule, so a rule\n * about a procedure that spans turns is judged with what earlier turns did.\n *\n * Only the hook writes it, one file per session and one per subagent, so\n * parallel SubagentStops never share a file. `check` by hand reads it and\n * never writes it. A missing or unreadable ledger is an empty history.\n */\nimport { createHash } from \"node:crypto\";\nimport { mkdir, readFile, rename, rm, writeFile } from \"node:fs/promises\";\nimport { dirname, isAbsolute, join, relative, resolve, sep } from \"node:path\";\nimport { DEFAULT_CAPTURE_DIR } from \"../capture/types.js\";\nimport { makeRedactor } from \"../judge/redact.js\";\nimport type { Trace } from \"../trace/types.js\";\nimport { pathKey, type RuleSource } from \"./sources.js\";\nimport type { TurnSlice } from \"./turn.js\";\n\nexport type LedgerOutcome = \"followed\" | \"broken\" | \"needs-review\" | \"not-applicable\";\n\nexport interface LedgerEntry {\n  /** The turn's first event, as an ordinal in the trace. */\n  turn: number;\n  outcome: LedgerOutcome;\n  /** The judge's reasoning, cut to `NOTE_CHARS`. */\n  note: string;\n}\n\n/** What one turn did, read from the trace with no model. */\nexport interface TurnFacts {\n  turn: number;\n  /** Whether any rule source governed the turn. */\n  inScope: boolean;\n  /** The rule sources in scope, by display path. */\n  sources: string[];\n  /** Bash commands, each clipped to `COMMAND_CHARS`. */\n  commands: string[];\n  /** Files written or edited, relative to the project. */\n  wrote: string[];\n  /** Rule sources the turn read. */\n  read: string[];\n  skills: string[];\n  /** Subagent types the turn spawned. */\n  agents: string[];\n}\n\nexport interface Ledger {\n  version: 1;\n  /** The last `FACT_TURNS` turns the hook saw, oldest first. */\n  turns: TurnFacts[];\n  /** Keyed `<source>#<id>`. `text` is the rule text's sha256, so an edited rule starts fresh. */\n  rules: Record<string, { text: string; entries: LedgerEntry[] }>;\n}\n\nexport const LEDGER_ENTRIES = 10;\nexport const HISTORY_ENTRIES = 5;\nexport const NOTE_CHARS = 200;\nexport const FACT_TURNS = 30;\nexport const COMMAND_CHARS = 120;\nconst LIMIT = { commands: 10, wrote: 10, read: 5, skills: 10, agents: 10 } as const;\n/** Runs of turns a rule's source missed, shown in its history. */\nconst GAP_RUNS = 3;\n\nconst sha256 = (s: string): string => createHash(\"sha256\").update(s).digest(\"hex\");\n\n/** A session or agent id, hashed so nothing in it can climb out of the directory. */\nexport function idHash(id: string): string {\n  return sha256(id).slice(0, 32);\n}\n\n/** `<project>/.manni/tracevals/sessions/<session hash>[.<agent id hash>].ledger.json` */\nexport function ledgerPath(projectDir: string, sessionId: string, agentId: string | null): string {\n  const agent = agentId === null ? \"\" : `.${idHash(agentId)}`;\n  return join(projectDir, DEFAULT_CAPTURE_DIR, `${idHash(sessionId)}${agent}.ledger.json`);\n}\n\nexport const emptyLedger = (): Ledger => ({ version: 1, turns: [], rules: {} });\n\nconst OUTCOMES = new Set<unknown>([\"followed\", \"broken\", \"needs-review\", \"not-applicable\"]);\n\nfunction isEntry(v: unknown): v is LedgerEntry {\n  if (typeof v !== \"object\" || v === null) return false;\n  const e = v as Record<string, unknown>;\n  return typeof e.turn === \"number\" && OUTCOMES.has(e.outcome) && typeof e.note === \"string\";\n}\n\nconst isStrings = (v: unknown): v is string[] =>\n  Array.isArray(v) && v.every((s) => typeof s === \"string\");\n\nconst FACT_LISTS = [\"sources\", \"commands\", \"wrote\", \"read\", \"skills\", \"agents\"] as const;\n\nfunction isFacts(v: unknown): v is TurnFacts {\n  if (typeof v !== \"object\" || v === null) return false;\n  const f = v as Record<string, unknown>;\n  return (\n    typeof f.turn === \"number\" &&\n    typeof f.inScope === \"boolean\" &&\n    FACT_LISTS.every((k) => isStrings(f[k]))\n  );\n}\n\n/** Never throws: anything but a well-formed ledger reads as an empty one. */\nexport async function readLedger(path: string): Promise<Ledger> {\n  let parsed: unknown;\n  try {\n    parsed = JSON.parse(await readFile(path, \"utf-8\"));\n  } catch {\n    return emptyLedger();\n  }\n  if (typeof parsed !== \"object\" || parsed === null) return emptyLedger();\n  const { version, turns, rules } = parsed as Record<string, unknown>;\n  if (version !== 1 || typeof rules !== \"object\" || rules === null) return emptyLedger();\n  const ledger = emptyLedger();\n  if (Array.isArray(turns)) ledger.turns = turns.filter(isFacts);\n  for (const [key, value] of Object.entries(rules)) {\n    if (typeof value !== \"object\" || value === null) continue;\n    const { text, entries } = value as Record<string, unknown>;\n    if (typeof text !== \"string\" || !Array.isArray(entries)) continue;\n    ledger.rules[key] = { text, entries: entries.filter(isEntry) };\n  }\n  return ledger;\n}\n\n/** The source half of a `<source>#<id>` key. */\nconst sourceOf = (key: string): string => key.slice(0, key.lastIndexOf(\"#\"));\n\n/**\n * The entries a rule's history keeps in view: its latest, its first\n * `followed`, then its `broken` ones from newest back, at most\n * `HISTORY_ENTRIES`, oldest first.\n */\nfunction keyEntries(entries: LedgerEntry[]): LedgerEntry[] {\n  const broken = entries.filter((e) => e.outcome === \"broken\").reverse();\n  const picked = [entries.at(-1), entries.find((e) => e.outcome === \"followed\"), ...broken];\n  return [...new Set(picked.filter((e): e is LedgerEntry => e !== undefined))]\n    .slice(0, HISTORY_ENTRIES)\n    .sort((a, b) => a.turn - b.turn);\n}\n\n/** The last `GAP_RUNS` runs of consecutive recorded turns whose sources leave `source` out. */\nfunction gaps(turns: TurnFacts[], source: string): { from: number; to: number }[] {\n  const runs: { from: number; to: number }[] = [];\n  let open: { from: number; to: number } | undefined;\n  for (const t of turns) {\n    if (t.sources.includes(source)) {\n      open = undefined;\n    } else if (open !== undefined) {\n      open.to = t.turn;\n    } else {\n      open = { from: t.turn, to: t.turn };\n      runs.push(open);\n    }\n  }\n  return runs.slice(-GAP_RUNS);\n}\n\n/**\n * The block a rule's item carries, or \"\" when the ledger holds nothing for it\n * before `before` other than turns it did not apply to. Runs of recorded\n * turns where its source was not in scope are marked, so a hole in the\n * history does not read as quiet.\n */\nexport function historyBlock(ledger: Ledger, key: string, text: string, before: number): string {\n  const rule = ledger.rules[key];\n  if (rule?.text !== sha256(text)) return \"\";\n  const shown = keyEntries(\n    rule.entries.filter((e) => e.turn < before && e.outcome !== \"not-applicable\"),\n  );\n  if (shown.length === 0) return \"\";\n  const entries = shown.map((e) => ({\n    turn: e.turn,\n    line: `- turn ${String(e.turn)}: ${e.outcome}.${e.note !== \"\" ? ` ${e.note}` : \"\"}`,\n  }));\n  const holes = gaps(\n    ledger.turns.filter((t) => t.turn < before),\n    sourceOf(key),\n  ).map((g) => ({\n    turn: g.from,\n    line:\n      g.from === g.to\n        ? `- (turn ${String(g.from)}: not in scope)`\n        : `- (turns ${String(g.from)}–${String(g.to)}: not in scope)`,\n  }));\n  const lines = [...entries, ...holes].sort((a, b) => a.turn - b.turn).map((l) => l.line);\n  return `# This rule earlier in this session\\n\\n${lines.join(\"\\n\")}`;\n}\n\nconst posix = (p: string): string => p.split(sep).join(\"/\");\n\n/** A path as the turn named it, relative to the project root when it is under it. */\nexport function projectPath(path: string, cwd: string, root: string): string {\n  const abs = resolve(cwd, path);\n  const r = relative(root, abs);\n  return posix(r === \"\" || r.startsWith(\"..\") || isAbsolute(r) ? abs : r);\n}\n\n/** `s` cut to at most `max` characters, the last an ellipsis when cut. */\nexport const clipTo = (s: string, max: number): string =>\n  s.length <= max ? s : `${s.slice(0, max - 1)}…`;\n\n/**\n * What the turn did, read from its window. Commands and paths pass through\n * the judge's redactor. `sources` are the rule sources in scope, none for a\n * turn that stopped before they were resolved.\n */\nexport function turnFacts(\n  trace: Trace,\n  turn: TurnSlice,\n  sources: Pick<RuleSource, \"path\" | \"displayPath\">[],\n  opts: { cwd: string; root: string; redact: readonly string[] },\n): TurnFacts {\n  const w = turn.window;\n  const scrub = makeRedactor(opts.redact);\n  const take = (items: string[], n = Number.POSITIVE_INFINITY): string[] =>\n    [...new Set(items)].slice(0, n);\n  const clip = (s: string): string => clipTo(s, COMMAND_CHARS);\n  const rel = (path: string): string => projectPath(path, opts.cwd, opts.root);\n  const commands = w.toolCalls.flatMap((c) =>\n    c.name === \"Bash\" && typeof c.input.command === \"string\"\n      ? [clip(scrub(c.input.command.replace(/\\s+/g, \" \").trim()))]\n      : [],\n  );\n  const reads = new Set(\n    w.fileAccesses.filter((a) => a.op === \"read\").map((a) => pathKey(resolve(opts.cwd, a.path))),\n  );\n  return {\n    turn: turn.from,\n    inScope: sources.length > 0,\n    sources: take(sources.map((s) => s.displayPath)),\n    commands: take(commands, LIMIT.commands),\n    wrote: take(\n      w.fileAccesses.filter((a) => a.op !== \"read\").map((a) => scrub(rel(a.path))),\n      LIMIT.wrote,\n    ),\n    read: take(\n      // A source with no file (the typed prompts, an inline plan) has path \"\",\n      // which would resolve to the cwd; it is never read.\n      sources.filter((s) => s.path !== \"\" && reads.has(pathKey(s.path))).map((s) => s.displayPath),\n      LIMIT.read,\n    ),\n    skills: take(\n      w.skillInvocations.map((s) => s.name),\n      LIMIT.skills,\n    ),\n    agents: w.empty\n      ? []\n      : take(\n          trace.agentSpawns\n            .filter((a) => a.index >= turn.from && a.index <= turn.to)\n            .map((a) => a.subagentType),\n          LIMIT.agents,\n        ),\n  };\n}\n\n/** The ledger with this turn's facts, replacing any earlier record of the same turn. */\nexport function recordFacts(ledger: Ledger, facts: TurnFacts): Ledger {\n  const turns = [...ledger.turns.filter((t) => t.turn !== facts.turn), facts]\n    .sort((a, b) => a.turn - b.turn)\n    .slice(-FACT_TURNS);\n  return { ...ledger, turns };\n}\n\nexport interface TurnResult {\n  key: string;\n  text: string;\n  outcome: LedgerOutcome;\n  note: string;\n}\n\n/**\n * Cut a rule's entries to `LEDGER_ENTRIES`. The first `followed`, every\n * `broken` and the latest are pinned, so the others go first, oldest first.\n * Only when every entry is pinned does the oldest `broken` go.\n */\nfunction trim(entries: LedgerEntry[]): LedgerEntry[] {\n  const first = entries.find((e) => e.outcome === \"followed\");\n  const out = [...entries];\n  while (out.length > LEDGER_ENTRIES) {\n    const last = out.length - 1;\n    const loose = out.findIndex((e, i) => e !== first && e.outcome !== \"broken\" && i !== last);\n    out.splice(loose >= 0 ? loose : out.findIndex((e) => e !== first), 1);\n  }\n  return out;\n}\n\n/** The ledger with this turn's results, replacing any earlier record of the same turn. */\nexport function recordTurn(ledger: Ledger, turn: number, results: TurnResult[]): Ledger {\n  const next: Ledger = { ...ledger, rules: { ...ledger.rules } };\n  for (const r of results) {\n    const hash = sha256(r.text);\n    const prior = next.rules[r.key];\n    const kept = prior?.text === hash ? prior.entries.filter((e) => e.turn !== turn) : [];\n    const entries = trim(\n      [...kept, { turn, outcome: r.outcome, note: r.note.slice(0, NOTE_CHARS) }].sort(\n        (a, b) => a.turn - b.turn,\n      ),\n    );\n    next.rules[r.key] = { text: hash, entries };\n  }\n  return next;\n}\n\nexport interface RuleRollup {\n  source: string;\n  rule: string;\n  followed: number;\n  broken: number;\n  /** Broken entries that a later `followed` entry came after. */\n  repaired: number;\n  needsReview: number;\n  notApplicable: number;\n  /** Recorded turns where the rule's source was not in scope. */\n  notInScope: number;\n  last: { turn: number; outcome: LedgerOutcome };\n}\n\nexport interface SessionRollup {\n  /** Turns the ledger records. */\n  turns: number;\n  rules: RuleRollup[];\n}\n\n/** Each rule's record over the session, or null when the ledger holds nothing. */\nexport function rollup(ledger: Ledger): SessionRollup | null {\n  const keys = Object.keys(ledger.rules);\n  if (ledger.turns.length === 0 && keys.length === 0) return null;\n  const rules = keys.flatMap((key): RuleRollup[] => {\n    const entries = ledger.rules[key]?.entries ?? [];\n    const last = entries.at(-1);\n    if (last === undefined) return [];\n    const source = sourceOf(key);\n    const n = (o: LedgerOutcome): number => entries.filter((e) => e.outcome === o).length;\n    return [\n      {\n        source,\n        rule: key.slice(source.length + 1),\n        followed: n(\"followed\"),\n        broken: n(\"broken\"),\n        repaired: entries.filter(\n          (e, i) =>\n            e.outcome === \"broken\" && entries.slice(i + 1).some((f) => f.outcome === \"followed\"),\n        ).length,\n        needsReview: n(\"needs-review\"),\n        notApplicable: n(\"not-applicable\"),\n        notInScope: ledger.turns.filter((t) => !t.sources.includes(source)).length,\n        last: { turn: last.turn, outcome: last.outcome },\n      },\n    ];\n  });\n  return { turns: ledger.turns.length, rules };\n}\n\n/** Temp file and rename, so a reader never sees half a ledger. Throws on failure. */\nexport async function writeLedger(path: string, ledger: Ledger): Promise<void> {\n  await mkdir(dirname(path), { recursive: true });\n  const tmp = `${path}.${String(process.pid)}.tmp`;\n  await writeFile(tmp, `${JSON.stringify(ledger, null, 2)}\\n`, \"utf-8\");\n  try {\n    await rename(tmp, path);\n  } catch (err) {\n    await rm(tmp, { force: true });\n    throw err;\n  }\n}\n"],"mappings":"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","names":[]}

package/dist/{chunk-MZC62HPZ.js → chunk-NBMPHD4I.js}

@@ -2,7 +2,7 @@
 import {
   TERM_FIELDS,
   displayPath
-} from "./chunk-NN4ASVTY.js";
+} from "./chunk-C73RSUIC.js";
 
 // src/term/reporters/json.ts
 function termEntry(term) {
@@ -49,4 +49,4 @@ export {
   renderFindingsJson,
   renderFormatsJson
 };
-//# sourceMappingURL=chunk-MZC62HPZ.js.map
+//# sourceMappingURL=chunk-NBMPHD4I.js.map

package/dist/{chunk-YA63PVWI.js → chunk-NHHOPZRA.js}

@@ -19,10 +19,10 @@ import {
   sha256,
   splitBody,
   urlManifestRefusal
-} from "./chunk-7OQAU4EA.js";
+} from "./chunk-Z4IZGEM3.js";
 import {
   turnBudgetSkipReason
-} from "./chunk-LJ2RDH3F.js";
+} from "./chunk-XG6PVB5S.js";
 import {
   isExecutionGrant,
   unknownGrantsMessage
@@ -33,7 +33,7 @@ import {
 import {
   externalWriteWarnings,
   offerExternalHomes
-} from "./chunk-3YHAYXBC.js";
+} from "./chunk-GREQKO6M.js";
 import {
   LOCATION_KEYWORD,
   Validator,
@@ -41,21 +41,23 @@ import {
   readManifestOrEmpty,
   readManifestValue,
   spliceManifestValue
-} from "./chunk-HVFR66GQ.js";
+} from "./chunk-TUAAR3MM.js";
 import {
   writeFileAtomic
-} from "./chunk-527HHQPS.js";
+} from "./chunk-KCOFEWV5.js";
+import {
+  noticeOnce,
+  warn
+} from "./chunk-HX44GB4Z.js";
 import {
   assertKnownProvider,
   assertLocalFlag,
   assertModelHasProvider,
   localNotice,
-  noticeOnce,
   providerSpecFor,
   resolveIdentity,
-  selectProvider,
-  warn
-} from "./chunk-Q35YIDBV.js";
+  selectProvider
+} from "./chunk-QCHVR4ZM.js";
 import {
   errorMessage
 } from "./chunk-G3T47CFV.js";
@@ -1039,4 +1041,4 @@ export {
   makeGenerateScripts,
   runRun
 };
-//# sourceMappingURL=chunk-YA63PVWI.js.map
+//# sourceMappingURL=chunk-NHHOPZRA.js.map