@event4u/agent-config 17.0.0 → 17.2.0

package/src/scripts/lint_decision_classes.ts

@@ -34,6 +34,7 @@ import process from 'node:process';
 import { fileURLToPath } from 'node:url';
 
 import { assertScanned, DeadScopeError } from './_lib/scan_scope.js';
+import { OWNER_LOCKED_CLASSES } from './ai_council/ownership_classes.js';
 
 const _HERE = fileURLToPath(import.meta.url);
 const _PROG = 'lint_decision_classes';
@@ -65,6 +66,19 @@ export const RESOLVER_FORMS: readonly string[] = [
     'owner',
 ];
 
+/**
+ * Locked-class rows resolved by the council before the owner lock reached this
+ * lint (road-to-a-tick-the-shipped-path-earns 2.2, decision A6). Listed rather
+ * than rewritten, so a fifth cannot land; each waits on the owner's ruling on
+ * blocker `delegated-owner-defaults`.
+ */
+export const LOCKED_RESOLVER_BASELINE: ReadonlySet<string> = new Set([
+    'agents/roadmaps/road-to-an-update-that-installs-itself-only-when-it-is-safe.md#D7',
+    'agents/roadmaps/road-to-an-update-that-installs-itself-only-when-it-is-safe.md#D8',
+    'agents/roadmaps/road-to-authority-routing-mechanism.md#D11',
+    'agents/roadmaps/road-to-placeholders-on-the-wire.md#D7',
+]);
+
 /**
  * Unresolved-decision markers. Deliberately narrow: every pattern is a phrase
  * an author writes when they KNOW a decision is open, never a word that shows
@@ -206,6 +220,21 @@ export function checkOwnershipColumn(rel: string, lines: readonly string[]): Vio
                         `team:<record>, owner`,
                 });
             }
+            const id = (cells[0] ?? '').replace(/`/g, '').trim();
+            if (
+                OWNER_LOCKED_CLASSES.has(owner) &&
+                resolved !== 'owner' &&
+                !LOCKED_RESOLVER_BASELINE.has(`${rel}#${id}`)
+            ) {
+                out.push({
+                    file: rel,
+                    line: i + 1,
+                    reason:
+                        `ownership=\`${owner}\` is locked to the owner (ownership_classes.ts), ` +
+                        `so resolved by=\`${resolved}\` cannot close it. Record a council answer ` +
+                        `as \`owner\` with a decision cell starting "proposed".`,
+                });
+            }
         }
     }
     return out;
@@ -438,6 +467,11 @@ function _selfTest(): number {
     if (checkFile('m2.md', resolved).length !== 0) {
         failures.push('a marker naming its own closure row red');
     }
+    const locked = good.replace('critical-technical | council:rec-1', 'product-owned | council:rec-1');
+    if (checkFile('l.md', locked).length === 0) failures.push('a locked class closed by the council did not red');
+    if (checkFile('l2.md', locked.replace('council:rec-1', 'owner')).length !== 0) {
+        failures.push('a locked class closed by the owner red');
+    }
     const dangling = 'Pick the codec: TBD — closed as D9.\n';
     if (checkFile('m3.md', dangling).length === 0) {
         failures.push('a marker naming a row that does not exist did not red');

package/src/scripts/lint_hook_manifest.ts

@@ -93,6 +93,7 @@ const EVENT_VOCABULARY: ReadonlySet<string> = new Set([
   "agent_error",
   "subagent_start",
   "subagent_stop",
+  "instructions_loaded",
 ]);
 
 // Known platform identifiers.
@@ -276,6 +277,30 @@ function _check_concerns(manifest: YamlObject, errors: string[]): Set<string> {
         }
       }
     }
+    // `payload_fields:` — field-level projection of the declared bodies. A
+    // non-list is ignored at run time, which would silently hand the concern
+    // whole bodies; a projection on a guard is ignored by design, so declaring
+    // one there states a narrowing that never happens.
+    if ("payload_fields" in spec) {
+      const raw = spec["payload_fields"];
+      if (!Array.isArray(raw) || raw.length === 0 || raw.some((f) => typeof f !== "string" || f === "")) {
+        errors.push(
+          `concerns.${name}: 'payload_fields' must be a non-empty list of key names`,
+        );
+      }
+      if (!("needs_payload_bodies" in spec)) {
+        errors.push(
+          `concerns.${name}: 'payload_fields' without 'needs_payload_bodies' ` +
+            `narrows bodies the concern never receives — declare the body classes`,
+        );
+      }
+      if (spec["fail_closed"] === true || spec["severity"] === "blocking") {
+        errors.push(
+          `concerns.${name}: 'payload_fields' has no effect on a blocking or ` +
+            `fail-closed concern, which always receives whole bodies — remove it`,
+        );
+      }
+    }
     // `re_arm:` — the named boundary at which a rebuilt prompt prefix is
     // expected and paid for once (`road-to-runtime-context-floors` step 1.2).
     // `check_prefix_stable_mutation` reads this key to decide whether a

package/src/scripts/lint_roadmap_blockers.ts

@@ -281,6 +281,27 @@ const TECHNICAL_CLASSES: ReadonlySet<string> = new Set([
  * parses as `1`: the taxonomy name is documentation for the reader and must
  * not have to be spelled identically in every entry to stay valid.
  */
+/** A `## Decisions` row resolved by `owner`, dated, that names blocker `id`. */
+function _ownerDecisionNames(text: string, id: string): boolean {
+    const lines = text.split('\n');
+    const start = lines.findIndex((l) => /^##\s+Decisions\s*$/.test(l));
+    if (start < 0) return false;
+    let resolvedCol = -1;
+    for (let i = start + 1; i < lines.length && !/^##\s/.test(lines[i] as string); i += 1) {
+        const line = (lines[i] as string).trim();
+        if (!line.startsWith('|')) continue;
+        const cells = line.replace(/^\|/, '').replace(/\|$/, '').split('|').map((c) => c.trim());
+        if (resolvedCol < 0) {
+            resolvedCol = cells.findIndex((c) => /^resolved[ _]by$/i.test(c));
+            continue;
+        }
+        if (cells[resolvedCol]?.replace(/`/g, '') !== 'owner') continue;
+        if (!line.includes(id) || !/\b\d{4}-\d{2}-\d{2}\b/.test(line)) continue;
+        return true;
+    }
+    return false;
+}
+
 function _blockerClass(body: string): string {
     const m = CLASS_FIELD_RE.exec(body);
     if (!m) {
@@ -341,6 +362,8 @@ interface ScanResult {
     decidability: Violation[];
     /** Open human-owned entries with no `Routed:` field — counted against its own ratchet. */
     routing: Violation[];
+    /** Resolved human-only entries no owner `## Decisions` row names — ratcheted (K1). */
+    ownerClose: Violation[];
 }
 
 /** What a scan needs to resolve a qualified reference: who it is, and where it may point. */
@@ -354,6 +377,7 @@ function _scanBoth(rawText: string, ctx: ScanContext = {}): ScanResult {
     const violations: Violation[] = [];
     const decidability: Violation[] = [];
     const routing: Violation[] = [];
+    const ownerClose: Violation[] = [];
     const text = _stripFencedCode(rawText);
     const declaredIds = new Set<string>();
     const userDecisionIds = new Set<string>();
@@ -416,6 +440,15 @@ function _scanBoth(rawText: string, ctx: ScanContext = {}): ScanResult {
             // Resolved entries are history — re-litigating a decision already
             // made would be churn, and the ratchet would never reach zero.
             const isResolved = /^-[ \t]*\*\*Status:\*\*[ \t]*resolved/im.test(body);
+            if (isResolved && ['', '3'].includes(_blockerClass(body)) && !_ownerDecisionNames(text, cur.id)) {
+                ownerClose.push({
+                    line: _lineAt(text, sectionStart + cur.start),
+                    message:
+                        `blocker '${cur.id}' is human-only and resolved, but no \`## Decisions\` row ` +
+                        'resolved by `owner` names it with a date — a class-3 blocker closes only on an ' +
+                        'owner decision (road-to-a-tick-the-shipped-path-earns 2.3)',
+                });
+            }
             if (!isResolved) {
                 openIds.add(cur.id);
                 // The class/run contract is HARD rather than ratcheted, and it
@@ -552,7 +585,7 @@ function _scanBoth(rawText: string, ctx: ScanContext = {}): ScanResult {
     violations.sort((a, b) => a.line - b.line);
     decidability.sort((a, b) => a.line - b.line);
     routing.sort((a, b) => a.line - b.line);
-    return { hard: violations, decidability, routing };
+    return { hard: violations, decidability, routing, ownerClose };
 }
 
 interface LocalBlockers {
@@ -920,10 +953,11 @@ function main(): number {
     let failed = 0;
     const undecidable: Array<{ rel: string; v: Violation }> = [];
     const unrouted: Array<{ rel: string; v: Violation }> = [];
+    const unowned: Array<{ rel: string; v: Violation }> = [];
     for (const roadmap of roadmaps) {
         const rel = _relPosix(roadmap, REPO_ROOT);
         const text = fs.readFileSync(roadmap, 'utf-8');
-        const { hard, decidability, routing } = _scanBoth(text, {
+        const { hard, decidability, routing, ownerClose } = _scanBoth(text, {
             selfStem: path.basename(roadmap, '.md'),
             index,
         });
@@ -933,6 +967,9 @@ function main(): number {
         for (const v of routing) {
             unrouted.push({ rel, v });
         }
+        for (const v of ownerClose) {
+            unowned.push({ rel, v });
+        }
         if (hard.length) {
             failed += 1;
             process.stderr.write(`❌  ${rel}\n`);
@@ -1021,12 +1058,24 @@ function main(): number {
                 '    See templates/roadmaps.md rule 20 "Route before you file".\n',
         );
     }
-    if (!verdict.ok || !routingVerdict.ok) {
+    const ownerVerdict = checkRatchet({
+        gate: 'lint_roadmap_blockers:owner-close',
+        actual: unowned.length,
+        repoRoot: REPO_ROOT,
+    });
+    if (!ownerVerdict.ok) {
+        process.stderr.write(`❌  ${ownerVerdict.message}\n`);
+        for (const { rel, v } of unowned) {
+            process.stderr.write(`    ${rel}:${v.line}: ${v.message}\n`);
+        }
+    }
+    if (!verdict.ok || !routingVerdict.ok || !ownerVerdict.ok) {
         return 1;
     }
     if (!QUIET) {
         process.stdout.write(`\n✅  ${roadmaps.length} roadmap(s) blocker-contract-clean\n`);
         process.stdout.write(`✅  ${routingVerdict.message}\n`);
+        process.stdout.write(`✅  ${ownerVerdict.message}\n`);
         process.stdout.write(
             `✅  0 blocker id(s) open in both an active and an archived roadmap ` +
                 `(${_globArchivedRoadmaps().length} archived file(s) read)\n`,

package/src/scripts/mcp_server/consumer_tool_catalog.json

@@ -93,7 +93,7 @@
     },
     {
       "name": "chat_history_read",
-      "description": "Read recent entries back from the consumer project's chat-history JSONL (`agents/runtime/.agent-chat-history`; `agents/.agent-chat-history` accepted for back-compat). Use to recover context from an earlier session — decisions, notes, phase markers — at the start of a new task. Read-only. Returns the resolved file path plus a list of matching entries (newest last). Combine `session`, `last`, and `entry_type` to narrow the result.",
+      "description": "Read recent entries from the chat-history JSONL (`agents/runtime/.agent-chat-history`; legacy `agents/.agent-chat-history` accepted) to recover decisions, notes and phase markers from an earlier session. Returns the resolved path and matching entries, newest last.",
       "side_effect": "ro",
       "implemented_on": [
         "stdio"
@@ -116,7 +116,7 @@
           },
           "path": {
             "type": "string",
-            "description": "Optional history-file path override; defaults to the standard chat-history location under the project root."
+            "description": "History-file override; default is the standard location."
           },
           "around": {
             "type": "integer",
@@ -142,7 +142,7 @@
               "full"
             ],
             "default": "full",
-            "description": "'index' returns compact rows (ref, t tag, ~100-char preview, tokens_estimate) instead of full entries — scan first, then re-read the refs you need via `around` or a narrowed filter. History entries are large, so index mode pays off here. 'full' (default) returns complete entries."
+            "description": "'index' returns compact rows (ref, t tag, preview, tokens_estimate) — scan, then re-read refs via `around` or a filter. 'full' (default) returns whole entries."
           }
         },
         "additionalProperties": false
@@ -222,6 +222,29 @@
         "readOnlyHint": true
       }
     },
+    {
+      "name": "graph_area",
+      "description": "One code-map area by id, exact name or member file: files, hubs, dependencies. Else refused.",
+      "side_effect": "ro",
+      "implemented_on": [
+        "stdio"
+      ],
+      "input_schema": {
+        "type": "object",
+        "required": [
+          "area"
+        ],
+        "properties": {
+          "area": {
+            "type": "string"
+          }
+        },
+        "additionalProperties": false
+      },
+      "annotations": {
+        "readOnlyHint": true
+      }
+    },
     {
       "name": "graph_dead",
       "description": "Symbols with no accepted reference that no declared entry point names. REFUSES (status `refused`) while a source is unreadable: with no exportedness recorded, an exported-but-unimported symbol is indistinguishable from a dead one. Never a deletion recommendation.",
@@ -283,6 +306,22 @@
         "readOnlyHint": false
       }
     },
+    {
+      "name": "graph_map_status",
+      "description": "Is there a code map (agents/map/)? Its freshness, counts and MAP.md path.",
+      "side_effect": "ro",
+      "implemented_on": [
+        "stdio"
+      ],
+      "input_schema": {
+        "type": "object",
+        "properties": {},
+        "additionalProperties": false
+      },
+      "annotations": {
+        "readOnlyHint": true
+      }
+    },
     {
       "name": "graph_node",
       "description": "One symbol in full: where it is declared, what reaches it, what it reaches, and how connected it is. Resolves EXACTLY (node id, then label) and refuses anything it cannot — it never scores free text, so an answer is always about the node you named.",
@@ -325,7 +364,15 @@
               "uses",
               "inherits",
               "member",
-              "tests"
+              "tests",
+              "routes-to",
+              "renders",
+              "includes",
+              "reads",
+              "migrates",
+              "persists",
+              "relates",
+              "documents"
             ],
             "description": "Restrict to one relation. Omit for all of them."
           }
@@ -527,7 +574,7 @@
     },
     {
       "name": "memory_lookup",
-      "description": "Retrieve engineering-memory entries for one or more memory types, optionally narrowed to specific anchor paths. Use before editing a security-sensitive or historically buggy file to surface prior incidents, ownership, and patterns tied to it. WORKFLOW: call with detail:\"index\" FIRST — each row carries id, title and tokens_estimate (the cost of fetching it) — then fetch full bodies via memory_get ONLY for the ids you will actually use, batching multiple ids into one call. Reads `agents/memory/<type>/*.yml` plus the `agents/memory/intake/*.jsonl` signal log. Read-only. Returns the v1 retrieval envelope: a `status` field plus per-type `slices` carrying the matched entries.",
+      "description": "Engineering-memory entries for one or more types, optionally narrowed to anchor paths — use before editing a security-sensitive or historically buggy file. Call with detail:\"index\" FIRST (rows carry id, title, tokens_estimate), then memory_get only the ids you will use, batched. Reads `agents/memory/<type>/*.yml` and `agents/memory/intake/*.jsonl`. Returns a `status` plus per-type `slices`.",
       "side_effect": "ro",
       "implemented_on": [
         "stdio"
@@ -568,7 +615,7 @@
           "token_budget": {
             "type": "integer",
             "minimum": 1,
-            "description": "Optional token budget. When set, entries are rendered as one-line compact rows (id, type, confidence, `line`) and the row set is hard-cut at token_budget × 4 chars; omitted hits appear as a top-level `truncation` hint naming a concrete next step. Absent → the envelope is unchanged."
+            "description": "Optional: render compact rows (id, type, confidence, `line`) hard-cut at token_budget × 4 chars; omitted hits yield a top-level `truncation` hint."
           }
         },
         "required": [

package/src/scripts/mcp_server/graph_tools.ts

@@ -62,6 +62,7 @@ import {
     testsFor,
     untested,
 } from '../code_graph/verbs.js';
+import { areaReport, readMap } from '../code_graph/map.js';
 import type { BuiltinTool } from './tools.js';
 
 /** The `no graph here` answer, in one place so all five agree on its shape. */
@@ -119,7 +120,22 @@ function str(args: Record<string, unknown>, key: string): string {
  * drift. An enum that silently lost a value would turn a legal filter into a
  * rejected argument.
  */
-const RELATIONS = ['calls', 'imports', 'uses', 'inherits', 'member', 'tests'] as const;
+const RELATIONS = [
+    'calls',
+    'imports',
+    'uses',
+    'inherits',
+    'member',
+    'tests',
+    'routes-to',
+    'renders',
+    'includes',
+    'reads',
+    'migrates',
+    'persists',
+    'relates',
+    'documents',
+] as const;
 
 function num(args: Record<string, unknown>, key: string, dflt: number): number {
     const v = args[key];
@@ -360,4 +376,60 @@ export const GRAPH_TOOLS: Record<string, BuiltinTool> = {
             }));
         },
     },
+    graph_map_status: {
+        name: 'graph_map_status',
+        side_effect: 'ro',
+        description: 'Is there a code map (agents/map/)? Its freshness, counts and MAP.md path.',
+        input_schema: { type: 'object', properties: {}, additionalProperties: false },
+        handler: async (_args, root) => {
+            const staleness = graphState(root);
+            const map = readMap(root);
+            if (!map) {
+                return {
+                    status: 'unavailable',
+                    staleness,
+                    map: 'absent',
+                    hint: 'run `agent-config code-graph map` to draw it into agents/map/',
+                };
+            }
+            const m = map.model;
+            return {
+                status: 'ok',
+                staleness,
+                map: 'present',
+                drawn_at_commit: map.meta.commit,
+                graph_state_when_drawn: map.meta.state,
+                files: m.files.length,
+                areas: m.areas.length,
+                trusted_links: m.analyses.trustedEdges,
+                guess_share: m.analyses.guessShare,
+                request_paths: m.analyses.requestPathsTotal,
+                largest_areas: m.areas.slice(0, 5).map((a) => `${a.id} ${a.name} (${a.files.length})`),
+                map_md: 'agents/map/MAP.md',
+                index_html: 'agents/map/index.html',
+            };
+        },
+    },
+    graph_area: {
+        name: 'graph_area',
+        side_effect: 'ro',
+        description: 'One code-map area by id, exact name or member file: files, hubs, dependencies. Else refused.',
+        input_schema: {
+            type: 'object',
+            required: ['area'],
+            properties: {
+                area: { type: 'string' },
+            },
+            additionalProperties: false,
+        },
+        handler: async (args, root) => {
+            const q = str(args, 'area');
+            if (q === '') return { status: 'error', error: 'area must be a non-empty string' };
+            const map = readMap(root);
+            if (!map) return { status: 'unavailable', error: 'no map — run `agent-config code-graph map`' };
+            const r = areaReport(map.model, q);
+            if ('refusal' in r) return { status: 'refused', refusal: r.refusal, candidates: r.candidates };
+            return { status: 'ok', drawn_at_commit: map.meta.commit, ...r };
+        },
+    },
 };

package/src/scripts/mcp_server/tools.ts

@@ -1298,15 +1298,11 @@ export const ALLOWLIST: Record<string, BuiltinTool> = {
         name: 'chat_history_read',
         side_effect: 'ro',
         description:
-            "Read recent entries back from the consumer project's " +
-            'chat-history JSONL ' +
-            '(`agents/runtime/.agent-chat-history`; ' +
-            '`agents/.agent-chat-history` accepted for back-compat). Use ' +
-            'to recover context from an earlier session — decisions, ' +
-            'notes, phase markers — at the start of a new task. ' +
-            'Read-only. Returns the resolved file path plus a list of ' +
-            'matching entries (newest last). Combine `session`, `last`, ' +
-            'and `entry_type` to narrow the result.',
+            'Read recent entries from the chat-history JSONL ' +
+            '(`agents/runtime/.agent-chat-history`; legacy ' +
+            '`agents/.agent-chat-history` accepted) to recover decisions, ' +
+            'notes and phase markers from an earlier session. Returns the ' +
+            'resolved path and matching entries, newest last.',
         input_schema: {
             type: 'object',
             properties: {
@@ -1328,9 +1324,7 @@ export const ALLOWLIST: Record<string, BuiltinTool> = {
                 path: {
                     type: 'string',
                     description:
-                        'Optional history-file path override; defaults to ' +
-                        'the standard chat-history location under the ' +
-                        'project root.',
+                        'History-file override; default is the standard location.',
                 },
                 around: {
                     type: 'integer',
@@ -1359,12 +1353,9 @@ export const ALLOWLIST: Record<string, BuiltinTool> = {
                     enum: ['index', 'full'],
                     default: 'full',
                     description:
-                        "'index' returns compact rows (ref, t tag, ~100-char " +
-                        'preview, tokens_estimate) instead of full entries — ' +
-                        'scan first, then re-read the refs you need via ' +
-                        '`around` or a narrowed filter. History entries are ' +
-                        "large, so index mode pays off here. 'full' " +
-                        '(default) returns complete entries.',
+                        "'index' returns compact rows (ref, t tag, preview, " +
+                        'tokens_estimate) — scan, then re-read refs via ' +
+                        "`around` or a filter. 'full' (default) returns whole entries.",
                 },
             },
             additionalProperties: false,
@@ -1375,18 +1366,13 @@ export const ALLOWLIST: Record<string, BuiltinTool> = {
         name: 'memory_lookup',
         side_effect: 'ro',
         description:
-            'Retrieve engineering-memory entries for one or more memory ' +
-            'types, optionally narrowed to specific anchor paths. Use ' +
-            'before editing a security-sensitive or historically buggy ' +
-            'file to surface prior incidents, ownership, and patterns ' +
-            'tied to it. WORKFLOW: call with detail:"index" FIRST — each ' +
-            'row carries id, title and tokens_estimate (the cost of ' +
-            'fetching it) — then fetch full bodies via memory_get ONLY ' +
-            'for the ids you will actually use, batching multiple ids ' +
-            'into one call. Reads `agents/memory/<type>/*.yml` plus the ' +
-            '`agents/memory/intake/*.jsonl` signal log. Read-only. ' +
-            'Returns the v1 retrieval envelope: a `status` field plus ' +
-            'per-type `slices` carrying the matched entries.',
+            'Engineering-memory entries for one or more types, optionally ' +
+            'narrowed to anchor paths — use before editing a ' +
+            'security-sensitive or historically buggy file. Call with ' +
+            'detail:"index" FIRST (rows carry id, title, tokens_estimate), ' +
+            'then memory_get only the ids you will use, batched. Reads ' +
+            '`agents/memory/<type>/*.yml` and `agents/memory/intake/*.jsonl`. ' +
+            'Returns a `status` plus per-type `slices`.',
         input_schema: {
             type: 'object',
             properties: {
@@ -1426,12 +1412,9 @@ export const ALLOWLIST: Record<string, BuiltinTool> = {
                     type: 'integer',
                     minimum: 1,
                     description:
-                        'Optional token budget. When set, entries are ' +
-                        'rendered as one-line compact rows (id, type, ' +
-                        'confidence, `line`) and the row set is hard-cut at ' +
-                        'token_budget × 4 chars; omitted hits appear as a ' +
-                        'top-level `truncation` hint naming a concrete next ' +
-                        'step. Absent → the envelope is unchanged.',
+                        'Optional: render compact rows (id, type, confidence, ' +
+                        '`line`) hard-cut at token_budget × 4 chars; omitted ' +
+                        'hits yield a top-level `truncation` hint.',
                 },
             },
             required: ['types'],

package/src/scripts/release.ts

@@ -36,8 +36,9 @@
  *                            the PR's own consistency check fails — PR #226).
  *     5. Commit + push     — `release: X.Y.Z`, push branch, open PR.
  *     6. Wait for CI       — `gh pr checks --watch` (skippable with --no-wait).
- *     7. Findings ledger   — VERIFY it is on the branch and dispositioned, and
- *                            STOP otherwise; `self-review-gate.yml` builds it.
+ *     7. No review gate    — a release waits for no review ledger: every commit
+ *                            on main is already reviewed and merged (owner,
+ *                            2026-10-22). The self-review stays advisory.
  *     8. Merge             — `gh pr merge --merge --delete-branch`.
  *     9. Tag main          — fast-forward main, tag the merge commit, push the
  *                            tag (triggers publish-npm.yml, except under --ci).
@@ -128,7 +129,6 @@ import { canPrompt, promptLine } from './_lib/tty_prompt.js';
 import type { CommitRecord, ImpactTrailers } from './_lib/consumer_impact.js';
 import { COMMIT_LOG_FORMAT, NO_IMPACT_TRAILERS, is_breaking_commit, parse_commit_log, parse_impact_trailers, write_impact_map } from './_lib/consumer_impact.js';
 import { preflightPosition } from './_lib/release_position.js';
-import { settleFindingsLedger } from './_lib/release_findings_ingest.js';
 import { TAG_TRIGGERED_WORKFLOWS, dispatchTagWorkflows } from './_lib/release_tag_dispatch.js';
 import {
     RELEASE_HEAD_DEFAULT,
@@ -1041,12 +1041,8 @@ function execute(
         _step(6, total, 'Skip waiting for checks (--no-wait)');
     }
 
-    // Step 7 — the findings ledger: verify, never produce; the module says why.
-    settleFindingsLedger({
-        run, die, repoRoot: REPO_ROOT, remote: REMOTE, trunk: MAIN_BRANCH,
-        step: (m) => { _step(7, total, m); }, write: (s) => process.stdout.write(s),
-        resolvePr: () => Number((pr_info ?? _pr_for_branch(branch))?.['number'] ?? NaN) || null,
-    }, plan.target, branch, pr_merged);
+    // Step 7 — kept as a numbered line so the step anchors stay stable.
+    _step(7, total, 'No review gate — main is already reviewed and merged');
     // Step 8 — merge
     if (pr_merged) {
         _step(8, total, `PR #${pr_info!['number']} already merged — skip`);