@event4u/agent-config 14.0.0 → 14.1.0

package/dist/mcp/server.mjs

@@ -34092,6 +34092,21 @@ var init_language_mirror_hook = __esm({
 import fs55 from "node:fs";
 import path56 from "node:path";
 import { fileURLToPath as fileURLToPath31, pathToFileURL as pathToFileURL20 } from "node:url";
+function sessionSlug(session_id) {
+  return session_id.replace(/[^A-Za-z0-9._-]/gu, "_").slice(0, 80);
+}
+function ledgerFileFor(session_id) {
+  if (!session_id) {
+    return STATE_FILE2;
+  }
+  return path56.join(STATE_DIR, `${sessionSlug(session_id)}.json`);
+}
+function pendingFileFor(session_id) {
+  if (!session_id) {
+    return PENDING_FILE;
+  }
+  return path56.join(PENDING_DIR, `${sessionSlug(session_id)}.json`);
+}
 function _isObject4(v) {
   return typeof v === "object" && v !== null && !Array.isArray(v);
 }
@@ -34110,6 +34125,18 @@ function isInterrogative(prose) {
     t
   );
 }
+function isAffirmative(prose) {
+  const t = prose.trim().replace(/[.!]+$/u, "");
+  if (!t || t.length > 24) {
+    return false;
+  }
+  if (isInterrogative(t)) {
+    return false;
+  }
+  return /^(?:option\s*)?\d{1,2}[.)]?$/iu.test(t) || /^(ja|jo|jep|yes|yep|yeah|ok|okay|okey|klar|passt|gut|los|go|go ahead|mach|mach das|mach es|leg los|do it|proceed|bitte)$/iu.test(
+    t
+  );
+}
 function splitFences(prompt) {
   const fences = [];
   const prose = prompt.replace(/```[^\n]*\n([\s\S]*?)```/g, (_m, body) => {
@@ -34148,6 +34175,40 @@ function classifyAuthorization(prompt) {
   }
   return { authorized: [...authorized], evidence };
 }
+function takePending(consumer_root, session_id, now) {
+  const file = path56.join(consumer_root, pendingFileFor(session_id));
+  let raw;
+  try {
+    raw = fs55.readFileSync(file, "utf8");
+  } catch {
+    return null;
+  }
+  try {
+    fs55.rmSync(file, { force: true });
+  } catch {
+  }
+  try {
+    const decoded = JSON.parse(raw);
+    if (!_isObject4(decoded)) {
+      return null;
+    }
+    const op = decoded["op"];
+    if (typeof op !== "string" || !ALL_OPS.includes(op)) {
+      return null;
+    }
+    const recorded = typeof decoded["session_id"] === "string" ? decoded["session_id"] : "";
+    if (session_id && recorded && recorded !== session_id) {
+      return null;
+    }
+    const at = Date.parse(String(decoded["refused_at"] ?? ""));
+    if (!Number.isFinite(at) || now - at > PENDING_MAX_AGE_MS) {
+      return null;
+    }
+    return { op, session_id: recorded, refused_at: String(decoded["refused_at"]) };
+  } catch {
+    return null;
+  }
+}
 function run2(stdin_text, options) {
   let envelope = {};
   if (stdin_text.trim()) {
@@ -34173,6 +34234,12 @@ function run2(stdin_text, options) {
     return EXIT_ALLOW2;
   }
   const { authorized, evidence } = classifyAuthorization(prompt);
+  const session = typeof envelope["session_id"] === "string" ? envelope["session_id"] : "";
+  const pending = takePending(options.consumer_root, session, Date.now());
+  if (pending && !authorized.includes(pending.op) && isAffirmative(prompt)) {
+    authorized.push(pending.op);
+    evidence[pending.op] = `confirmation of the refused \`${pending.op}\` (refused ${pending.refused_at}): "${prompt.trim().slice(0, 40)}"`;
+  }
   const ledger = {
     session_id: typeof envelope["session_id"] === "string" ? envelope["session_id"] : "",
     detected_at: (/* @__PURE__ */ new Date()).toISOString(),
@@ -34181,7 +34248,7 @@ function run2(stdin_text, options) {
     prompt_chars: prompt.length
   };
   try {
-    atomic_write_json(path56.join(options.consumer_root, STATE_FILE2), ledger);
+    atomic_write_json(path56.join(options.consumer_root, ledgerFileFor(session)), ledger);
   } catch {
   }
   return EXIT_ALLOW2;
@@ -34219,7 +34286,7 @@ function _isCliEntry18() {
     return false;
   }
 }
-var EXIT_ALLOW2, STATE_FILE2, PHRASES, OUTPUT_LINE, PASTED_COMMANDS;
+var EXIT_ALLOW2, STATE_FILE2, STATE_DIR, PENDING_DIR, PENDING_FILE, PENDING_MAX_AGE_MS, ALL_OPS, PHRASES, OUTPUT_LINE, PASTED_COMMANDS;
 var init_git_authorization_hook = __esm({
   "src/scripts/git_authorization_hook.ts"() {
     "use strict";
@@ -34227,6 +34294,20 @@ var init_git_authorization_hook = __esm({
     init_hook_stdin();
     EXIT_ALLOW2 = 0;
     STATE_FILE2 = path56.join("agents", "state", "git-authorization.json");
+    STATE_DIR = path56.join("agents", "state", "git-authorization");
+    PENDING_DIR = path56.join("agents", "state", "git-authorization-pending");
+    PENDING_FILE = path56.join("agents", "state", "git-authorization-pending.json");
+    PENDING_MAX_AGE_MS = 10 * 60 * 1e3;
+    ALL_OPS = [
+      "commit",
+      "push",
+      "branch",
+      "pr-create",
+      "pr-merge",
+      "tag",
+      "release",
+      "publish"
+    ];
     PHRASES = [
       { op: "commit", re: /\b(commit(e|et|te|ten)?|committe|einchecken)\b/i },
       { op: "push", re: /\b(push(e|en|t)?|hochladen|hochschieben|raufschieben)\b/i },
@@ -34456,17 +34537,30 @@ function commandOp(command) {
   return found;
 }
 function _loadLedger(consumer_root, session_id, now) {
+  const candidates = [ledgerFileFor(session_id)];
+  if (!candidates.includes(STATE_FILE2)) {
+    candidates.push(STATE_FILE2);
+  }
+  for (const rel of candidates) {
+    const found = _readLedgerFile(path57.join(consumer_root, rel), session_id, now);
+    if (found !== null) {
+      return found;
+    }
+  }
+  return { authorized: /* @__PURE__ */ new Set(), present: false };
+}
+function _readLedgerFile(file, session_id, now) {
   try {
-    const raw = fs56.readFileSync(path57.join(consumer_root, STATE_FILE2), "utf8");
+    const raw = fs56.readFileSync(file, "utf8");
     const decoded = JSON.parse(raw);
     if (_isObject5(decoded) && Array.isArray(decoded["authorized"])) {
       const ledgerSession = typeof decoded["session_id"] === "string" ? decoded["session_id"] : "";
       if (session_id && ledgerSession && ledgerSession !== session_id) {
-        return { authorized: /* @__PURE__ */ new Set(), present: false };
+        return null;
       }
       const at = Date.parse(String(decoded["detected_at"] ?? ""));
       if (Number.isFinite(at) && now - at > LEDGER_MAX_AGE_MS) {
-        return { authorized: /* @__PURE__ */ new Set(), present: false };
+        return null;
       }
       return {
         authorized: new Set(decoded["authorized"].filter(Boolean)),
@@ -34475,7 +34569,7 @@ function _loadLedger(consumer_root, session_id, now) {
     }
   } catch {
   }
-  return { authorized: /* @__PURE__ */ new Set(), present: false };
+  return null;
 }
 function decide(command, ledger) {
   if (command === null) {
@@ -34489,7 +34583,7 @@ function decide(command, ledger) {
   if (BLOCK_OPS.has(op)) {
     const reason = `Blocked: \`${op}\` with no authorization in this turn's prompt. This operation is irreversible and non-destructive-by-default already declares it never-autonomous. Command: ${shown}. Ask the user, in one numbered-options block, and run it only after they answer this turn.`;
     return { exit: EXIT_BLOCK, stdout: "", stderr: `${reason}
-` };
+`, blockedOp: op };
   }
   if (WARN_OPS.has(op)) {
     const reason = `No \`${op}\` authorization found in this turn's prompt (commit-policy: a one-shot authorization is spent on the operation it named). If the user did authorize it this turn, proceed; otherwise stop and ask. Command: ${shown}`;
@@ -34519,6 +34613,16 @@ function run3(stdin_text, options) {
     extractCommand(envelope),
     _loadLedger(options.consumer_root, session_id, Date.now())
   );
+  if (decision.blockedOp) {
+    try {
+      atomic_write_json(path57.join(options.consumer_root, pendingFileFor(session_id)), {
+        op: decision.blockedOp,
+        session_id,
+        refused_at: (/* @__PURE__ */ new Date()).toISOString()
+      });
+    } catch {
+    }
+  }
   if (decision.stdout) {
     process.stdout.write(decision.stdout);
   }
@@ -34565,6 +34669,7 @@ var init_block_unauthorized_git = __esm({
   "src/scripts/hooks/block_unauthorized_git.ts"() {
     "use strict";
     init_hook_stdin();
+    init_state_io();
     init_git_authorization_hook();
     EXIT_ALLOW3 = 0;
     EXIT_BLOCK = 1;
@@ -35610,12 +35715,12 @@ function resolveDepth(parentRef, open) {
   if (!parent) return { depth: 2, depth_basis: "asserted-parent" };
   return { depth: parent.depth + 1, depth_basis: "observed" };
 }
-function ledgerFileFor(root, ts) {
+function ledgerFileFor2(root, ts) {
   return path60.join(root, LEDGER_DIR, `${ts.slice(0, 7)}.jsonl`);
 }
 function appendLedgerLine(root, ts, line) {
   if (is_replay_mode()) return;
-  const file = ledgerFileFor(root, ts);
+  const file = ledgerFileFor2(root, ts);
   fs59.mkdirSync(path60.dirname(file), { recursive: true });
   fs59.appendFileSync(file, `${JSON.stringify(line)}
 `, "utf8");

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "@event4u/agent-config",
     "mcpName": "io.github.event4u-app/agent-config",
-    "version": "14.0.0",
+    "version": "14.1.0",
     "description": "Governed skills, rules and commands for AI coding tools (Claude Code, Cursor, Windsurf, Copilot) — every claim machine-checked, including \"zero runtime daemon\".",
     "license": "MIT",
     "private": false,

package/src/config/gate-violation-baselines.json

@@ -34,9 +34,9 @@
       "note": "Markdown links between source artefacts that cross a pack boundary the source pack's `requires` graph does not reach — revealed when the scan root moved off the deleted packages/ tree to the live corpus (0 -> 753 artefacts scanned). 82 distinct pack pairs across 131 source files; largest single class is engineering-base -> meta (73), skills in a consumer-installable pack citing this package's own maintenance skills. Each is a link that dangles for a consumer who installs the source pack without the target's. Judged real drift rather than an over-strict gate because it is long-tailed — top bucket 22%, no single systematic cause — unlike the lint_artefact_frontmatter case, where one required shape had 0-of-288 adoption. Fix per finding: add the edge to packs.yml requires, retarget the link, or move the artefact."
     },
     "check_gate_completeness": {
-      "count": 216,
-      "landed": "2026-08-12",
-      "note": "Ledger adoption ratchet. 216 of 244 registered gates do not yet carry per-target completeness accounting (`_lib/gate_ledger.ts`) or a `// ledger-exempt:` marker. This is deliberately NOT a sweep: road-to-skill-ecosystem-gate-integrity Phase 1 adopts exactly three gates (lint_framework_leakage, check_references, lint_roadmap_complexity) plus the checker itself to prove the interface, and the remainder migrates as gates are touched. Shrink-only from here — the number may not grow, so a NEW gate must adopt or exempt.",
+      "count": 215,
+      "landed": "2026-08-17",
+      "note": "Ledger adoption ratchet. Gates registered under the CI task roots that carry neither per-target completeness accounting (`_lib/gate_ledger.ts`) nor a `// ledger-exempt:` marker. This is deliberately NOT a sweep: road-to-skill-ecosystem-gate-integrity Phase 1 adopts exactly three gates (lint_framework_leakage, check_references, lint_roadmap_complexity) plus the checker itself to prove the interface, and the remainder migrates as gates are touched. Shrink-only from here — the number may not grow, so a NEW gate must adopt or exempt. Lowered 216 -> 215 on 2026-08-17 by discharging the obligation three NEW arrivals had incurred, which is the standing rule being enforced rather than a drain: the registered population grew 244 -> 258 and three of the fourteen arrivals adopted nothing — `build_archive_index`, `check_gate_coverage`, `check_pr_ci_current`. The reading was 218 against this baseline of 216, and the missing arithmetic is that one PRE-existing gate (`lint_rule_skill_pack_reach`) had adopted in the meantime: 216 + 3 - 1 = 218. All three adopted a real ledger. `check_pr_ci_current` first took a reasoned exemption claiming no target population; the completion review refuted it from the file itself — the check rows ARE a population, and rows whose `state` is not a string were being dropped before any verdict ran, so a dropped row could be the failing one. The exemption was withdrawn and the ledger adopted, counting kept rows as read, dropped rows as skips, and rows a pre-row verdict never reached as out of scope. The denominator in this note was 14 stale (it said 244) and is now expressed without one, because a count pinned to a population that grows weekly rots faster than the count itself. Note what this lowering does NOT buy: headroom is zero either way, so the next un-adopted arrival reds this gate immediately — which is the intended behaviour and the reason the number is not padded. The refreshed `landed` is load-bearing rather than bookkeeping: `checkRatchet` returns `improved` BEFORE it evaluates staleness, so an entry left at 216 while the tree measures 215 would never expire at any age (pinned by tests/lib/gate_baseline.test.ts, which asserts `improved` at landed + STALE_AFTER_DAYS + 400 days) — the greenest available state and the worst, since it switches off the anti-fossilization clause exactly when someone has done real work.",
       "falsifier": "./scripts-run src/scripts/check_gate_completeness"
     },
     "check_depth_budget": {

package/src/scripts/_lib/gate_ledger.ts

@@ -57,7 +57,9 @@ export type GateSkipReason =
     | 'generated_artifact'
     | 'dead_scan_root'
     | 'declared_exemption'
-    | 'not_applicable_kind';
+    | 'not_applicable_kind'
+    | 'precondition_unmet'
+    | 'check_did_not_run';
 
 /**
  * One sentence per skip code, printed verbatim in the ledger's own output.
@@ -79,6 +81,8 @@ export const SKIP_REASON_MESSAGE: Record<GateSkipReason, string> = {
     dead_scan_root: 'the root this target was enumerated from no longer exists',
     declared_exemption: 'the target carries an explicit, reviewable exemption from this check',
     not_applicable_kind: 'the target is a kind of artifact this check does not apply to',
+    precondition_unmet: 'a precondition of this run settled the verdict before the target could be inspected',
+    check_did_not_run: 'the check itself could not be executed, so the target was never read',
 };
 
 /** Terminal outcomes a planned target can reach. Exactly one, exactly once. */

package/src/scripts/build_archive_index.ts

@@ -45,6 +45,7 @@ import * as path from 'node:path';
 import process from 'node:process';
 import { fileURLToPath, pathToFileURL } from 'node:url';
 
+import { GateLedger } from './_lib/gate_ledger.js';
 import { DeadScopeError, reportScanned } from './_lib/scan_scope.js';
 import { parse_frontmatter } from './validate_frontmatter.js';
 
@@ -217,12 +218,24 @@ export function archiveFiles(dir: string): string[] {
         .sort();
 }
 
-export function buildIndex(dir: string): ArchiveEntry[] {
-    return archiveFiles(dir).map((name) =>
+/**
+ * Build entries from an enumeration the CALLER already performed.
+ *
+ * Split out so the ledger's plan and the results can come from ONE walk. With
+ * two walks, a file created between them reports as a skip that never happened
+ * and a file deleted between them yields an entry that was never planned — the
+ * plan would describe a different directory state than the results.
+ */
+export function buildIndexFrom(dir: string, names: readonly string[]): ArchiveEntry[] {
+    return names.map((name) =>
         buildEntry(name.replace(/\.md$/, ''), fs.readFileSync(path.join(dir, name), 'utf8')),
     );
 }
 
+export function buildIndex(dir: string): ArchiveEntry[] {
+    return buildIndexFrom(dir, archiveFiles(dir));
+}
+
 /** Table-cell text: pipes escaped, newlines flattened, never empty. */
 function _cell(value: string | null): string {
     if (value === null) {
@@ -309,7 +322,44 @@ export function main(argv: readonly string[]): number {
     const quiet = argv.includes('--quiet');
     const dir = path.join(ROOT, ARCHIVE_REL);
 
-    const entries = buildIndex(dir);
+    // ONE walk feeds both the plan and the results.
+    //
+    // Planning the result set and completing it in the next statement would make
+    // `planned === completed, skipped=0` true by construction — an accounting
+    // line that can never report anything. Planning a SECOND walk is only
+    // marginally better: it describes a directory state the results did not come
+    // from. Enumerating once and passing that list into the builder makes the
+    // gap real — the natural future fix for an unreadable archive file is a
+    // `try/catch { continue }` in the builder, and that file then shows up here
+    // as a skip instead of vanishing.
+    //
+    // `not-extractable` is a real reading rather than a skip and therefore
+    // completes — but a frontmatter PARSE failure is swallowed by `_frontmatter`
+    // and zeroes title/verdict/status, which is a genuine per-target degrade the
+    // disposition tally cannot show. Both are visible here as the difference
+    // between the planned and completed sets.
+    const walked = archiveFiles(dir);
+    const entries = buildIndexFrom(dir, walked);
+    const planned = walked.map((f) => path.basename(f, '.md'));
+    const produced = new Set(entries.map((e) => e.slug));
+    const ledger = new GateLedger('build_archive_index');
+    ledger.plan(planned);
+    for (const slug of planned) {
+        // `check_did_not_run`, not `no_applicable_files`: the file IS one the
+        // check applies to — the entry build did not produce a reading for it.
+        if (produced.has(slug)) ledger.complete(slug);
+        else ledger.skip(slug, 'check_did_not_run');
+    }
+    // A produced entry outside the plan means the two sets came apart despite
+    // the single walk; the ledger would under-state the denominator silently.
+    const unplanned = [...produced].filter((s) => !planned.includes(s));
+    if (unplanned.length > 0) {
+        throw new Error(
+            `build_archive_index: ${String(unplanned.length)} entry/entries were produced but never ` +
+                `planned (${unplanned.slice(0, 5).join(', ')}) — the ledger denominator is wrong.`,
+        );
+    }
+
     try {
         reportScanned({
             gate: 'build_archive_index',
@@ -325,6 +375,15 @@ export function main(argv: readonly string[]): number {
         throw err;
     }
 
+    // Reported before the `--check` and write paths branch, so both publish the
+    // same accounting. NOT on all three: the earliest exit — `reportScanned`
+    // throwing `DeadScopeError` on an empty walk — returns above this line and
+    // reports nothing, which is the one exit where the accounting would say the
+    // most. Left as-is rather than papered over: the ledger has no targets to
+    // report there either, and moving it above the scope assertion would publish
+    // a plan for a root the assertion is about to reject.
+    ledger.report();
+
     const mdPath = path.join(dir, INDEX_MD);
     const jsonPath = path.join(dir, INDEX_JSON);
     const md = renderMarkdown(entries);

package/src/scripts/check_gate_coverage.ts

@@ -50,6 +50,7 @@ import { fileURLToPath, pathToFileURL } from 'node:url';
 
 import * as yaml from 'js-yaml';
 import { checkRatchet } from './_lib/gate_baseline.js';
+import { GateLedger, type GateSkipReason } from './_lib/gate_ledger.js';
 import { runCountedProbe } from './_lib/counted_probe.js';
 import { listGateScripts } from './_lib/gate_population.js';
 import { describeOutcome, namesEstateInvalidatingError } from './_lib/gate_result.js';
@@ -187,6 +188,59 @@ export function parse_scanned(output: string): number | null {
   return m === null ? null : Number(m[1]);
 }
 
+/**
+ * Map a gate verdict onto its ledger outcome.
+ *
+ * Extracted and exported so the mapping can be PINNED — it was inline, and the
+ * completion review's three sharpest findings were all mis-mappings that a
+ * discrimination test would have caught in one line each.
+ *
+ * The split is INSPECTED vs NOT INSPECTED, never pass vs fail. `fail` counts
+ * into the ledger's `scanned=` (`report()` sets `checked = completed + failed`),
+ * so a target that could not be READ must never land there — that inflates the
+ * exact number the library exists to make trustworthy. This file's own comment
+ * already says a gate that could not MEASURE "is not a gate that found
+ * violations, and it is not a gate that passed either"; this agrees with it.
+ */
+export function ledgerOutcomeFor(
+  verdict: GateResult['verdict'],
+): 'complete' | 'fail' | GateSkipReason {
+  switch (verdict) {
+    case 'pending':
+      return 'disabled_by_configuration';
+    case 'unavailable':
+      // NOT `missing_credentials`. The only manifest row carrying
+      // `unavailable_exit` is unavailable for an unbuilt `site/dist`, and the
+      // skip sentence IS the audit surface — naming a credential would send the
+      // reader hunting an unset token instead of running the build.
+      return 'no_applicable_files';
+    case 'crashed':
+      // NOT `dead_scan_root` — a gate that threw has no dead root, and the skip
+      // sentence would send the reader to check a scan path that is fine. The
+      // vocabulary was extended rather than approximated, same reasoning as the
+      // `unavailable` case above.
+      return 'check_did_not_run';
+    case 'estate_invalid':
+      // Nothing was read here either. `crashed` still reds the build through
+      // this gate's own filter and `estate_invalid` deliberately does not, but
+      // neither belongs in the inspected count.
+      return 'dead_scan_root';
+    case 'silent':
+    case 'below_floor':
+      return 'fail';
+    case 'ok':
+      return 'complete';
+    default: {
+      // Exhaustiveness guard. A `Verdict` member added later must be classified
+      // deliberately: without this, a new member would silently count as
+      // INSPECTED and both the switch and its test would stay green —
+      // re-creating the over-report this function was extracted to pin.
+      const unhandled: never = verdict;
+      throw new Error(`ledgerOutcomeFor: unhandled verdict ${String(unhandled)}`);
+    }
+  }
+}
+
 /** Classify one gate's run against its declared floor. Pure — testable without
  * spawning anything. */
 export function classify(
@@ -323,6 +377,31 @@ export function main(argv: readonly string[]): number {
     return 0;
   }
 
+  // Per-target accounting over the manifest rows. The gate that audits gate
+  // coverage was itself unaudited.
+  //
+  // Stated precisely, because the obvious justification overstates it: this gate
+  // ALREADY prints counted `pending N · unavailable N` warnings, so those two
+  // classes were not invisible. What the ledger adds is that they are expressed
+  // in the estate-wide vocabulary every other adopter uses, so a reader
+  // comparing gates does not have to learn this one's private status names — and
+  // that `crashed` and `estate_invalid`, which had no counted line at all, stop
+  // being counted as inspected.
+  //
+  // Note the two numbers this produces in one run: the ledger's `scanned=` (what
+  // was inspected) and the contract line `scanned:` (manifest rows read). They
+  // differ by the skips and that is correct, but only the latter is what
+  // `SCANNED_RE` parses.
+  const ledger = new GateLedger('check_gate_coverage');
+  // Deduplicated on purpose. `load_manifest` does not check id uniqueness, and a
+  // copy-pasted row with a forgotten rename would otherwise make `plan()` throw
+  // an uncaught LedgerUsageError — surfacing a manifest mistake as a stack trace
+  // and Node's exit 1, which this file's own contract reads as "a gate is blind,
+  // collapsed, or silent" rather than as the exit 2 a malformed manifest earns.
+  // The duplicate still runs twice and still prints twice; only the accounting
+  // refuses to double-count it.
+  ledger.plan([...new Set(specs.map((s) => s.id))]);
+
   const results = specs.map((s) => {
     if (spec_is_pending(s)) {
       const { scanned, crashed } = probe_pending(s);
@@ -332,6 +411,20 @@ export function main(argv: readonly string[]): number {
     return classify(s, scanned, crashed, exit_code, output);
   });
 
+  // `recorded` pairs with the deduplicated plan above: a duplicated manifest id
+  // must be accounted once, and recording it twice would raise the same
+  // LedgerUsageError the dedupe exists to avoid.
+  const recorded = new Set<string>();
+  for (const r of results) {
+    if (recorded.has(r.id)) continue;
+    recorded.add(r.id);
+    const outcome = ledgerOutcomeFor(r.verdict);
+    if (outcome === 'complete') ledger.complete(r.id);
+    else if (outcome === 'fail') ledger.fail(r.id, r.message);
+    else ledger.skip(r.id, outcome);
+  }
+  ledger.report();
+
   if (wantJson) {
     process.stdout.write(`${JSON.stringify({ generated_by: 'check_gate_coverage', results }, null, 2)}\n`);
   } else {

package/src/scripts/check_pr_ci_current.ts

@@ -34,12 +34,29 @@
  * Exit codes (contract §6): 0 = current, or unobservable-and-said-so ·
  * 1 = the remote answered and the verdict is not about the branch head ·
  * 2 = internal error. `scanned:` is emitted on EVERY exit path.
+ *
+ * ## The per-target ledger, and the exemption that was withdrawn
+ *
+ * This gate first shipped with a `// ledger-exempt:` marker arguing it had "no
+ * target population to account for — a short-circuiting chain of 0-3 remote
+ * facts". Its completion review refuted that from the file itself: the check
+ * rows ARE a population, and the parse below **drops** every row whose `state`
+ * is not a string. A dropped row could be the failing one, so the gate could
+ * print *"green on its own head"* over a check it never read — the precise
+ * "absence of scanning looks like absence of findings" shape the ledger exists
+ * to count.
+ *
+ * The exemption's secondary claim was accurate — every `main()` exit already
+ * self-reports through `scanReport` with an explicit `allowEmpty` reason — and
+ * that is exactly why the first argument was easy to believe. It was still
+ * resting on the false half.
  */
 
 import * as path from 'node:path';
 import { spawnSync } from 'node:child_process';
 import { fileURLToPath, pathToFileURL } from 'node:url';
 
+import { GateLedger } from './_lib/gate_ledger.js';
 import { reportScanned } from './_lib/scan_scope.js';
 
 const NETWORK_TIMEOUT_MS = 8_000;
@@ -117,6 +134,12 @@ export interface Facts {
     /** The head SHA the reported checks ran against. */
     checksHead: string | null;
     rows: readonly CheckRow[];
+    /**
+     * Names of check rows the parse DROPPED because their `state` was not a
+     * string. Carried out rather than swallowed: a dropped row could be the
+     * failing one, so it is a skip the ledger must count, not a non-event.
+     */
+    droppedRows?: readonly string[];
     /** Set when something could not be observed; forces the degrade path. */
     unobservable: string | null;
     /**
@@ -235,6 +258,51 @@ export function decide(f: Facts, opts: DecideOptions = {}): Verdict {
     };
 }
 
+/**
+ * Whether {@link decide} reached the check rows at all.
+ *
+ * Every branch above the row logic — unobservable, no open PR, behind/diverged,
+ * ahead — settles the verdict WITHOUT reading a single row state. Recording
+ * those rows as `complete` would publish `scanned=N` for a run that inspected
+ * none of them: the absence-of-scanning-reads-as-absence-of-findings inflation
+ * the ledger exists to count, in the gate that adopted it. Under `--pre-push`,
+ * `ahead` is the NORMAL state, so this is the common path, not the exotic one.
+ */
+export function rowsWereEvaluated(f: Facts): boolean {
+    if (f.unobservable !== null) return false;
+    if (f.pr === null) return false;
+    return f.relation !== 'behind' && f.relation !== 'diverged' && f.relation !== 'ahead';
+}
+
+/**
+ * Publish the row-level accounting for one run.
+ *
+ * Three populations, three outcomes: rows the parse dropped are skips (a dropped
+ * row could be the failing one), rows a row-reading verdict covered are
+ * completions, and rows the verdict never reached are out of scope for THIS run.
+ *
+ * The line is emitted even under `--quiet` — {@link GateLedger.report} writes
+ * unconditionally by design, so a `--quiet` run of this gate is one line louder
+ * than before. Stated here because it is a change to this gate's own contract.
+ */
+function reportRowLedger(f: Facts): void {
+    const ledger = new GateLedger('check_pr_ci_current');
+    const dropped = new Set(f.droppedRows ?? []);
+    // Duplicate check names are a normal remote condition — a cancelled re-run
+    // beside a live one, two workflows sharing a job name, or a dropped row
+    // whose name equals a kept row's. `plan` throws on a repeat, and this gate
+    // promises to degrade rather than block, so the plan is deduplicated.
+    const planned = [...new Set([...f.rows.map((r) => r.name), ...dropped])];
+    ledger.plan(planned);
+    const evaluated = rowsWereEvaluated(f);
+    for (const name of planned) {
+        if (dropped.has(name)) ledger.skip(name, 'not_applicable_kind');
+        else if (evaluated) ledger.complete(name);
+        else ledger.outOfScope(name, 'precondition_unmet');
+    }
+    ledger.report();
+}
+
 /**
  * Ancestry between the local tip and the PR head.
  *
@@ -261,7 +329,7 @@ export function relate(
 /** Gather the facts `decide` consumes. Every failure becomes `unobservable`. */
 export function gather(repo: string): Facts {
     const empty: Facts = {
-        pr: null, prHead: null, localHead: null, checksHead: null, rows: [], unobservable: null, relation: 'unknown',
+        pr: null, prHead: null, localHead: null, checksHead: null, rows: [], droppedRows: [], unobservable: null, relation: 'unknown',
     };
 
     const branch = run('git', ['rev-parse', '--abbrev-ref', 'HEAD'], repo);
@@ -296,9 +364,19 @@ export function gather(repo: string): Facts {
     // with parseable stdout is DATA, not an error. Treating it as unobservable
     // would make the gate blind in exactly the red case it exists for.
     let rows: CheckRow[] = [];
+    // A row whose `state` is not a string is DROPPED, and that drop is the one
+    // thing in this gate worth counting: a dropped row could be the failing one,
+    // and without accounting the gate prints "green on its own head" over a
+    // check it never read. `dropped` is surfaced by the caller through the
+    // ledger rather than swallowed here.
+    let dropped: string[] = [];
     if (checks.stdout.trim() !== '') {
         try {
-            rows = (JSON.parse(checks.stdout) as CheckRow[]).filter((r) => typeof r.state === 'string');
+            const parsed = JSON.parse(checks.stdout) as CheckRow[];
+            rows = parsed.filter((r) => typeof r.state === 'string');
+            dropped = parsed
+                .filter((r) => typeof r.state !== 'string')
+                .map((r, i) => (typeof r.name === 'string' ? r.name : `row-${String(i)}`));
         } catch {
             rows = [];
         }
@@ -329,6 +407,7 @@ export function gather(repo: string): Facts {
         localHead: localSha,
         checksHead: runsHead.ok && runsHead.stdout.trim() !== '' ? runsHead.stdout.trim() : null,
         rows,
+        droppedRows: dropped,
         unobservable: null,
         relation: relate(repo, localSha, prSha),
     };
@@ -374,7 +453,11 @@ export function main(argv?: readonly string[]): number {
 
     let verdict: Verdict;
     try {
-        verdict = decide(gather(repo), { prePush });
+        const facts = gather(repo);
+        // The verdict comes FIRST: whether the rows were inspected at all is a
+        // property of the verdict's path, not of the parse (see reportRowLedger).
+        verdict = decide(facts, { prePush });
+        reportRowLedger(facts);
     } catch (exc) {
         scanReport(0, 'internal error — nothing was compared');
         process.stderr.write(