@sabaiway/agent-workflow-kit 2.1.0 → 3.0.0

package/tools/{seed-gates.mjs → gates-init.mjs}

@@ -1,10 +1,12 @@
 #!/usr/bin/env node
-// seed-gates.mjs — the consent-gated docs/ai/gates.json seeder (AD-042). Reached ONLY through
-// explicitly-consenting prose (the bootstrap accelerators block and the gates.md consent-seed
-// section) — it is NOT a routable mode token, it sits OUTSIDE every velocity allowlist tier
-// (a consent-per-run writer is never pre-approved), and the shipped gates.json TEMPLATE stays
-// EMPTY (AD-021/AD-038): a populated declaration is per-entry maintainer consent recorded through
-// this preview, never auto-seeding.
+// gates-init.mjs — the consented docs/ai/gates.json FILL preview (D9; the pure derivation carried
+// from the retired standalone seeder, AD-042/AD-052 invariants intact). Reached ONLY through
+// explicitly-consenting prose (the init/bootstrap flows and the gates.md consent-fill section) —
+// it is NOT a routable mode token, it sits OUTSIDE every velocity allowlist tier (a
+// consent-per-run writer is never pre-approved), and the shipped gates.json TEMPLATE stays EMPTY
+// (AD-021/AD-038): a populated declaration is per-entry maintainer consent recorded through this
+// preview, never auto-seeding. ONE lifecycle contract: this preview runs at INIT; at UPGRADE the
+// only gates.json writer is the consented legacy migration.
 //
 // What it offers (the derivation invariants, test-pinned) — CLOSED-WORLD since AD-052: an entry
 // is offered only when every axis is proven safe by MEMBERSHIP in a finite, test-guarded set,
@@ -29,7 +31,7 @@
 //     executes project-controlled tooling (a node_modules/.bin PATH shim intercepts under every
 //     form) — the documented residual, disclosed in the preview, bounded by the two consents;
 //   • ids derive kebab-case from script names (build:prod → build-prod) and every offered entry
-//     passes the runner's validateDeclaration (the seeder imports the validator — NEVER the
+//     passes the runner's validateDeclaration (this module imports the validator — NEVER the
 //     reverse: run-gates.mjs stays a runner that writes nothing);
 //   • the review-state candidate appears ONLY when docs/ai/orchestration.json DECLARES
 //     reviewed/council on plan-execution.review — the slot the checker enforces — with the
@@ -44,7 +46,7 @@
 // .workflow-version == lineage-head stamp gate on --apply only (the velocity/gate-hook precedent).
 //
 // Exit codes: 0 done / dry-run; 1 precondition STOP (no deployment, stamp, symlink, malformed
-// declaration, id collision); 2 usage. Dependency-free, Node >= 18. No side effects on import.
+// declaration, id collision); 2 usage. Dependency-free, Node >= 22. No side effects on import.
 
 import { existsSync, lstatSync, readFileSync } from 'node:fs';
 import { join, resolve, dirname } from 'node:path';
@@ -58,39 +60,40 @@ const HERE = dirname(fileURLToPath(import.meta.url));
 const KIT_ROOT = resolve(HERE, '..');
 const TEMPLATE_PATH = join(KIT_ROOT, 'references', 'templates', 'gates.json');
 const REVIEW_STATE_TOOL = join(KIT_ROOT, 'tools', 'review-state.mjs');
-const REVIEW_LEDGER_TOOL = join(KIT_ROOT, 'tools', 'review-ledger.mjs');
+const COVERAGE_CHECK_TOOL = join(KIT_ROOT, 'tools', 'coverage-check.mjs');
 const STAMP_REL = join('docs', 'ai', '.workflow-version');
 
 const EXIT_OK = 0;
 const EXIT_PRECONDITION = 1;
 const EXIT_USAGE = 2;
 
-export const SEED_GATES_STOP = 'SEED_GATES_STOP';
+export const GATES_INIT_STOP = 'GATES_INIT_STOP';
 const stop = (message) =>
-  Object.assign(new Error(`[agent-workflow-kit] ${message}`), { name: 'SeedGatesStop', code: SEED_GATES_STOP, exitCode: EXIT_PRECONDITION });
+  Object.assign(new Error(`[agent-workflow-kit] ${message}`), { name: 'GatesInitStop', code: GATES_INIT_STOP, exitCode: EXIT_PRECONDITION });
 const usageFail = (message) =>
   Object.assign(new Error(`[agent-workflow-kit] ${message}`), { exitCode: EXIT_USAGE });
 
 // The trust-chain disclosure (AD-042) — printed with EVERY preview, token-pinned by the tests: a
 // consent-seeded command becomes auto-approvable only after TWO explicit consents.
 export const TRUST_CHAIN_DISCLOSURE =
-  'Disclosure: once the optional approval hook is wired (/agent-workflow-kit hook), it ' +
-  'auto-approves byte-exact declared gate commands from the project root — seeding (this consent) ' +
-  'and hook wiring (its own consent) are two separate yeses. A script gate runs the project\'s ' +
-  'own tooling, which executes project-controlled code (the seeder does not sandbox it; the two ' +
-  'consents bound it).';
-
-const USAGE = `usage: seed-gates [--dry-run | --apply] [--only <id>]... [--cwd <dir>] [--help]
-
-Consent-gated seeder for the project's own docs/ai/gates.json. Default is --dry-run: prints the
-derived { id, title, cmd } entries and writes NOTHING. --apply APPENDS exactly the consented
-entries (--only <id> selects a subset; append-only — existing entries are never modified or
-removed, an id collision is refused). The offer is CLOSED-WORLD: only a terminating-class script
-name (test / lint / type-check / build — never release/publish/deploy, never watch/serve, never a
-write-mode variant) whose BODY is a member of the literal runner allowlist is offered, as the
-hook-free \`COREPACK_ENABLE_NETWORK=0 <pm> exec -- <body>\` form for the detected package manager. A gate-class script whose
-body is NOT in the allowlist is screened out with a note naming it (a command you trust can still
-be declared by hand); non-gate-class names are excluded silently, as always.
+  'Disclosure: gates.json is a PRIVILEGED file — once the optional approval hook is wired ' +
+  '(/agent-workflow-kit hook), it auto-approves byte-exact declared gate commands from the ' +
+  'project root — filling (this consent) and hook wiring (its own consent) are two separate ' +
+  'yeses. A script gate runs the project\'s own tooling, which executes project-controlled code ' +
+  '(this preview does not sandbox it; the two consents bound it).';
+
+const USAGE = `usage: gates-init [--dry-run | --apply] [--only <id>]... [--cwd <dir>] [--help]
+
+The consented FILL preview for the project's own docs/ai/gates.json (D9). Default is --dry-run:
+prints the derived { id, title, cmd } entries and writes NOTHING. --apply APPENDS exactly the
+consented entries (--only <id> selects a subset; append-only — existing entries are never
+modified or removed, an id collision is refused). The offer is CLOSED-WORLD: only a
+terminating-class script name (test / lint / type-check / build — never release/publish/deploy,
+never watch/serve, never a write-mode variant) whose BODY is a member of the literal runner
+allowlist is offered, as the hook-free \`COREPACK_ENABLE_NETWORK=0 <pm> exec -- <body>\` form for
+the detected package manager. A gate-class script whose body is NOT in the allowlist is screened
+out with a note naming it (a command you trust can still be declared by hand); non-gate-class
+names are excluded silently, as always.
 ${TRUST_CHAIN_DISCLOSURE}`;
 
 // ── candidate classification: the NAME screens (the LOCKED derivation invariants) ──────
@@ -310,12 +313,14 @@ export const reviewStateCandidate = (cwd, deps = {}) => {
   }
 };
 
-// The conditional review-LEDGER candidate (AD-045) — the SAME consent + conditional rule as the
-// review-state candidate (offered ONLY when plan-execution.review is reviewed/council), keyed on the
-// same slot, path resolved + QUOTED. It gates the review-ROUND ledger (converged / resolved-residual);
-// review-state gates receipt PRESENCE. Both may be offered together — distinct axes.
-export const reviewLedgerCandidate = (cwd, deps = {}) => {
-  const toolPath = deps.reviewLedgerTool ?? REVIEW_LEDGER_TOOL;
+// The conditional COVERAGE-CHECK candidate (D3(a)) — the SAME consent + conditional rule as the
+// review-state candidate (offered ONLY when plan-execution.review is reviewed/council), keyed on
+// the same slot, path resolved + QUOTED. Together they are the canonical core pair `run-gates
+// --final` requires (the checker declared LAST — buildOffer appends it last so a whole-offer
+// apply lands final-ready); review-state gates receipt satisfaction, coverage-check verifies the
+// consumed lcov + the red-proof declarations.
+export const coverageCheckCandidate = (cwd, deps = {}) => {
+  const toolPath = deps.coverageCheckTool ?? COVERAGE_CHECK_TOOL;
   try {
     const { config } = loadConfig(resolve(cwd), deps.readFile ?? readFileSync, deps.lstat ?? lstatSync);
     const declared = config?.['plan-execution']?.review;
@@ -324,15 +329,15 @@ export const reviewLedgerCandidate = (cwd, deps = {}) => {
       return {
         candidate: null,
         note:
-          `the review-ledger candidate was withheld: the resolved kit path contains shell ` +
+          `the coverage-check candidate was withheld: the resolved kit path contains shell ` +
           `metacharacters that do not survive double-quoting (${toolPath}) — declare the gate ` +
-          `by hand per references/modes/review-ledger.md`,
+          `by hand per references/modes/coverage-check.md`,
       };
     }
     return {
       candidate: {
-        id: 'review-ledger',
-        title: 'Review-round ledger: the in-flight loop is converged or resolved-residual',
+        id: 'coverage-check',
+        title: 'Changed-line coverage + red-proof verification (the final-run checker)',
         cmd: `node "${toolPath}" --check`,
       },
       note: null,
@@ -340,7 +345,7 @@ export const reviewLedgerCandidate = (cwd, deps = {}) => {
   } catch (err) {
     return {
       candidate: null,
-      note: `orchestration config unreadable (${err.message}) — the review-ledger candidate was not evaluated`,
+      note: `orchestration config unreadable (${err.message}) — the coverage-check candidate was not evaluated`,
     };
   }
 };
@@ -356,22 +361,23 @@ const assertOnlyIdsOffered = (offer, onlyIds = []) => {
   }
 };
 
-// The full offer: script entries + the conditional review-state + review-ledger candidates (last),
-// plus loud notes. Both review candidates key on the same slot (plan-execution.review reviewed/council)
-// but gate distinct axes (receipt presence vs review-round convergence) — offered together.
+// The full offer: script entries + the conditional review-state + coverage-check candidates
+// (coverage-check LAST — the `run-gates --final` declaration-shape rule requires the checker as
+// the last declared gate, so a whole-offer apply is final-ready by construction). Both key on the
+// same slot (plan-execution.review reviewed/council) but gate distinct axes.
 export const buildOffer = (cwd, deps = {}) => {
   const scripts = deriveScripts(cwd, deps);
   const rs = reviewStateCandidate(cwd, deps);
-  const rl = reviewLedgerCandidate(cwd, deps);
-  const candidates = [rs.candidate, rl.candidate].filter(Boolean);
+  const cc = coverageCheckCandidate(cwd, deps);
+  const candidates = [rs.candidate, cc.candidate].filter(Boolean);
   return {
     entries: [...scripts.entries, ...candidates],
-    notes: [...scripts.notes, rs.note, rl.note].filter(Boolean),
+    notes: [...scripts.notes, rs.note, cc.note].filter(Boolean),
   };
 };
 
 // The RUNNABLE apply invocation for a given project — this tool has no bin and no mode token, so
-// the consent step must print the real command, never a bare `seed-gates`. Consent integrity: a
+// the consent step must print the real command, never a bare `gates-init`. Consent integrity: a
 // previewed --only subset is carried into the hint VERBATIM (ids are shell-safe by construction —
 // kebabIdOf output / the fixed `review-state`), so following the hint can never widen the consent.
 // Paths that do not survive double-quoting (the reviewStateCandidate screen, same pattern) make
@@ -386,7 +392,7 @@ export const applyInvocationFor = (cwd, onlyIds = []) => {
 const GENERIC_APPLY_HINT = 're-run this same command with --apply [--only <id>]...';
 
 export const formatPreview = (offer, applyInvocation = null, { explicitOnly = false } = {}) => {
-  const lines = ['[agent-workflow-kit] gates seeding preview (dry-run — nothing was written):'];
+  const lines = ['[agent-workflow-kit] gates fill preview (dry-run — nothing was written):'];
   if (!offer.entries.length) {
     lines.push('  nothing to offer — no seedable terminating verification scripts were found.');
   }
@@ -418,14 +424,14 @@ const loadExistingDeclaration = (cwd, deps = {}) => {
     try {
       return JSON.parse(String(read(full, 'utf8')));
     } catch (err) {
-      throw stop(`${GATES_REL}: malformed JSON (${err.message}) — fix it by hand; the seeder never writes over a declaration it cannot parse`);
+      throw stop(`${GATES_REL}: malformed JSON (${err.message}) — fix it by hand; this preview never writes over a declaration it cannot parse`);
     }
   })();
   const gates = (() => {
     try {
       return validateDeclaration(parsed);
     } catch (err) {
-      throw stop(`${err.message} — fix it by hand; the seeder never writes over an invalid declaration`);
+      throw stop(`${err.message} — fix it by hand; this preview never writes over an invalid declaration`);
     }
   })();
   return { outcome: 'loaded', readme: typeof parsed._README === 'string' ? parsed._README : undefined, gates };
@@ -453,7 +459,7 @@ const readStampValue = (cwd, deps = {}) => {
 };
 
 // ── apply (append exactly the consented entries) ───────────────────────────────────────
-export const applySeed = ({ cwd, onlyIds = [] }, deps = {}) => {
+export const applyFill = ({ cwd, onlyIds = [] }, deps = {}) => {
   assertDocsAiDeployment(cwd, deps, { stop, noun: 'a gate declaration', rel: GATES_REL });
   const stampValue = readStampValue(cwd, deps);
   if (stampValue !== EXPECTED_WORKFLOW_VERSION) {
@@ -474,7 +480,7 @@ export const applySeed = ({ cwd, onlyIds = [] }, deps = {}) => {
   if (collisions.length) {
     throw stop(
       `id collision — already declared in ${GATES_REL}: ${collisions.join(', ')} (append-only: the ` +
-        `seeder never modifies or removes an existing entry; pick the others with --only, or edit by hand)`,
+        `fill never modifies or removes an existing entry; pick the others with --only, or edit by hand)`,
     );
   }
 
@@ -539,7 +545,7 @@ export const main = (argv = process.argv.slice(2), deps = {}) => {
       log(formatPreview(filtered, applyInvocationFor(cwd, args.only), { explicitOnly: args.only.length > 0 }));
       return EXIT_OK;
     }
-    const result = applySeed({ cwd, onlyIds: args.only }, deps);
+    const result = applyFill({ cwd, onlyIds: args.only }, deps);
     if (result.outcome === 'nothing') {
       log('[agent-workflow-kit] nothing to offer — no seedable terminating verification scripts were found; wrote nothing.');
       for (const note of result.notes) log(`  note: ${note}`); // the user learns WHY (same note as the preview)

package/tools/grounding.mjs

@@ -23,7 +23,7 @@
 // not-ignored path (a new untracked file would itself move the review fingerprint the facts are
 // about to ground). stdout is the default. It never commits and never runs a subscription CLI.
 //
-// Dependency-free, Node >= 18. No side effects on import (the isDirectRun idiom).
+// Dependency-free, Node >= 22. No side effects on import (the isDirectRun idiom).
 
 import { readFileSync, writeFileSync, lstatSync, realpathSync } from 'node:fs';
 import { resolve, join, relative, isAbsolute, dirname, basename, sep } from 'node:path';
@@ -31,11 +31,6 @@ import { tmpdir } from 'node:os';
 import { pathToFileURL } from 'node:url';
 import { spawnSync } from 'node:child_process';
 import { fail } from './orchestration-config.mjs';
-// (e) --ledger-summary (BUGFREE-3 / AD-049): a computed, loop/base-SCOPED review-ledger digest for
-// the facts payload. The review ledger is read-only here — grounding never writes it. ORIGINS +
-// computeTelemetry give the counts; the segment filter gives the scope.
-import { ORIGINS, computeTelemetry, filterSegmentRecords, readLedger, resolveLedgerPath, resolveBase } from './review-ledger.mjs';
-import { plansInFlight } from './review-state.mjs';
 // (f) --autonomy (AD-044 Plan 3): the effective per-project autonomy policy for the facts payload.
 // READ core only — never autonomy-write.mjs (the import-split invariant).
 import { AUTONOMY_REL, loadAutonomy, resolveAutonomy, isSparseSeedConfig } from './autonomy-config.mjs';
@@ -119,72 +114,10 @@ export const trimToBudget = (payload, budget) => {
   return { text, trimmedBytes: bytes - keep };
 };
 
-// ── (e) --ledger-summary: a loop/base-SCOPED review-ledger digest (read-only, computed) ─────────
-// `computeTelemetry` aggregates ALL loops and is not per-round-facts-shaped, so this renders the
-// in-flight SEGMENT only (plan-execution, loop, base) — the telemetry COUNTS filtered to that
-// segment, plus a terse per-round/triage/override render. Deliberately compact + distinct from the
-// review-ledger `--status` human view (that one is indented + segment-grouped): this is a byte-
-// budgeted FACTS block that agy/codex review against, so unrelated loops are excluded by construction.
-
-const baseTag = (base) => (base === null ? '(unborn branch)' : String(base).slice(0, 12));
-const countsOf = (obj) => {
-  const keys = Object.keys(obj).sort();
-  return keys.length === 0 ? '(none)' : keys.map((k) => `${k}:${obj[k]}`).join(' ');
-};
-const summaryRoundLine = (r) =>
-  `round ${r.round} — ${r.backends.map((b) => `${b.backend} ${b.degraded ? `degraded(${b.reason})` : `${b.blockers}/${b.majors}/${b.minors} ${b.verdict}`}`).join(', ')}` +
-  (r.findings.length ? ` [${r.findings.map((f) => `${f.findingKey}(${f.severity})`).join(', ')}]` : '');
-const summaryTriageLine = (t) => `triage @round ${t.round} — ${t.classifications.map((c) => `${c.findingKey}=${c.class}`).join(', ')}`;
-const summaryOverrideLine = (o) =>
-  `override @round ${o.round} [${o.scope}] — ${o.scope === 'oracle-change' ? o.files.join(', ') : o.scope === 'size-cap' ? `sanctioned ${o.sanctionedLines} lines` : o.testId}: ${o.reason}`;
-const summaryGateRunLine = (g) => `gate-run — status=${g.summary.status} ${g.summary.passed}/${g.summary.gates} green`;
-const summaryRecordLine = (r) =>
-  r.kind === 'round' ? summaryRoundLine(r) : r.kind === 'triage' ? summaryTriageLine(r) : r.kind === 'override' ? summaryOverrideLine(r) : summaryGateRunLine(r);
-
-// renderLedgerSummary(records, { loop, base }) → the scoped facts section, or '' when the segment
-// holds no records (empty/absent → nothing to ground). Pure: the caller does the I/O.
-export const renderLedgerSummary = (records, { loop, base }) => {
-  const segment = filterSegmentRecords(records, { activity: PLAN_EXECUTION, loop, base });
-  if (segment.length === 0) return '';
-  const t = computeTelemetry(segment, []).loops[0];
-  const lines = [
-    `## Review-ledger summary — loop ${loop} @ base ${baseTag(base)}`,
-    '',
-    `rounds ${t.rounds} · divergence-rounds ${t.divergenceRounds}`,
-    `finding origins — ${ORIGINS.map((k) => `${k}:${t.origins[k]}`).join(' ')}`,
-    `classifications — ${countsOf(t.classifications)}`,
-    `backend verdicts — ${Object.keys(t.backendVerdicts).sort().map((b) => `${b}{${countsOf(t.backendVerdicts[b])}}`).join(' · ') || '(none)'}`,
-    `overrides — ${countsOf(t.overrides)}`,
-    '',
-    ...segment.map(summaryRecordLine),
-  ];
-  return `${lines.join('\n')}\n`;
-};
-
-// resolveLedgerSummary({ cwd, env }) → the scoped section text for the SINGLE in-flight plan-execution
-// segment. A loud STOP unless exactly one plan is in flight (the family's single-plan discipline —
-// never guess which loop to ground). Reads the ledger read-only.
 const gitTop = (cwd) => {
   const r = gitLine(['rev-parse', '--show-toplevel'], cwd);
   return r && r.status === 0 ? r.stdout.replace(/\r?\n$/, '') : cwd;
 };
-export const resolveLedgerSummary = ({ cwd, env }) => {
-  const root = gitTop(cwd);
-  const plans = plansInFlight(root);
-  if (plans.length !== 1) {
-    throw fail(1, `--ledger-summary needs exactly one in-flight plan (in flight: ${plans.length ? plans.join(', ') : 'none'}) — resolve to one active plan`);
-  }
-  const loop = plans[0].replace(/\.md$/, '');
-  const base = resolveBase(cwd);
-  const ledgerPath = resolveLedgerPath(cwd, env);
-  const { records, readError, malformed, malformedReasons } = ledgerPath ? readLedger(ledgerPath) : { records: [], malformed: 0 };
-  // Fail CLOSED like every sibling ledger reader (No-silent-failures): an unreadable OR malformed
-  // ledger must never silently render an empty/partial digest the reviewer then grounds against — an
-  // empty section would be indistinguishable from a legitimately-empty segment.
-  if (readError) throw fail(1, `--ledger-summary cannot read the ledger (${readError}) — failing closed; inspect ${ledgerPath}`);
-  if (malformed > 0) throw fail(1, `--ledger-summary: the ledger has ${malformed} malformed line(s) — failing closed (a dropped line could hide a round/finding): ${malformedReasons.join('; ')}`);
-  return renderLedgerSummary(records, { loop, base });
-};
 
 // ── (f) --autonomy: the effective autonomy policy as a computed facts block (AD-044 Plan 3) ─────
 // The ONE shared resolver (resolveAutonomy) renders the FULL effective policy — every red-line and
@@ -310,7 +243,7 @@ export const assertScratchDestination = (outPath, cwd) => {
 const HELP = `grounding — grounded-review facts assembler for the agent-workflow family (AD-038).
 
 Usage:
-  node grounding.mjs [--constraints] [--autonomy] [--plan <path>] [--ledger-summary] [--reserve-bytes <n>] [--out <path>]
+  node grounding.mjs [--constraints] [--autonomy] [--plan <path>] [--reserve-bytes <n>] [--out <path>]
 
   --constraints        slice the root AGENTS.md "Hard Constraints" section verbatim
                        (exactly one matching heading, else a loud STOP)
@@ -322,10 +255,6 @@ Usage:
   --plan <path>        extract the plan's decision-bearing sections verbatim + whole:
                        "## Approach" + "## Verification" (REQUIRED — STOP if missing),
                        "## Decisions (locked)" when present; a duplicate heading is a STOP
-  --ledger-summary     append a COMPUTED review-ledger digest for the SINGLE in-flight
-                       plan-execution segment (rounds · origins · classifications · verdicts ·
-                       overrides + a per-round render) — "computed, not remembered" facts; a
-                       loud STOP unless exactly one plan is in flight
   --reserve-bytes <n>  the artifact share agy-review will add around these facts — the output
                        budget becomes AGY_MAX_PROMPT_BYTES − n (loud tail-trim on overflow)
   --out <path>         write instead of stdout — system-temp scratch (rewritable), or a FRESH
@@ -345,12 +274,10 @@ const parseArgs = (argv) => {
   let plan = null;
   let out = null;
   let reserve = 0;
-  let ledgerSummary = false;
   for (let i = 0; i < argv.length; i += 1) {
     const a = argv[i];
     if (a === '--constraints') constraints = true;
     else if (a === '--autonomy') autonomy = true;
-    else if (a === '--ledger-summary') ledgerSummary = true;
     else if (a === '--plan') {
       plan = argv[i + 1];
       if (!plan || plan.startsWith('--')) throw fail(2, '--plan requires a <path>');
@@ -366,10 +293,10 @@ const parseArgs = (argv) => {
       i += 1;
     } else throw fail(2, `unknown argument: ${a}`);
   }
-  if (!constraints && !autonomy && plan == null && !ledgerSummary) {
-    throw fail(2, 'nothing to assemble — pass --constraints, --autonomy, --plan <path>, and/or --ledger-summary');
+  if (!constraints && !autonomy && plan == null) {
+    throw fail(2, 'nothing to assemble — pass --constraints, --autonomy, and/or --plan <path>');
   }
-  return { constraints, autonomy, plan, out, reserve, ledgerSummary };
+  return { constraints, autonomy, plan, out, reserve };
 };
 
 const resolveBudget = (env, reserve) => {
@@ -389,7 +316,7 @@ export const main = (argv, ctx = {}) => {
   const env = ctx.env ?? process.env;
   try {
     if (argv.includes('--help') || argv.includes('-h')) return { code: 0, stdout: HELP, stderr: '' };
-    const { constraints, autonomy, plan, out, reserve, ledgerSummary } = parseArgs(argv);
+    const { constraints, autonomy, plan, out, reserve } = parseArgs(argv);
     const budget = resolveBudget(env, reserve);
 
     const readOrStop = (path, label) => {
@@ -424,10 +351,6 @@ export const main = (argv, ctx = {}) => {
     const parts = [];
     const assembled = assembleGrounding({ constraintsText, autonomyText, planText, planLabel: plan ?? 'plan' });
     if (assembled) parts.push(assembled);
-    if (ledgerSummary) {
-      const summary = resolveLedgerSummary({ cwd, env });
-      if (summary) parts.push(summary);
-    }
     const payload = parts.join('\n');
     const { text, trimmedBytes } = trimToBudget(payload, budget);
     const stderr = trimmedBytes > 0

package/tools/hide-footprint.mjs

@@ -17,7 +17,7 @@
 // path). Add-local-first, then DETECT + REPORT the residual legacy global block — removal is the
 // explicit, ASK-gated `--remove-global` (prints a restorable backup), never a default (an arbitrary
 // host's OTHER hidden repo may rely on the same root-anchored global lines). Windows is supported (text
-// edit; forward-slash patterns; CRLF preserved via EOL detection). Dependency-free, Node >= 18.
+// edit; forward-slash patterns; CRLF preserved via EOL detection). Dependency-free, Node >= 22.
 
 import {
   readFileSync, writeFileSync, statSync, readdirSync,

package/tools/inject-methodology.mjs

@@ -18,7 +18,7 @@
 // The live read is lazy + fail-loud: resolve+read the engine ONLY when a fill is actually needed, and
 // STOP loudly (never a silent fallback) when the engine is needed but absent/invalid.
 //
-// Pure string functions (testable with byte-preservation fixtures); dependency-free, Node >= 18.
+// Pure string functions (testable with byte-preservation fixtures); dependency-free, Node >= 22.
 //
 // Canonical-refresh (AD-025): a slot filled BEFORE a clause existed is normally preserved verbatim
 // (reconcile only fills an EMPTY slot). To push a NEW canonical clause to the EXISTING filled base

package/tools/known-footprint.mjs

@@ -14,7 +14,7 @@
 // count sentinel + intrinsic invariants (anchoring, uniqueness, disjointness, no subsumption) — and
 // references/contracts.md carries the human-readable mirror table, kept in sync by review.
 //
-// Pure, dependency-free, Node >= 18. The only fs touch is expandGlob (readdir/stat of a glob parent),
+// Pure, dependency-free, Node >= 22. The only fs touch is expandGlob (readdir/stat of a glob parent),
 // injected so the registry stays unit-testable without the real filesystem.
 
 import { readdirSync, statSync } from 'node:fs';

package/tools/labels.mjs

@@ -7,7 +7,7 @@
 // imports family-registry for vocabulary, and family-registry imports + re-exports the public subset
 // it exported before (the 7 state constants + DISPLAY_NAMES), so every existing importer stays green.
 //
-// Pure data, no side effects, Node >= 18. Every export is frozen — this is a contract, not a mutable.
+// Pure data, no side effects, Node >= 22. Every export is frozen — this is a contract, not a mutable.
 
 // ── manifestState values (internal; the detect-backends precedence, generalized to any member) ──────
 // These are INTERNAL — they must never reach a user surface verbatim (mapped through STATE_PUBLIC

package/tools/lcov.mjs

@@ -1,11 +1,7 @@
 #!/usr/bin/env node
-// lcov.mjs — a dependency-free LCOV parser for the fold-completeness runner's coverage.kind:"lcov"
-// branch (BUGFREE-3, AD-049 — the language-independence contract). When a verification profile
-// declares coverage.kind:"lcov", the consumer's OWN suite leaves an LCOV file at the declared path
-// (the diff-cover / c8 --reporter=lcov pattern) and this module reads it into a per-file
-// line→hits map, keyed by the SAME canonical absolute path the V8 coverage map uses — so the
-// runner's ONE uncovered-changed loop consumes either source unchanged (computeUncoveredLines /
-// effectiveCount stay the V8-only path, D10).
+// lcov.mjs — a dependency-free LCOV parser for the coverage-check final-run checker (D3(d)).
+// The declared unit-tests gate leaves an LCOV file at the fixed git-dir path and this module reads
+// it into a per-file line→hits map, keyed by a canonical absolute path.
 //
 // FAIL-CLOSED posture (the whole reason the fold gate exists): a malformed record can never mark a
 // line COVERED — a DA with a valid line but a non-integer HIT count reads the line UNCOVERED (hits 0,
@@ -16,7 +12,7 @@
 // changed executable line with NO DA entry reads non-executable — LCOV carries no separate
 // executability signal; the V8 path, which reads an absent line as uncovered, differs by format.)
 //
-// Dependency-free, Node >= 18. No side effects on import.
+// Dependency-free, Node >= 22. No side effects on import.
 
 import { join, resolve, isAbsolute, sep } from 'node:path';
 import { realpathSync } from 'node:fs';
@@ -80,8 +76,8 @@ const defaultCanon = (p) => {
 };
 
 // Segment-safe containment ('/a' never contains '/ab'); correct at the filesystem root (mirrors
-// fold-completeness-run.mjs containsPath). Defined locally so lcov.mjs never imports the runner (the
-// runner imports THIS module).
+// core-evidence.mjs containsPath). Defined locally so lcov.mjs imports no family module (its
+// consumers import THIS module).
 const containsPath = (realRoot, realAbs) =>
   realAbs === realRoot || realAbs.startsWith(realRoot.endsWith(sep) ? realRoot : realRoot + sep);
 

package/tools/lens-region.mjs

@@ -22,7 +22,7 @@
 // never a silent truncate; a file without frontmatter/`maxLines` skips the guard with a stated
 // note (such a file is outside the docs cap gate anyway).
 //
-// Pure string functions (fs only in the CLI); dependency-free, Node >= 18.
+// Pure string functions (fs only in the CLI); dependency-free, Node >= 22.
 
 import { normalizeCanonical } from './orchestration-config.mjs';
 

package/tools/manifest/validate.mjs

@@ -704,6 +704,25 @@ export const validateManifest = (skillDir) => {
     else validateModeCatalog(modeCatalog, roles, errors);
   }
 
+  // `posture` (strip-the-kit D5): the DEFAULT dispatch posture pins the wrapper ships — the
+  // checkable source the kit renders the configured posture from (before D5 these lived only in
+  // shell defaults + prose). ADDITIVE-OPTIONAL like modeCatalog (absence = a bridge predating
+  // posture labeling); a PRESENT block is typed-validated with the SAME shape rule the receipt
+  // predicate applies (isValidReceiptPosture's manifest twin): `model` a non-empty string;
+  // `effort` (when present) a non-empty string; `tier` (when present) a non-empty string or null.
+  if (Object.hasOwn(manifest, 'posture')) {
+    const posture = manifest.posture;
+    if (posture === null || typeof posture !== 'object' || Array.isArray(posture)) {
+      errors.push('`posture` must be an object of dispatch-posture pins');
+    } else {
+      if (typeof posture.model !== 'string' || posture.model.length === 0) errors.push('`posture.model` must be a non-empty string');
+      if (Object.hasOwn(posture, 'effort') && (typeof posture.effort !== 'string' || posture.effort.length === 0)) errors.push('`posture.effort` (when declared) must be a non-empty string');
+      if (Object.hasOwn(posture, 'tier') && posture.tier !== null && (typeof posture.tier !== 'string' || posture.tier.length === 0)) errors.push('`posture.tier` (when declared) must be a non-empty string or null');
+      const unknown = Object.keys(posture).filter((k) => !['model', 'effort', 'tier'].includes(k));
+      if (unknown.length > 0) errors.push(`\`posture\` carries unknown key(s): ${unknown.join(', ')} (closed vocabulary: model, effort, tier)`);
+    }
+  }
+
   if (!isStub) {
     const auth = readAuthoritativeVersion(skillDir);
     if (auth.version == null) errors.push(`could not resolve an authoritative version (${auth.from})`);

package/tools/migrate-adr-store.mjs

@@ -23,7 +23,7 @@
 //
 // Write discipline: preview (--dry-run) is the DEFAULT and writes NOTHING; --apply performs the
 // migration. It NEVER commits. Exit codes: 0 done / dry-run / no-op; 1 precondition STOP (no
-// deployment, no writable snapshot base, a failed migration); 2 usage. Dependency-free, Node >= 18.
+// deployment, no writable snapshot base, a failed migration); 2 usage. Dependency-free, Node >= 22.
 // No side effects on import.
 
 import { existsSync, readFileSync, readdirSync, statSync, mkdirSync, writeFileSync, chmodSync } from 'node:fs';
@@ -65,7 +65,7 @@ conservation proof) and writes NOTHING. --apply snapshots, force-refreshes the e
 then runs the conservation-checked migration. It NEVER commits — review the tree and commit yourself.`;
 
 // The mutually-exclusive dry-run/apply parse (a consent-gated writer never lets a later flag silently
-// decide whether it mutates) + --cwd, cloned from the seed-gates writer contract.
+// decide whether it mutates) + --cwd — the family's shared consented-writer contract.
 export const parseArgs = (argv) => {
   const parsed = argv.reduce(
     (acc, a, i) => {

package/tools/orchestration-config.mjs

@@ -16,7 +16,7 @@
 //
 // This module performs NO filesystem WRITES — only reads (loadConfig). The single fs-writer lives in
 // orchestration-write.mjs, which procedures.mjs never imports, so "procedures never reaches a writer"
-// is structurally true. Pure-where-possible (fs injectable), dependency-free, Node >= 18. No side
+// is structurally true. Pure-where-possible (fs injectable), dependency-free, Node >= 22. No side
 // effects on import.
 
 import { readFileSync, lstatSync } from 'node:fs';

package/tools/orchestration-write.mjs

@@ -10,7 +10,7 @@
 // consumed here with this module's own STOP identity, so the public API + error contract are
 // unchanged (this file's tests pin them, characterize-first).
 //
-// Dependency-free, Node >= 18. Every fs primitive is injectable (deps.*) so the guards are unit-testable.
+// Dependency-free, Node >= 22. Every fs primitive is injectable (deps.*) so the guards are unit-testable.
 
 import { CONFIG_REL, serializeConfig } from './orchestration-config.mjs';
 import { writeDocsAiFileAtomic } from './atomic-write.mjs';

package/tools/presentation.mjs

@@ -6,7 +6,7 @@
 // in the user's language per SKILL.md §4.4 — it never reads this file. Keeping the vocabulary here (a
 // frozen leaf) means the renderers carry no inline strings and the phrasing is pinned by tests.
 //
-// Pure data, no side effects, Node >= 18. Every export frozen.
+// Pure data, no side effects, Node >= 22. Every export frozen.
 
 // public state token (STATE_PUBLIC value) → the direct-CLI English phrase. `installed` is null because
 // an installed member shows its VERSION, not a phrase (the renderer special-cases it). Mirrors the

package/tools/procedures.mjs

@@ -9,7 +9,7 @@
 //
 // Invariants (mirror recipes.mjs): pure-where-possible, READ-ONLY (never writes, never commits, never
 // runs a subscription CLI). The deterministic resolution lives in the kit (resolveActivityRecipe), not
-// in the agent. Dependency-free, Node >= 18.
+// in the agent. Dependency-free, Node >= 22.
 //
 // Exit codes: 0 success (an unsatisfiable explicit override degrades LOUDLY but still exits 0 — it is a
 // valid request that gracefully degraded); 2 usage (unknown <activity> / bad --override syntax);
@@ -213,7 +213,7 @@ const reviewLoopAdvice = (slots, activity) =>
         '  • At the cap, classify every surviving blocking finding: fixable-bug (fold ONCE as a red→green test, re-review) / inherent-layer-residual (document + raise to an acceptance criterion) / escalate (the maintainer decides); a minor never forces triage.',
         ...(activity === 'plan-execution'
           ? [
-              '  • The computed instrument for THIS loop: run the FULL gate matrix with run-gates --record BEFORE recording a round (the green-baseline receipt the writer demands), then record each round + triage via review-ledger (record / classify); rounds, caps, and teeth are per SEGMENT (base = HEAD — the counter resets only at a gated commit); read the stop with review-ledger --status (its render replaces the hand-composed tally); gate the commit with review-ledger --check.',
+              '  • The computed instrument for THIS loop: declare each bugfix red BEFORE the fix (core-evidence red-proof — observed N/N red, custody-hashed); an unavailable backend gets an explicit core-evidence degrade record, never a silent skip; then stage everything, run the reviews on the STAGED tree, and mint the ONE receipt with run-gates --final (coverage + red-proof verification ride the final run); the commit is gated by commit-guard --check (the D13 ordering: any edit after the final run re-stales it); read the loop state statelessly with core-evidence summary.',
             ]
           : []),
       ]