@event4u/agent-config 14.19.0 → 14.21.0

package/src/scripts/probe_unblocked_ask.ts

@@ -47,18 +47,40 @@
  * Both edges are printed. A reader who cannot see the bracket cannot judge the
  * number.
  *
+ * The `form` dimension (road-to-asked-not-parked 1.1)
+ *
+ * Every unblocked ask is additionally partitioned by the FORM the ask took:
+ *
+ *   - `native` — the same assistant turn carries a tool call whose name is a
+ *     structured-ask tool (`_lib/structured_ask.ts`, `isStructuredAskTool`).
+ *   - `text`   — everything else, i.e. the ask was prose.
+ *
+ * The two are exhaustive and disjoint by construction, so `text + native`
+ * always equals `unblockedAsks`. That identity is asserted in `--self-test`
+ * rather than left to a reader to check.
+ *
+ * Expect `native` to be **0** on every corpus this repo can scan today: no host
+ * in the capability registry carries an observed structured-ask tool, and
+ * `structured_ask.ts` states why matching on a name-shape pattern is not a claim
+ * that any host ships one. A measured zero and an uninstrumented zero look the
+ * same in a report and are not the same fact — this axis is what makes them
+ * distinguishable later.
+ *
  * Usage:
  *   ./scripts-run src/scripts/probe_unblocked_ask [--limit N] [--store PATH] [--json]
  *   ./scripts-run src/scripts/probe_unblocked_ask --self-test
+ *   ./scripts-run src/scripts/probe_unblocked_ask --help
  *
  * Exit codes: 0 always — a measurement, not a gate. `--self-test` exits 1 when
  * the detector fails to fire on its fixtures.
  */
 import fs from 'node:fs';
+import os from 'node:os';
 import path from 'node:path';
 import { pathToFileURL } from 'node:url';
 
 import { defaultStore, HARNESS_TEXT, isInjectedBody } from './conformance_scan.js';
+import { isStructuredAskTool } from './_lib/structured_ask.js';
 import { isSyntheticPrompt } from './_lib/prompt_shape.js';
 
 /** A numbered-options block — the surface `check_reply_consistency` already reads. */
@@ -88,6 +110,8 @@ interface Turn {
     role: 'user' | 'assistant';
     text: string;
     at: string;
+    /** Tool names invoked in this turn — empty for a user turn. */
+    tools: string[];
 }
 
 function turns(lines: string[]): Turn[] {
@@ -116,10 +140,16 @@ function turns(lines: string[]): Turn[] {
                         .map((b: { text?: string }) => b.text ?? '')
                         .join('\n')
                   : '';
+        const tools = Array.isArray(c)
+            ? c
+                  .filter((b: { type?: string }) => b?.type === 'tool_use')
+                  .map((b: { name?: string }) => String(b?.name ?? ''))
+                  .filter((n: string) => n !== '')
+            : [];
         if (!text.trim()) continue;
         if (role === 'assistant' && HARNESS_TEXT.test(text.trim())) continue;
         if (role === 'user' && (isSyntheticPrompt(text) || isInjectedBody(text))) continue;
-        out.push({ role, text, at: String(e['timestamp'] ?? '') });
+        out.push({ role, text, at: String(e['timestamp'] ?? ''), tools });
     }
     return out;
 }
@@ -139,16 +169,39 @@ export function classifyTail(tail: string): AskVerdict {
     return { unblockedAsk: true, malformed: !RECOMMENDATION.test(tail) };
 }
 
+/** The ask FORM partition. Exhaustive and disjoint: `text + native === unblockedAsks`. */
+export interface FormBreakdown {
+    text: number;
+    native: number;
+}
+
+/**
+ * Which FORM an ask took. `native` iff the turn carried a structured-ask tool
+ * call; `text` otherwise. Exported so the partition is one function rather than
+ * an inline condition a later edit can quietly make non-exhaustive.
+ */
+export function askForm(tools: readonly string[]): 'text' | 'native' {
+    return tools.some((n) => isStructuredAskTool(n)) ? 'native' : 'text';
+}
+
 export interface Result {
     handbacks: number;
     withBlock: number;
     unblockedAsks: number;
     malformed: number;
+    form: FormBreakdown;
     samples: { session: string; at: string; span: string }[];
 }
 
 export function measure(store: string, limit: number): Result {
-    const r: Result = { handbacks: 0, withBlock: 0, unblockedAsks: 0, malformed: 0, samples: [] };
+    const r: Result = {
+        handbacks: 0,
+        withBlock: 0,
+        unblockedAsks: 0,
+        malformed: 0,
+        form: { text: 0, native: 0 },
+        samples: [],
+    };
     let files: string[];
     try {
         files = fs.readdirSync(store).filter((f) => f.endsWith('.jsonl'));
@@ -179,6 +232,7 @@ export function measure(store: string, limit: number): Result {
             const v = classifyTail(tail);
             if (!v.unblockedAsk) continue;
             r.unblockedAsks += 1;
+            r.form[askForm(t.tools)] += 1;
             if (v.malformed) {
                 r.malformed += 1;
                 if (r.samples.length < 5) {
@@ -221,6 +275,52 @@ export function selfTest(): number {
         );
         if (!ok) failed += 1;
     }
+    for (const [tools, want] of [
+        [[], 'text'],
+        [['Bash', 'Read'], 'text'],
+        [['AskUserQuestion'], 'native'],
+        [['ask_user_question'], 'native'],
+    ] as Array<[string[], 'text' | 'native']>) {
+        const got = askForm(tools);
+        const ok = got === want;
+        process.stdout.write(
+            `${ok ? '✅' : '❌'}  form of [${tools.join(', ')}] — ${got}` +
+                (ok ? '\n' : ` (wanted ${want})\n`),
+        );
+        if (!ok) failed += 1;
+    }
+    const fx = fs.mkdtempSync(path.join(os.tmpdir(), 'probe-ask-form-'));
+    try {
+        const mk = (role: string, blocks: unknown): string =>
+            JSON.stringify({ type: role, timestamp: '2026-01-01T00:00:00Z', message: { role, content: blocks } });
+        fs.writeFileSync(
+            path.join(fx, 'fixture.jsonl'),
+            [
+                mk('assistant', [{ type: 'text', text: 'Done.\n\nSoll ich das so umsetzen?' }]),
+                mk('user', 'ja'),
+                mk('assistant', [
+                    { type: 'text', text: 'Done.\n\nShall I take the second half too?' },
+                    { type: 'tool_use', name: 'AskUserQuestion' },
+                ]),
+                mk('user', 'ja'),
+            ].join('\n'),
+            'utf8',
+        );
+        const r = measure(fx, 10);
+        const sums = r.form.text + r.form.native === r.unblockedAsks;
+        process.stdout.write(
+            `${sums ? '✅' : '❌'}  form partition is exhaustive — text ${String(r.form.text)} + ` +
+                `native ${String(r.form.native)} = unblocked ${String(r.unblockedAsks)}\n`,
+        );
+        if (!sums) failed += 1;
+        const split = r.form.text === 1 && r.form.native === 1;
+        process.stdout.write(
+            `${split ? '✅' : '❌'}  the fixture's two asks split one per class\n`,
+        );
+        if (!split) failed += 1;
+    } finally {
+        fs.rmSync(fx, { recursive: true, force: true });
+    }
     const positives = cases.filter((c) => c[3]).length;
     if (positives < 3) {
         process.stderr.write('❌  probe_unblocked_ask --self-test: fewer than 3 positive cases — a truncated suite must fail.\n');
@@ -233,6 +333,32 @@ export function selfTest(): number {
     return failed > 0 ? 1 : 0;
 }
 
+const HELP = `probe_unblocked_ask — the unblocked-ask rate, and the FORM each ask took.
+
+Usage:
+  probe_unblocked_ask [--limit N] [--store PATH] [--json]
+  probe_unblocked_ask --self-test
+  probe_unblocked_ask --help
+
+Dimensions reported:
+  hand-back turns    assistant turns immediately followed by a user turn
+  unblocked asks     …that hand a decision with no numbered-options block
+  malformed          …of those, carrying no Recommendation:/Empfehlung: label
+  form               the ask FORM partition of the unblocked asks:
+                       native  the turn carried a structured-ask tool call
+                       text    the ask was prose
+                     text + native always equals the unblocked-ask total.
+                     native is 0 wherever no host has an observed structured-ask
+                     tool — a measured zero, not an uninstrumented one.
+
+Options:
+  --limit N     most recent N sessions (default 60)
+  --store PATH  transcript store (default: the host's own)
+  --json        emit the Result object instead of the report
+  --self-test   run the detector fixtures, incl. the form-partition identity
+  --help        this text
+`;
+
 export function main(argv: string[]): number {
     let limit = 60;
     let storeArg: string | null = null;
@@ -246,6 +372,10 @@ export function main(argv: string[]): number {
         // in-process, and resolving a transcript store that may not exist here
         // would make the sensitivity proof depend on the host having one.
         else if (a === '--self-test') return selfTest();
+        else if (a === '--help' || a === '-h') {
+            process.stdout.write(HELP);
+            return 0;
+        }
         else {
             process.stderr.write(`probe_unblocked_ask: unrecognized argument: ${a}\n`);
             return 0;
@@ -264,6 +394,9 @@ export function main(argv: string[]): number {
             `  …with a numbered block   ${String(r.withBlock)}  (excluded — check_reply_consistency reads that surface)\n` +
             `  …unblocked asks          ${String(r.unblockedAsks)}  ${pct(r.unblockedAsks, r.handbacks)} of hand-backs\n` +
             `  …of those, malformed     ${String(r.malformed)}  ${pct(r.malformed, r.unblockedAsks)} of unblocked asks\n` +
+            `  form: text               ${String(r.form.text)}  ${pct(r.form.text, r.unblockedAsks)} of unblocked asks\n` +
+            `  form: native             ${String(r.form.native)}  ${pct(r.form.native, r.unblockedAsks)} of unblocked asks\n` +
+            `  form: text + native      ${String(r.form.text + r.form.native)}  (must equal unblocked asks: ${String(r.unblockedAsks)})\n` +
             '\n  CEILING, not a point estimate: "hands a decision" is a heuristic and a\n' +
             '  rhetorical question can match it. A recommendation is matched on its LABEL,\n' +
             '  which is the rule\'s own bar but a bar on form.\n',

package/src/scripts/release.ts

@@ -49,8 +49,10 @@
  * Idempotency: pass `--resume` to recover from a partial failure. Each
  * step then probes existing state (branch, commit, PR, tag, GitHub
  * Release) and skips work that is already done, instead of erroring out.
- * Without `--resume` the pipeline still mutates git/network state, so
- * re-running on a dirty tree needs `--resume` (or a manual cleanup). The
+ * Re-running from `release/{target}` needs neither the flag nor a clean
+ * tree — that position, dirty, is the state `guard_release_curation` leaves
+ * behind, and `preflightPosition` accepts it (a dirty `main` still refuses).
+ * The
  * two entry points guard against colliding with each other via these same
  * probes plus the CI workflow's concurrency group — whichever starts
  * second sees the other's in-progress state and skips or refuses cleanly.
@@ -124,6 +126,8 @@ import {
     derive_category_hits,
     render_derived_head_values,
 } from './_lib/release_highlights.js';
+import { canPrompt, promptLine } from './_lib/tty_prompt.js';
+import { preflightPosition } from './_lib/release_position.js';
 import {
     RELEASE_HEAD_DEFAULT,
     extract_changelog_section,
@@ -551,8 +555,8 @@ function render_changelog_entry(
 
     // The curated head sits above the generated log, which stays unchanged.
     const body_lines: string[] = [...render_release_head(opts.head ?? {})];
-    // Under the head and outside it — rationale on `MIX_RESPONSE_PLACEHOLDER`.
-    if (opts.mix?.triggered) {
+    // Under the head, outside it; any resolved reading — see `MixObligation`.
+    if (opts.mix) {
         body_lines.push('');
         body_lines.push(...render_mix_response(opts.mix.level));
     }
@@ -784,17 +788,17 @@ export function assert_scheduled_deprecations_clear(
 /**
  * Fail fast on conditions that would break the release mid-flight.
  *
- * In `--resume` mode two invariants are relaxed:
+ * The start position — which branch, and whether a dirty tree is tolerated —
+ * is `preflightPosition` in `_lib/release_position.ts`, and it is NO LONGER
+ * gated on `--resume`:
+ * `release/{target}` is where `guard_release_curation` leaves the operator, so
+ * refusing it there made the guard's own remedy unreachable. Read that
+ * function's header for the measurement.
  *
- * - The starting branch may be `release/{target}` in addition to `main` —
- *   both are valid resume positions (mid-pipeline crash after step 1 leaves
- *   you on the release branch).
- * - The target-tag-exists check is dropped — execute() probes for existing
- *   tags/releases and skips them.
+ * `--resume` still relaxes ONE invariant here: the target-tag-exists check is
+ * dropped, because execute() probes for existing tags/releases and skips them.
  *
- * Tree cleanliness, gh auth, and `main` in-sync with origin are still
- * enforced, so resuming has the same starting posture as a fresh run; only
- * step-level outcomes differ.
+ * gh auth and `main` in-sync with origin are enforced either way.
  *
  * `opts.ci` swaps the gh-auth probe (see below) for the CI-mode variant —
  * everything else is identical between the two entry points.
@@ -832,20 +836,17 @@ function preflight(target: string, opts: { resume?: boolean; ci?: boolean } = {}
 
     const branch = git(['rev-parse', '--abbrev-ref', 'HEAD'], { capture: true });
     const release_branch = `release/${target}`;
-    const allowed = resume ? new Set([MAIN_BRANCH, release_branch]) : new Set([MAIN_BRANCH]);
-    if (!allowed.has(branch)) {
-        if (resume) {
-            die(
-                `resume must run from '${MAIN_BRANCH}' or '${release_branch}', ` +
-                    `currently on '${branch}'`,
-            );
-        }
-        die(`release must run from '${MAIN_BRANCH}', currently on '${branch}'`);
+    const position = preflightPosition({
+        branch,
+        mainBranch: MAIN_BRANCH,
+        releaseBranch: release_branch,
+        porcelain: git(['status', '--porcelain'], { capture: true }),
+    });
+    if (!position.proceed) {
+        die(position.message ?? `release cannot start from '${branch}'`);
     }
-
-    const porcelain = git(['status', '--porcelain'], { capture: true });
-    if (porcelain) {
-        die('working tree is not clean; commit or stash first');
+    if (position.notice) {
+        process.stdout.write(`\u26a0\ufe0f  ${position.notice}\n`);
     }
 
     // --force lets the remote's tag positions win over stale local tags.
@@ -933,74 +934,12 @@ function print_preview(plan: Plan): void {
 }
 
 function confirm(prompt: string): boolean | null {
-    const ans = _input(`${prompt} [y/N] `);
+    const ans = promptLine(`${prompt} [y/N] `);
     if (ans === null) return null; // no usable controlling terminal
     const norm = ans.trim().toLowerCase();
     return norm === 'y' || norm === 'yes';
 }
 
-/** Can we prompt at all — is fd 0 a TTY, or is a controlling terminal openable? */
-function _canPrompt(): boolean {
-    if (process.env.CI) return false; // CI is non-interactive by contract → require --yes
-    if (process.stdin.isTTY) return true;
-    try {
-        const fd = fs.openSync('/dev/tty', 'r');
-        fs.closeSync(fd);
-        return true;
-    } catch {
-        return false;
-    }
-}
-
-/**
- * Mirror of Python `input(prompt)` — write the prompt, read one line from the
- * controlling terminal. Returns `null` when no terminal is reachable.
- *
- * The answer is ALWAYS read from a freshly opened, blocking `/dev/tty`
- * (`openSync(..., 'rs')`), NEVER from fd 0. `task release` / `./scripts-run`
- * run this under go-task's `interactive: true`, which leaves fd 0 a TTY
- * (`process.stdin.isTTY === true`) but one Node treats as NON-blocking — so a
- * bare `readSync(0)` throws `EAGAIN`, the catch swallows it, and the `[y/N]`
- * prompt "auto-aborts" without ever waiting (the exact failure this fixes;
- * reproduced with `isTTY === true`). A fresh blocking `/dev/tty` descriptor
- * blocks for real input regardless of how the script was invoked — the proven
- * synchronous-prompt pattern.
- */
-function _input(prompt: string): string | null {
-    process.stdout.write(prompt);
-    let fd: number;
-    try {
-        // 'rs' → O_RDONLY | O_SYNC: a fresh, blocking descriptor on the
-        // controlling terminal, unaffected by Node's non-blocking fd 0.
-        fd = fs.openSync('/dev/tty', 'rs');
-    } catch {
-        return null; // no controlling terminal (true non-interactive)
-    }
-    try {
-        const buf = Buffer.alloc(1);
-        const chars: number[] = [];
-        for (;;) {
-            let bytesRead: number;
-            try {
-                bytesRead = fs.readSync(fd, buf, 0, 1, null);
-            } catch (e) {
-                const code = (e as NodeJS.ErrnoException).code;
-                // A blocking /dev/tty should not yield these, but inherited
-                // descriptor flags can — retry rather than abort the prompt.
-                if (code === 'EAGAIN' || code === 'EINTR') continue;
-                break; // EOF / EIO → EOFError analogue; return what we have.
-            }
-            if (bytesRead === 0) break;
-            const b = buf[0] as number;
-            if (b === 0x0a) break; // newline terminates the line (stripped, like input()).
-            chars.push(b);
-        }
-        return Buffer.from(chars).toString('utf-8');
-    } finally {
-        fs.closeSync(fd);
-    }
-}
-
 export interface ConfirmVerdict {
     proceed: boolean;
     /** Message to surface when not proceeding (no trailing newline). */
@@ -1024,7 +963,7 @@ export function confirmGate(target: string, yes: boolean): ConfirmVerdict {
             'No terminal available for the [y/N] confirmation (non-interactive shell). ' +
             'Re-run with --yes to confirm, e.g. `task release -- --yes`.',
     };
-    if (!_canPrompt()) return noTerminal;
+    if (!canPrompt()) return noTerminal;
     const answer = confirm(`Proceed with release ${target}?`);
     // null = the controlling terminal vanished between the probe and the read;
     // surface the actionable --yes guidance, never a bare silent "aborted.".
@@ -1684,17 +1623,33 @@ function main(argv: readonly string[] | null = null): number {
 
     const bump = resolve_bump(args.bump_override, commits);
 
-    // Resume mode: prefer an existing `release/X.Y.Z` over computed bump,
-    // so we don't accidentally start a 1.16.0 release while 1.15.0 is
-    // still in flight. Explicit --version still wins.
-    const in_flight = args.resume ? _detect_in_flight_target() : null;
+    // An in-flight release is a STATE, never a flag — so the probe runs
+    // unconditionally and `--resume` no longer decides what is being released.
+    //
+    // The comment this replaces already stated the right intent ("so we don't
+    // accidentally start a 1.16.0 release while 1.15.0 is still in flight") and
+    // the `args.resume ?` gate narrowed it to resumed runs only. Measured on
+    // 14.20.0: `guard_release_curation` refuses after step 2 has bumped
+    // `package.json`, so a plain re-run computed the bump from the ALREADY
+    // BUMPED version, landed on 14.21.0, and then refused its own branch with
+    // `release must run from 'main' or 'release/14.21.0', currently on
+    // 'release/14.20.0'`. The 2026-09-07 start-position fix could not help: it
+    // was asked about the wrong target.
+    //
+    // Neither branch of `_detect_in_flight_target` needs the flag — HEAD
+    // sitting on `release/X.Y.Z`, and a `package.json` version whose tag is not
+    // PUBLISHED, are both facts about the repository. On a clean `main` after a
+    // completed release the second branch returns null (the tag is published),
+    // so a fresh release is unaffected; what changes is that an abandoned bump
+    // can no longer be silently released as the NEXT version.
+    const in_flight = _detect_in_flight_target();
     let target: string;
     if (args.explicit) {
         target = args.explicit;
     } else if (in_flight) {
         target = in_flight;
         process.stdout.write(
-            `(resume) in-flight target ${in_flight} (package.json version with no tag yet)\n`,
+            `in-flight target ${in_flight} (package.json version with no published tag yet)\n`,
         );
     } else {
         target = bump_version(current, bump);

package/src/scripts/release_drill.ts

@@ -244,17 +244,13 @@ export function defaultChangelogFixture(target: string): string {
         '',
         '- fixture entry for the release drill',
         '',
-        // Both lines are section-level publication obligations
-        // (`section_publication_blockers`), so a fixture without them refuses
-        // at the curation guard and every sequencing scenario dies at step 2 —
-        // the same "fixture trips the guard the drill exists to sequence"
-        // failure this builder's docstring already warns about, for the two
-        // obligations added 2026-09-05. The mix answer is written OUT rather
-        // than measured: measuring would couple every scenario to the live
-        // repository's commit span, which is the coupling `changelog` was
-        // introduced to remove.
+        // The mix line is written OUT rather than measured: measuring would
+        // couple every scenario to the live repository's commit span, which is
+        // the coupling `changelog` was introduced to remove. It is no longer a
+        // publication obligation (ADR-261 deleted the written answer it used to
+        // carry) — it stays because the drill exercises the shape the writer
+        // actually renders.
         '> **Governance mix:** governance-only 2 vs consumer-only 1 (taxonomy 1.0.0).',
-        '> Next cycle ships the fixture consumer work, tracked in the drill.',
         '',
         'Tests: 1000 (+0 since 0.0.0)',
         '',

package/src/scripts/release_env.ts

@@ -124,6 +124,7 @@ function _set_changelog_reader(fn: ((file: string) => string) | null): void {
 function read_changelog_text(): string {
     return _changelog_reader ? _changelog_reader(CHANGELOG) : fs.readFileSync(CHANGELOG, 'utf-8');
 }
+
 const MAIN_BRANCH = 'main';
 const REMOTE = 'origin';
 const REPO_SLUG = 'event4u-app/agent-config';

package/src/scripts/release_publication.ts

@@ -458,15 +458,14 @@ export function local_release_gate_argv(): string[] {
 /**
  * Measure the governance-versus-product level for the span under release.
  *
- * The push guard's fourth site reads the SAME obligation the release PR reads,
- * which until 2026-09-05 it did not: `publication_blockers` knew two sentinels
- * and not this one, so the earliest refusal was the pull request. That gap was
- * documented in `docs/contracts/CHANGELOG-conventions.md` and it is what turned
- * 14.17.0 red after a branch, a PR and a CI run had already been spent.
+ * REPORTING ONLY since ADR-261. It feeds exactly one consumer: the `>
+ * **Governance mix:** …` line the writer renders into the section. No guard
+ * reads it, nothing refuses over it, and `triggered` gates nothing — the
+ * written-answer obligation it used to serve is deleted.
  *
  * Returns `null` on any measurement failure — a shallow clone or a missing tag
- * is an environment fact, and the contract is explicit that it degrades to a
- * warning rather than to a refusal. `null` produces no blocker downstream.
+ * is an environment fact, and a release must not stop over one. `null` means
+ * the line is simply not rendered.
  */
 export function measure_mix_obligation(
     version: string,
@@ -478,19 +477,18 @@ export function measure_mix_obligation(
         const reading = measureRange(from, 'HEAD', loadTaxonomy(), version, REPO_ROOT);
         const o = reading.response_obligation;
         return {
-            triggered: o.triggered,
             level:
                 `governance-only ${String(o.governance_only)} vs consumer-only ` +
                 `${String(o.consumer_only)} (taxonomy ${reading.taxonomy_version})`,
         };
     } catch (err) {
-        // The CI side prints `⚠️  governance mix not measured`; swallowing it
-        // here made a broken taxonomy file disable BOTH local guards in
-        // silence while CI kept refusing — the exact asymmetry this change
-        // exists to remove, restored one layer down.
+        // Printed rather than swallowed. Nothing refuses over the reading any
+        // more (ADR-261), so this is not a blocked release — it is a section
+        // that will publish without its `> **Governance mix:** …` line, and the
+        // operator is entitled to know why the line is missing.
         process.stderr.write(
             `⚠️   governance mix not measured for ${version}: ${(err as Error).message}\n` +
-                '    Both local guards are inert for this obligation; the release PR still refuses.\n',
+                '    The section will publish without the measured line. Nothing is blocked.\n',
         );
         return null;
     }
@@ -539,12 +537,7 @@ export function guard_release_branch_push(branch: string): void {
     if (!section) {
         return;
     }
-    const blockers = section_publication_blockers(
-        section.body,
-        version,
-        `\`${branch}\``,
-        measure_mix_obligation(version),
-    );
+    const blockers = section_publication_blockers(section.body, version, `\`${branch}\``);
     if (blockers.length === 0) {
         return;
     }
@@ -685,6 +678,13 @@ export function integrate_main_if_behind(branch: string, say: (msg: string) => v
     run(['git', 'merge', `${REMOTE}/${MAIN_BRANCH}`, '--no-edit']);
 }
 
+/** Everything this site refuses over: the head-level blockers, nothing else. */
+function curation_blockers(version: string): string[] {
+    const section = extract_changelog_section(read_changelog_text(), version);
+    if (section === null) return [];
+    return publication_blockers(section.body, version, `\`release/${version}\``);
+}
+
 export function guard_release_curation(version: string, prMerged = false): void {
     if (prMerged) {
         return;
@@ -693,8 +693,7 @@ export function guard_release_curation(version: string, prMerged = false): void
     if (!section) {
         return;
     }
-    // The head-level blockers plus the mix obligation — deliberately NOT the
-    // tests footer.
+    // The head-level blockers only — deliberately NOT the tests footer.
     //
     // This site runs BEFORE `prepend_changelog`'s output is committed, and
     // `--resume` skips the whole bump block once `package.json` already carries
@@ -707,17 +706,23 @@ export function guard_release_curation(version: string, prMerged = false): void
     //
     // `guard_release_branch_push` carries it instead: by then the section is
     // committed and editable on the branch, and nothing has left the machine.
-    const blockers = [
-        ...publication_blockers(
-            section.body,
-            version,
-            `\`release/${version}\``,
-            measure_mix_obligation(version),
-        ),
-    ];
+    //
+    // What is NOT here any more (ADR-261): the governance-versus-product
+    // written answer, the next-cycle promise, the read-back of the previous
+    // one, the `## [Unreleased]` staging channel that fed them and the
+    // interactive prompt that asked for them. This guard refuses the
+    // generator's own unrewritten draft — a claim no human has looked at — and
+    // nothing else. It never asks the operator to write prose about a future
+    // cycle to get a version out.
+    const blockers = curation_blockers(version);
     if (blockers.length === 0) {
         return;
     }
+    // Read once. This used to re-read the file here, because
+    // `consume_staged_answers` / `collect_curation_answers` could rewrite the
+    // section between the two reads; both write paths are gone (ADR-261) and
+    // `curation_blockers` is read-only, so a second read could only ever
+    // return the same bytes.
     const marked = section.body
         .split('\n')
         .filter((l) => l.includes(DERIVED_MARKER))
@@ -731,8 +736,12 @@ export function guard_release_curation(version: string, prMerged = false): void
                   marked.join('\n')
                 : '') +
             '\n    Stopped BEFORE committing — no release commit, no branch on ' +
-            `${REMOTE}, no pull request, no tag. Curate the ` +
-            '`### Release highlights` head, then re-run `task release`.',
+            `${REMOTE}, no pull request, no tag. HEAD is on the LOCAL ` +
+            `\`release/${version}\` branch and the generated section is in the working ` +
+            'tree: curate the `### Release highlights` head in `CHANGELOG.md` there, then ' +
+            're-run `task release`. That re-run works from this position — `preflightPosition` ' +
+            'accepts the release branch with the uncommitted step-2 output, which it did not ' +
+            'until 2026-09-07 (both spellings of the re-run were refused before step 1).',
     );
 }
 

package/src/scripts/self_repair_cli.ts

@@ -48,6 +48,7 @@ import {
     attachReleaseErrors,
     listRecords,
     markReleased,
+    writeTargetIndex,
     openRecords,
     readOverflow,
     readRecord,
@@ -503,6 +504,30 @@ function releaseCmd(root: string, argv: string[]): number {
     return EXIT_OK;
 }
 
+/**
+ * Rebuild the per-target occurrence index and print it.
+ *
+ * A DERIVED read: the record files are the source, the index is regenerable
+ * and gitignored with the rest of `agents/runtime/`. It exists because
+ * `occurrences` counts a fingerprint (class + normalised evidence shape), so a
+ * rule's weakness showing up in three different shapes was three records with
+ * one occurrence each — and the third-recurrence escalation had nothing that
+ * could ever establish its own precondition.
+ */
+function targetsCmd(root: string): number {
+    const counts = writeTargetIndex(root);
+    if (counts.length === 0) {
+        process.stdout.write('self-repair: no record carries a resolved target yet.\n');
+        return EXIT_OK;
+    }
+    for (const c of counts) {
+        process.stdout.write(
+            `  ${c.target}  ${c.occurrences} occurrence(s) across ${c.records.length} record(s)\n`,
+        );
+    }
+    return EXIT_OK;
+}
+
 export function main(argv: readonly string[]): number {
     const root = process.cwd();
     const sub = argv[0] ?? 'status';
@@ -512,7 +537,12 @@ export function main(argv: readonly string[]): number {
     if (sub === 'release') {
         return releaseCmd(root, [...argv.slice(1)]);
     }
-    process.stderr.write(`self-repair: unknown subcommand '${sub}' (status | release).\n`);
+    if (sub === 'targets') {
+        return targetsCmd(root);
+    }
+    process.stderr.write(
+        `self-repair: unknown subcommand '${sub}' (status | release | targets).\n`,
+    );
     return EXIT_FAIL;
 }