@event4u/agent-config 17.0.0 → 17.1.0

package/src/scripts/hooks/dispatch_hook.ts

@@ -55,7 +55,7 @@ import {
 import { emitFor, type PermissionDecision, type Severity } from "./host_semantics.js";
 import { _concern_permission_verdict, _payload_tool_name, _permission_for } from "./permission_gate.js";
 export { _concern_permission_verdict, _payload_tool_input, _payload_tool_name, _permission_for, _working_tree_root } from "./permission_gate.js";
-import { _concern_body_classes, planPayloadShapes } from "./payload_stub.js";
+import { _concern_body_classes, applyPayloadFields, planPayloadShapes } from "./payload_stub.js";
 import { attributeRefusal, egressInjection, egressViewFor, runEgressStage } from "./egress_stage.js";
 import { resolveSessionRole, type SessionRole } from "../_lib/session_role.js";
 import { stdinReadFailure, denyOnStdinFailure } from './stdin_failure_policy.js';
@@ -1299,7 +1299,7 @@ export function main(argv?: string[]): number {
     if (!_concern_matches_tool(concern, tool_name)) {
       continue;
     }
-    const concern_envelope = shapes.shapeFor(keep_classes, egressViewFor(concern));
+    const concern_envelope = applyPayloadFields(concern, shapes.shapeFor(keep_classes, egressViewFor(concern)));
     const stubs_served = shapes.stubsFor(keep_classes);
     // What was actually SERVED, not what was declared. Recording the
     // declaration made the record wrong in both directions on a body-less

package/src/scripts/hooks/payload_stub.ts

@@ -387,6 +387,33 @@ export function _concern_body_classes(concern: JsonObject): Set<BodyClass> {
   return parseBodyClasses(concern["needs_payload_bodies"]);
 }
 
+/**
+ * Field-level projection: a concern declaring `payload_fields: [k, …]` gets
+ * each tool body reduced to those top-level keys, and a body that is not an
+ * object as a stub. It reads only what it was handed, so its privacy does not
+ * rest on what it chooses to keep. The same guard floor as the body classes:
+ * a blocking or fail-closed concern is never narrowed.
+ */
+export function applyPayloadFields(concern: JsonObject, env: JsonObject): JsonObject {
+  const fields = concern["payload_fields"];
+  const payload = env["payload"];
+  if (!Array.isArray(fields) || !isObject(payload) || concern["fail_closed"] === true || concern["severity"] === "blocking") {
+    return env;
+  }
+  const keep = new Set(fields);
+  const out: JsonObject = { ...payload };
+  for (const cls of BODY_CLASSES) {
+    for (const key of BODY_KEYS[cls]) {
+      const v = payload[key];
+      if (v === undefined || v === null || isPayloadStub(v)) continue;
+      out[key] = isObject(v)
+        ? Object.fromEntries(Object.entries(v).filter(([k]) => keep.has(k)))
+        : makePayloadStub(key, cls, v, new Map([[key, bodyBytes(v)]]));
+    }
+  }
+  return { ...env, payload: out };
+}
+
 /** The per-dispatch shaping plan. Built once, read per concern. */
 export interface PayloadShapePlan {
   /**

package/src/scripts/hooks/spawn_guard_shadow_hook.ts

@@ -61,12 +61,15 @@ import { probeHostCapabilities } from '../_lib/host_capability.js';
 import { recentHostMarker } from '../_lib/quota_parked.js';
 import { shadowReuseVerdict, type ReuseContext, type WorkerState } from '../_lib/worker_reuse.js';
 import {
-    LEDGER_DIR,
     appendLedgerLine,
     openRecordStats,
+    readIndexEntry,
     readOpenRecords,
     refFor,
     resolveConsumerRoot,
+    stateStamp,
+    stopIndexKey,
+    writeIndexEntry,
 } from './subagent_ledger_hook.js';
 import { readHookStdin } from './hook_stdin.js';
 import { EXIT_ALLOW } from './exit_codes.js';
@@ -104,49 +107,6 @@ export const RESUME_TOOL_NAMES: ReadonlySet<string> = new Set(['SendMessage']);
  */
 export type SendKind = 'resume' | 'message_running' | 'message_or_resume';
 
-/** Bytes read from the end of each monthly ledger file when looking for a stop. */
-export const STOP_SCAN_BYTES = 1024 * 1024;
-
-function tailOf(file: string): string {
-    let fd: number;
-    try {
-        fd = fs.openSync(file, 'r');
-    } catch {
-        return '';
-    }
-    try {
-        const size = fs.fstatSync(fd).size;
-        const length = Math.min(size, STOP_SCAN_BYTES);
-        const buf = Buffer.alloc(length);
-        fs.readSync(fd, buf, 0, length, size - length);
-        return buf.toString('utf8');
-    } finally {
-        fs.closeSync(fd);
-    }
-}
-
-function stoppedInSession(root: string, ref: string, sessionId: string, now: Date): boolean {
-    const prev = new Date(Date.UTC(now.getUTCFullYear(), now.getUTCMonth() - 1, 1));
-    for (const month of [now.toISOString().slice(0, 7), prev.toISOString().slice(0, 7)]) {
-        for (const line of tailOf(path.join(root, LEDGER_DIR, `${month}.jsonl`)).split('\n')) {
-            if (!line.includes(ref)) continue;
-            try {
-                const rec = JSON.parse(line) as Record<string, unknown>;
-                if (rec['event'] === 'subagent_stop' && rec['ref'] === ref && rec['session_id'] === sessionId) {
-                    return true;
-                }
-            } catch {
-                // The first line of a tail is usually cut; a torn line is no evidence.
-            }
-        }
-    }
-    return false;
-}
-
-/**
- * The ref a named spawn of this session left in the register, read from the
- * same bounded tails as a stop; null when this session named no such worker.
- */
 /** Longer names are neither recorded nor resolved: a name is an address, not a payload. */
 export const NAME_MAX = 128;
 
@@ -155,27 +115,6 @@ function nameKey(sessionId: string, name: string): string {
     return refFor(`subagent-name\0${sessionId}\0${name}`);
 }
 
-function refForName(root: string, name: string, sessionId: string, now: Date): string | null {
-    if (name.length > NAME_MAX) return null;
-    const key = nameKey(sessionId, name);
-    let found: string | null = null;
-    const prev = new Date(Date.UTC(now.getUTCFullYear(), now.getUTCMonth() - 1, 1));
-    for (const month of [prev.toISOString().slice(0, 7), now.toISOString().slice(0, 7)]) {
-        for (const line of tailOf(path.join(root, LEDGER_DIR, `${month}.jsonl`)).split('\n')) {
-            if (!line.includes('subagent_named')) continue;
-            try {
-                const rec = JSON.parse(line) as Record<string, unknown>;
-                if (rec['event'] === 'subagent_named' && rec['name_key'] === key && typeof rec['ref'] === 'string') {
-                    found = rec['ref'];
-                }
-            } catch {
-                // A torn line is no evidence.
-            }
-        }
-    }
-    return found;
-}
-
 /**
  * Classify one send. `recipient_kind: name` is resolved through the register a
  * named spawn of this session left; any other recipient is taken as an agent id
@@ -192,10 +131,15 @@ export function classifySend(
     const recipient = input['to'];
     if (typeof recipient !== 'string' || recipient === '') return 'message_or_resume';
     if (sessionId === null || sessionId === '') return 'message_or_resume';
-    const ref = input['recipient_kind'] === 'name' ? refForName(root, recipient, sessionId, now) : refFor(recipient);
-    if (ref === null) return 'message_or_resume';
+    const ref =
+        input['recipient_kind'] !== 'name'
+            ? refFor(recipient)
+            : recipient.length > NAME_MAX
+              ? null
+              : readIndexEntry(root, nameKey(sessionId, recipient), now);
+    if (!ref) return 'message_or_resume';
     if (readOpenRecords(root).has(ref)) return 'message_running';
-    return stoppedInSession(root, ref, sessionId, now) ? 'resume' : 'message_or_resume';
+    return readIndexEntry(root, stopIndexKey(sessionId, ref), now) === null ? 'message_or_resume' : 'resume';
 }
 
 /**
@@ -208,8 +152,10 @@ export function recordNamedSpawn(root: string, payload: JsonObject, sessionId: s
     const name = input['name'];
     const agentId = result['agentId'];
     if (typeof name !== 'string' || name === '' || name.length > NAME_MAX || typeof agentId !== 'string' || agentId === '') return;
-    if (sessionId === null) return;
-    appendLedgerLine(root, nowIso, { event: 'subagent_named', ts: nowIso, ref: refFor(agentId), name_key: nameKey(sessionId, name), session_id: sessionId });
+    if (!sessionId) return;
+    const key = nameKey(sessionId, name);
+    appendLedgerLine(root, nowIso, { event: 'subagent_named', ts: nowIso, ref: refFor(agentId), name_key: key, session_id: sessionId });
+    writeIndexEntry(root, nowIso, key, refFor(agentId));
 }
 
 /**
@@ -318,6 +264,18 @@ export function processEnvelope(envelope: JsonValue, consumerRoot: string, deps:
         const sessionRaw = payload['session_id'] ?? envelope['session_id'];
         const sessionId = typeof sessionRaw === 'string' ? sessionRaw : null;
         const sendKind: SendKind | null = isResume ? classifySend(consumerRoot, toolInput, sessionId) : null;
+        // A spawn's definition and requested name (as its session digest), so a
+        // report can join the request to the named worker a reuse would address.
+        const reqName = toolInput['name'];
+        const spawnFacts = isResume
+            ? {}
+            : {
+                  ...stateStamp(payload['cwd']),
+                  agent_type: typeof toolInput['subagent_type'] === 'string' ? toolInput['subagent_type'] : null,
+                  ...(typeof reqName === 'string' && reqName && reqName.length <= NAME_MAX && sessionId
+                      ? { name_key: nameKey(sessionId, reqName) }
+                      : {}),
+              };
         // Only the verdict's label and reason codes reach disk — never the tool input.
         const reuse = isResume
             ? null
@@ -357,6 +315,7 @@ export function processEnvelope(envelope: JsonValue, consumerRoot: string, deps:
                 ? {}
                 : { candidates: verdicts.map((v) => ({ label: v.label, would_deny: v.would_deny, on: v.on })) }),
             dispatch_kind: sendKind ?? 'spawn',
+            ...spawnFacts,
             resume_admission: platform !== null && RESUME_ADMISSION_OBSERVED.has(platform) ? 'counted' : 'unobserved',
             ...(reuse === null ? {} : { reuse }),
             // A recent host-sourced rate marker: a new spawn would have waited.

package/src/scripts/hooks/subagent_ledger_hook.ts

@@ -107,6 +107,7 @@
  * undercount landed precisely in parallel fan-out, the mode this instrument
  * exists to measure.
  */
+import { execFileSync } from 'node:child_process';
 import * as crypto from 'node:crypto';
 import * as fs from 'node:fs';
 import * as path from 'node:path';
@@ -500,6 +501,78 @@ export function appendLedgerLine(root: string, ts: string, line: Record<string,
     fs.appendFileSync(file, `${JSON.stringify(line)}\n`, 'utf8');
 }
 
+/**
+ * The register's index: one file per key under `index/<YYYY-MM>/`, so a reader
+ * answers "did this session stop that leg" or "which ref does this name
+ * address" with one stat or read instead of scanning a ledger tail that heavy
+ * traffic can push the answer out of. Keys are digests only (`refFor` over a
+ * domain-separated string), so no session id, agent id or name is a file name.
+ */
+const INDEX_SUBDIR = 'index';
+
+export function writeIndexEntry(root: string, ts: string, key: string, value: string): void {
+    if (is_replay_mode()) return;
+    const dir = path.join(root, LEDGER_DIR, INDEX_SUBDIR, ts.slice(0, 7));
+    fs.mkdirSync(dir, { recursive: true });
+    const tmp = path.join(dir, `.${key}.${process.pid}.tmp`);
+    try {
+        fs.writeFileSync(tmp, value, 'utf8');
+        fs.renameSync(tmp, path.join(dir, key));
+    } finally {
+        fs.rmSync(tmp, { force: true });
+    }
+}
+
+/** The entry for `key` in this month or the previous one; null when neither holds it. */
+export function readIndexEntry(root: string, key: string, now: Date): string | null {
+    const prev = new Date(Date.UTC(now.getUTCFullYear(), now.getUTCMonth() - 1, 1));
+    for (const month of [now.toISOString().slice(0, 7), prev.toISOString().slice(0, 7)]) {
+        try {
+            return fs.readFileSync(path.join(root, LEDGER_DIR, INDEX_SUBDIR, month, key), 'utf8');
+        } catch {
+            // Not in this month.
+        }
+    }
+    return null;
+}
+
+/** The commit the checkout containing `dir` is on; null outside a repository or on any failure. */
+export function headOf(dir: string): string | null {
+    try {
+        // An inherited GIT_DIR / GIT_WORK_TREE would override `-C`.
+        const env = Object.fromEntries(Object.entries(process.env).filter(([k]) => !k.startsWith('GIT_')));
+        return execFileSync('git', ['-C', dir, 'rev-parse', 'HEAD'], { encoding: 'utf8', timeout: 2000, stdio: ['ignore', 'pipe', 'ignore'], env }).trim() || null;
+    } catch {
+        return null;
+    }
+}
+
+/**
+ * What a reuse decision compares between a worker's stop and a later spawn,
+ * stamped at both so a report can reconstruct it after the fact: the commit,
+ * a digest of the directory, and the install epoch (the running bundle's
+ * mtime, which changes whenever the package is rebuilt or reinstalled).
+ */
+export function stateStamp(cwd: unknown): { head: string | null; cwd_key: string | null; epoch: number | null } {
+    let epoch: number | null = null;
+    try {
+        epoch = fs.statSync(fileURLToPath(import.meta.url)).mtimeMs;
+    } catch {
+        // No file behind the module; the epoch stays unknown.
+    }
+    return typeof cwd === 'string' && cwd
+        ? { head: headOf(cwd), cwd_key: refFor(cwd), epoch }
+        : { head: null, cwd_key: null, epoch };
+}
+
+export function stopIndexKey(sessionId: string, ref: string): string {
+    return refFor(`subagent-stop\0${sessionId}\0${ref}`);
+}
+
+export function recordStopIndex(root: string, ts: string, sessionId: string, ref: string): void {
+    writeIndexEntry(root, ts, stopIndexKey(sessionId, ref), '');
+}
+
 /**
  * Candidate wall-clock stop-loss arms — Phase 3 Step 3, shadow only.
  *
@@ -750,7 +823,14 @@ function handleStop(root: string, payload: JsonObject, nowIso: string, sessionId
         // candidate was, this says whether it was aimed at the envelope.
         envelope_field_hits: parse.field_hits,
         concurrent_open: countOpen(root),
+        ...stateStamp(payload['cwd']),
     });
+    // After the line, and on its own: a failed index write must not cost the stop record.
+    try {
+        if (sessionId !== null) recordStopIndex(root, nowIso, sessionId, ref);
+    } catch {
+        // The guard then reads this stop as unplaced, the safe reading.
+    }
 }
 
 /** Process an ALREADY-PARSED dispatcher envelope. Always returns EXIT_ALLOW. */

package/src/scripts/install.ts

@@ -3010,14 +3010,14 @@ function _deploy_global_content(
                 info,
                 warn,
                 res,
-                preserved_now,
+                preserved_now, claude_rule_rewrite.onlyDeployed(anchor, current_files, (p) => _log_tx_entry('write', p)),
             );
             // Steps 1.1 and 1.4 of road-to-an-installed-layer-that-is-thinned;
             // both modules' headers carry the reasoning.
             deployClaudeCarrier({
                 packageRoot: package_root, rulesDir: path.join(anchor, 'rules'), quiet: state.QUIET, info, warn, userPin: state.FULL_PIN,
                 wantsThin: installerThinsHost(tool_id, { packageRoot: package_root }),
-                thin: (bodyLinkRoot) => describeThinInstalledLayer(thinInstalledRuleLayer({ rulesDir: path.join(anchor, 'rules'), packageRoot: package_root, preserved: preserved_now, bodyLinkRoot })),
+                thin: (bodyLinkRoot) => describeThinInstalledLayer(thinInstalledRuleLayer({ rulesDir: path.join(anchor, 'rules'), packageRoot: package_root, preserved: preserved_now, bodyLinkRoot, onWrite: claude_rule_rewrite.onlyDeployed(anchor, current_files, (p) => _log_tx_entry('write', p)) })),
             });
             if (!state.QUIET) for (const l of installReceiptBudgetLines(package_root, undefined, { thisDeploy: new Map([[anchor, current_files]]) })) info(l);
         }

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

@@ -276,6 +276,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/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`);