@event4u/agent-config 16.2.0 → 16.4.0

package/src/scripts/estate_exemption_shape.ts

@@ -0,0 +1,202 @@
+#!/usr/bin/env tsx
+/**
+ * What the `estate_offset_exempt` population actually says — the producing command.
+ *
+ * THIS IS A READER, NOT A GATE. It exits 0 on every corpus, including one where
+ * no reason names anything. The refusal lives in `check_estate_count`, applies
+ * to ADDED files only, and is grandfathered precisely because of what this
+ * script measures: 43 of the 221 reasons in the tree on 2026-10-01 name no
+ * alternative disposition, so a check that re-read them would land red on a
+ * fifth of its corpus.
+ *
+ * WHAT IT BUYS. Two numbers nobody could produce before: how many exemptions
+ * name a rejected alternative, and how many repeat another file's reason
+ * verbatim. Both are the inputs to whether the refusal vocabulary is the right
+ * one, and both move as the estate moves — so the NEXT reading is a delta
+ * rather than a re-derivation, which is the same bargain `roadmap_verify_share`
+ * makes for the verify grammar.
+ *
+ * THE VOCABULARY IS NOT THIS SCRIPT'S. It imports the lemma list the gate
+ * refuses on, so the report and the refusal cannot drift. A drifted pair fails
+ * silently and in the worst direction: the report says the tree conforms while
+ * the gate rejects it.
+ *
+ * CLI:
+ *   ./scripts-run src/scripts/estate_exemption_shape
+ *   ./scripts-run src/scripts/estate_exemption_shape --json
+ *   ./scripts-run src/scripts/estate_exemption_shape --root <dir>
+ *
+ * Exit codes: 0 always, except 2 for bad argv or a scan root that holds nothing.
+ */
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import process from 'node:process';
+import { fileURLToPath } from 'node:url';
+
+import { exemptionReason } from './_lib/estate_offsets.js';
+import { DISPOSITION_LEMMAS, lemmasNamed, namesDisposition, reasonKey } from './_lib/exemption_shape.js';
+import { DeadScopeError, assertScanned } from './_lib/scan_scope.js';
+
+const _HERE = fileURLToPath(import.meta.url);
+const _PROG = 'estate_exemption_shape';
+const REPO_ROOT = path.resolve(path.dirname(_HERE), '..', '..');
+
+/** The three trees an exemption can sit in. `stubs/` and `skipped/` carry none. */
+const TREES: readonly { readonly label: string; readonly dir: string }[] = [
+    { label: 'active', dir: 'agents/roadmaps' },
+    { label: 'later', dir: 'agents/roadmaps/later' },
+    { label: 'archive', dir: 'agents/roadmaps/archive' },
+];
+
+export interface ExemptionRow {
+    readonly tree: string;
+    readonly file: string;
+    readonly reason: string;
+    /** The disposition lemmas this reason names; empty means it names none. */
+    readonly lemmas: readonly string[];
+}
+
+export interface ShapeReport {
+    readonly rows: readonly ExemptionRow[];
+    readonly shaped: number;
+    readonly shapeless: number;
+    /** Per-lemma hit counts, in the gate's own lemma order. */
+    readonly byLemma: Readonly<Record<string, number>>;
+    /** Groups of two or more files sharing one reason, largest first. */
+    readonly duplicates: readonly (readonly string[])[];
+}
+
+/** Read every exemption under `root`, in a stable order. */
+export function collectExemptions(root: string): ExemptionRow[] {
+    const rows: ExemptionRow[] = [];
+    for (const tree of TREES) {
+        const abs = path.join(root, tree.dir);
+        let names: string[];
+        try {
+            names = fs.readdirSync(abs);
+        } catch {
+            continue;
+        }
+        for (const name of [...names].sort()) {
+            if (!name.endsWith('.md')) continue;
+            const file = path.join(abs, name);
+            let text: string;
+            try {
+                if (!fs.statSync(file).isFile()) continue;
+                text = fs.readFileSync(file, 'utf-8');
+            } catch {
+                continue;
+            }
+            const reason = exemptionReason(text);
+            if (reason === null) continue;
+            rows.push({ tree: tree.label, file: `${tree.dir}/${name}`, reason, lemmas: lemmasNamed(reason) });
+        }
+    }
+    return rows;
+}
+
+/** Summarise the population against the gate's vocabulary. */
+export function report(rows: readonly ExemptionRow[]): ShapeReport {
+    const byLemma: Record<string, number> = {};
+    for (const l of DISPOSITION_LEMMAS) {
+        byLemma[l.name] = rows.filter((r) => r.lemmas.includes(l.name)).length;
+    }
+    const groups = new Map<string, string[]>();
+    for (const r of rows) {
+        const key = reasonKey(r.reason);
+        const list = groups.get(key) ?? [];
+        list.push(r.file);
+        groups.set(key, list);
+    }
+    const duplicates = [...groups.values()].filter((g) => g.length > 1).sort((a, b) => b.length - a.length);
+    return {
+        rows,
+        shaped: rows.filter((r) => namesDisposition(r.reason)).length,
+        shapeless: rows.filter((r) => !namesDisposition(r.reason)).length,
+        byLemma,
+        duplicates,
+    };
+}
+
+function render(rep: ShapeReport): string {
+    const out: string[] = [];
+    const total = rep.rows.length;
+    out.push(`${_PROG}: ${String(total)} exemption(s)`);
+    for (const tree of TREES) {
+        out.push(`  ${tree.label.padEnd(10)} ${String(rep.rows.filter((r) => r.tree === tree.label).length).padStart(4)}`);
+    }
+    out.push(`  names a rejected alternative  ${String(rep.shaped).padStart(4)}`);
+    out.push(`  names none                    ${String(rep.shapeless).padStart(4)}`);
+    out.push('  per lemma:');
+    for (const l of DISPOSITION_LEMMAS) {
+        out.push(`    ${l.name.padEnd(12)} ${String(rep.byLemma[l.name] ?? 0).padStart(4)}`);
+    }
+    const dupFiles = rep.duplicates.reduce((n, g) => n + g.length, 0);
+    out.push(`  verbatim duplicate groups     ${String(rep.duplicates.length).padStart(4)} covering ${String(dupFiles)} file(s)`);
+    for (const g of rep.duplicates) {
+        out.push(`    (${String(g.length)}x) ${g.join(', ')}`);
+    }
+    if (rep.shapeless > 0) {
+        out.push('  naming no rejected alternative:');
+        for (const r of rep.rows.filter((x) => !namesDisposition(x.reason))) {
+            out.push(`    ${r.file}: ${r.reason.slice(0, 120)}`);
+        }
+    }
+    return out.join('\n') + '\n';
+}
+
+export function main(argv: string[] = process.argv.slice(2)): number {
+    const json = argv.includes('--json');
+    const rootIdx = argv.indexOf('--root');
+    let root = REPO_ROOT;
+    if (rootIdx !== -1) {
+        const next = argv[rootIdx + 1];
+        if (next === undefined || next.startsWith('-')) {
+            process.stderr.write(`usage: ${_PROG} [--root <dir>] [--json]\n`);
+            return 2;
+        }
+        root = path.resolve(next);
+    }
+    const unknown = argv.filter((a) => a.startsWith('-') && a !== '--json' && a !== '--root');
+    if (unknown.length > 0) {
+        process.stderr.write(`${_PROG}: unknown argument(s) ${unknown.join(', ')}\n`);
+        return 2;
+    }
+
+    const rows = collectExemptions(root);
+    try {
+        // A root holding no roadmap at all is a dead scope, never an estate with
+        // nothing to report: this reader would otherwise print a confident zero
+        // over a path that does not exist.
+        assertScanned({
+            gate: _PROG,
+            scanned: TREES.reduce((n, t) => {
+                try {
+                    return n + fs.readdirSync(path.join(root, t.dir)).filter((f) => f.endsWith('.md')).length;
+                } catch {
+                    return n;
+                }
+            }, 0),
+            units: 'roadmap file(s)',
+            roots: TREES.map((t) => t.dir),
+        });
+    } catch (err) {
+        if (err instanceof DeadScopeError) {
+            process.stderr.write(`❌  ${_PROG}: ${err.message}\n`);
+            return 2;
+        }
+        throw err;
+    }
+
+    const rep = report(rows);
+    if (json) {
+        process.stdout.write(JSON.stringify(rep, null, 2) + '\n');
+        return 0;
+    }
+    process.stdout.write(render(rep));
+    return 0;
+}
+
+if (path.resolve(process.argv[1] ?? '') === _HERE) {
+    process.exit(main());
+}

package/src/scripts/explain_run.ts

@@ -27,7 +27,7 @@
  *      honest "no telemetry record" line, never a fabricated estimate.
  *      Sources: `_lib/judgment_ladder.ts::explainLadder` + the same
  *      audit-log-v1 files as §4.
- *   5. Hook / loop / freshness state snapshot. Source:
+ *   5. Hook / freshness state snapshot. Source:
  *      `agents/state/context-hygiene.json` (the code path the hook
  *      actually writes — see `context_hygiene_hook.ts::STATE_FILE`) or
  *      the doc-referenced `agents/runtime/state/context-hygiene.json`.
@@ -477,7 +477,7 @@ function renderSummarySection(
         out.push('- Session health: no state recorded.');
     } else {
         const s = hygiene.state;
-        out.push(`- Session health: ${String(s['tool_calls'] ?? '(unset)')} tool call(s) recorded, loop detected: ${String(s['loop_detected'] ?? '(unset)')}.`);
+        out.push(`- Session health: ${String(s['tool_calls'] ?? '(unset)')} tool call(s) recorded.`);
     }
     return out;
 }
@@ -686,7 +686,7 @@ function renderDecisionSection(
 
 function renderHygieneSection(hygiene: HygieneReadResult): string[] {
     const out: string[] = [];
-    out.push('## Hook / loop state (context-hygiene)');
+    out.push('## Hook state (context-hygiene)');
     out.push(`_Source: tried ${hygiene.checkedPaths.map((p) => `\`${p}\``).join(', then ')}_`);
     out.push('');
     if (hygiene.state === null) {
@@ -697,9 +697,6 @@ function renderHygieneSection(hygiene: HygieneReadResult): string[] {
     out.push(`Found at \`${hygiene.path}\`.`);
     out.push('');
     out.push(`- tool_calls: ${String(s['tool_calls'] ?? '(unset)')}`);
-    out.push(`- consecutive_same_tool: ${String(s['consecutive_same_tool'] ?? '(unset)')}`);
-    out.push(`- last_tool: ${String(s['last_tool'] ?? '(unset)')}`);
-    out.push(`- loop_detected: ${String(s['loop_detected'] ?? '(unset)')}`);
     out.push(`- freshness_threshold: ${String(s['freshness_threshold'] ?? '(unset)')}`);
     out.push(`- checked_at: ${String(s['checked_at'] ?? '(unset)')}`);
     return out;
@@ -718,14 +715,12 @@ function renderParkedSection(): string[] {
         '   thin-projector budget decision** — no on-disk record of "artefact',
         '   considered but dropped for budget" exists today. Revisit-if such a',
         '   record ships.',
-        '3. **Which memory entry id influenced a specific answer**, when the run',
-        '   did NOT opt into `decision_engine.surface_traces` — the',
+        '3. **Which memory entry id influenced a specific answer** — the',
         '   `🧠 Memory: n/m · ids=[...]` line is printed to stdout only, never',
-        '   persisted. The durable form (`memory.ids` in',
-        '   `agents/runtime/state/work/<id>/decision-trace-<phase>.json`) exists',
-        '   ONLY when `decision_engine.surface_traces: true` (off by default) and',
-        '   the run went through /work or /implement-ticket — see `explain last`',
-        '   for that narrower, per-run case; not duplicated here.',
+        '   persisted. The per-phase decision-trace file that once carried',
+        '   `memory.ids` is no longer written: its opt-in key,',
+        '   `decision_engine.surface_traces`, was retired (2026-10-09) with its',
+        '   default (off) as the fixed behavior.',
         '4. **Why a given subagent primitive was/wasn\'t available on this host**',
         '   — the host-capability manifest is resolved in-session by the agent',
         '   from its own knowledge (+ an optional settings override) and is never',

package/src/scripts/generate_git_convention_grammar.ts

@@ -0,0 +1,127 @@
+#!/usr/bin/env tsx
+/**
+ * Writes the grammar block of the commit-subject reference from
+ * `_lib/git_convention_grammar.ts`, so the fallback a command reads when the
+ * `agent-config` binary cannot run is the grammar the binary runs.
+ *
+ * Usage:
+ *     tsx src/scripts/generate_git_convention_grammar.ts            # rewrite in place
+ *     tsx src/scripts/generate_git_convention_grammar.ts --check    # exit 1 when stale
+ *     tsx src/scripts/generate_git_convention_grammar.ts --out PATH # write the refreshed page elsewhere
+ *
+ * Exit codes: 0 written / in sync · 1 stale, or the markers are missing · 2 usage.
+ */
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import process from 'node:process';
+import { fileURLToPath, pathToFileURL } from 'node:url';
+
+import { FAMILY_ERE, FORMAT_GRAMMAR, GIT_OWN_SUBJECT, TICKETLESS_FORM, TICKET_DENYLIST, TICKET_GRAMMAR, TICKET_TOKEN, VERSION_LIKE_KEYS } from './_lib/git_convention_grammar.js';
+import {
+    AUTHOR_CAP_PER_HALF,
+    BULK_IMPORT_FILES,
+    MEASURE_LIMIT,
+    MEASURE_SINCE,
+    MIN_BRANCHES,
+    MIN_CAPPED_AUTHORS,
+    MIN_N,
+    RECENT_WINDOW,
+    SHARE_BAR,
+    SMALL_TEAM_SHARE_BAR,
+    pct,
+} from './_lib/git_convention_measure.js';
+
+const REPO_ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..', '..');
+
+export const REFERENCE = 'src/skills/git-workflow/references/commit-subject.md';
+export const GENERATOR = 'src/scripts/generate_git_convention_grammar.ts';
+export const GRAMMAR_MODULE = 'src/scripts/_lib/git_convention_grammar.ts';
+export const MEASURE_MODULE = 'src/scripts/_lib/git_convention_measure.ts';
+
+const BEGIN = '<!-- BEGIN GENERATED: git-convention-grammar -->';
+const END = '<!-- END GENERATED: git-convention-grammar -->';
+
+export function renderBlock(): string {
+    const rows: [string, string][] = [
+        ['ticket', TICKET_GRAMMAR],
+        ['ticket in text', TICKET_TOKEN],
+        ['standard names', TICKET_DENYLIST.join(' ')],
+        ['version-like names', `${VERSION_LIKE_KEYS.join(' ')} (one-digit number, no card)`],
+        ...Object.entries(FORMAT_GRAMMAR).map(([f, re]) => [`format ${f}`, re] as [string, string]),
+        ...FAMILY_ERE.map(([f, ere]) => [`family ${f}`, ere] as [string, string]),
+        ...Object.entries(TICKETLESS_FORM).map(([f, ere]) => [`family ${f}, no ticket`, `${ere ?? ''} (no ticket elsewhere in the subject)`] as [string, string]),
+        ['any format or family', `${GIT_OWN_SUBJECT} (git's own subjects)`],
+        ['measure sample', `newest ${MEASURE_LIMIT} non-merge commits since ${MEASURE_SINCE}, or regardless of age when that window yields fewer than ${MIN_N}; bots, automation subjects, commits over ${BULK_IMPORT_FILES} files dropped`],
+        ['measure bar', `n >= ${MIN_N}; >= ${pct(SHARE_BAR)} capped at ${AUTHOR_CAP_PER_HALF} per author per half (${MIN_CAPPED_AUTHORS}+ authors), else >= ${pct(SMALL_TEAM_SHARE_BAR)} uncapped; both halves agree`],
+        ['measure migration', `the newer half, or the newest ${RECENT_WINDOW} commits, clearing the bar on another family than the dominant one: "migrating to <family>", and that family is proposed`],
+        ['measure branches', `>= ${MIN_BRANCHES} remote branch names, top shape >= ${pct(SHARE_BAR)}`],
+    ];
+    const width = Math.max(...rows.map(([k]) => k.length)) + 2;
+    return [
+        BEGIN,
+        `<!-- Written by \`./scripts-run ${GENERATOR.replace(/\.ts$/, '')}\` from \`${GRAMMAR_MODULE}\` and \`${MEASURE_MODULE}\`; edit the modules, never this block. -->`,
+        '',
+        '```',
+        ...rows.map(([k, v]) => `${k.padEnd(width)}${v}`),
+        '```',
+        '',
+        'Formats are JavaScript / PCRE syntax; families are POSIX extended, matched in',
+        'order, first hit wins. Under `format ticket-conventional` and `family',
+        'ticket-conventional` a ticket anywhere inside the scope fails, and a standard',
+        'name in the ticket position fails. A ticket is found in a branch or scope only as',
+        'a whole token (`ticket in text`). Without a card, a version-like name — one of',
+        'the keys above with a one-digit number, such as `HTTP-2` or `PHP-8` — is not a',
+        'ticket; `HTTP2-1` still has the ticket shape. A convention card\'s `ticket_keys`',
+        'settles both, and matches a key written in lower case; without a card a',
+        'lower-case key is never detected.',
+        END,
+    ].join('\n');
+}
+
+export function refresh(text: string): { ok: true; text: string } | { ok: false; reason: string } {
+    const start = text.indexOf(BEGIN);
+    const end = text.indexOf(END);
+    if (start === -1 || end === -1 || end < start) return { ok: false, reason: `${REFERENCE} lacks the ${BEGIN} / ${END} markers` };
+    return { ok: true, text: text.slice(0, start) + renderBlock() + text.slice(end + END.length) };
+}
+
+export function main(argv: readonly string[] = process.argv.slice(2), root = REPO_ROOT): number {
+    let check = false;
+    let out: string | null = null;
+    for (let i = 0; i < argv.length; i++) {
+        if (argv[i] === '--check') check = true;
+        else if (argv[i] === '--out' && argv[i + 1] !== undefined) out = argv[++i] as string;
+        else {
+            process.stderr.write(`unknown argument: ${String(argv[i])}\nusage: generate_git_convention_grammar [--check | --out PATH]\n`);
+            return 2;
+        }
+    }
+    const file = path.join(root, REFERENCE);
+    const current = fs.readFileSync(file, 'utf-8');
+    const next = refresh(current);
+    if (!next.ok) {
+        process.stderr.write(`${next.reason}\n`);
+        return 1;
+    }
+    if (check) {
+        if (next.text === current) return 0;
+        process.stderr.write(`${REFERENCE} is stale — run ./scripts-run ${GENERATOR.replace(/\.ts$/, '')}\n`);
+        return 1;
+    }
+    fs.writeFileSync(out ?? file, next.text);
+    return 0;
+}
+
+function _isCliEntry(): boolean {
+    if (process.argv[1] === undefined) return false;
+    if (import.meta.url === pathToFileURL(path.resolve(process.argv[1])).href) return true;
+    try {
+        return fs.realpathSync(fileURLToPath(import.meta.url)) === fs.realpathSync(path.resolve(process.argv[1]));
+    } catch {
+        return false;
+    }
+}
+
+if (_isCliEntry()) {
+    process.exitCode = main();
+}

package/src/scripts/generate_host_cost_table.ts

@@ -52,6 +52,7 @@ import * as fs from 'node:fs';
 import * as path from 'node:path';
 import { fileURLToPath } from 'node:url';
 
+import { extractSection, SectionError } from './_lib/md_section.js';
 import {
     ARTIFACT_REL,
     HOST_SURFACES,
@@ -63,7 +64,7 @@ import {
 const _HERE = fileURLToPath(import.meta.url);
 export const REPO_ROOT = path.resolve(path.dirname(_HERE), '..', '..');
 
-/** The contract the README points at for projection modes (README.md:288). */
+/** The contract the README points at for projection modes. */
 export const CONTRACT_REL = path.join('docs', 'contracts', 'rule-router.md');
 
 export const BEGIN = '<!-- BEGIN generated: host-standing-cost -->';
@@ -85,9 +86,25 @@ export interface HostRow {
  * without anything saying so.
  */
 export function parseCensus(text: string): HostRow[] {
-    const start = text.indexOf('## Per host');
-    if (start === -1) return [];
-    const lines = text.slice(start).split('\n');
+    // Anchored on the LINE, never a substring — a prose mention of the same
+    // heading earlier in the artefact used to be indistinguishable from the
+    // real one under a plain `indexOf` (the measured 2026-08-20 incident
+    // `_lib/md_section.ts` documents). `extractSection` also refuses a
+    // heading that occurs more than once, which this census format never
+    // intends — exactly the silent-wrong-match failure this script's own
+    // "deliberately strict" design already asks for.
+    let section: string;
+    try {
+        section = extractSection(text, '## Per host');
+    } catch (err) {
+        // "not found" means the format moved — the pre-existing, intentional
+        // `[]` contract below. "ambiguous" (the heading occurs more than
+        // once) is NOT the same case and must stay loud: that is exactly the
+        // silently-wrong-match failure this wiring exists to stop.
+        if (err instanceof SectionError && err.message.startsWith('heading not found')) return [];
+        throw err;
+    }
+    const lines = section.split('\n');
     const rows: HostRow[] = [];
     for (const line of lines) {
         if (!line.startsWith('|')) {

package/src/scripts/handoff_context_hook.ts

@@ -332,42 +332,65 @@ export function consume_recycle_envelope(
  * and reading the wrong record for the wrong reason is how a continuation
  * acquires a stranger's state — the failure this step exists to prevent.
  *
- *   - `startup` (and an ABSENT source) — a fresh session. Inject: this is the
- *     ordinary case and the one every existing fixture exercises.
- *   - `clear` — the operator wrote the record and cleared. Inject. This is the
- *     recycle path the record was built for, and suppressing it would defeat
- *     the mechanism. Note that hot-context DISCARDS on the same source, and the
- *     two are right for opposite reasons: hot-context is a cache of a session
- *     that was deliberately thrown away, while the record is the thing the
- *     operator wrote in order to survive throwing it away.
- *   - `compact` — the SAME session continuing past a compaction. Inject: the
- *     resolver keys on session id, so what comes back is this session's own
- *     record rather than a predecessor's. That identity is the reason this is
- *     an inject rather than a suppression.
+ * TWO SEPARATE GATES, not one, since a 2/2 council verdict (2026-10-06): the
+ * prose handoff and the recycle-envelope RECORD are different artefacts with
+ * different safety properties, and coupling them under one `compact` verdict
+ * is what let a stale claim about the record go unnoticed inside a test that
+ * only ever exercised the handoff.
+ *
+ *   - `startup` (and an ABSENT source) — a fresh session. Both gates inject:
+ *     this is the ordinary case and the one every existing fixture exercises.
+ *   - `clear` — the operator wrote the record and cleared. Both gates inject.
+ *     This is the recycle path the record was built for, and suppressing it
+ *     would defeat the mechanism. Note that hot-context DISCARDS on the same
+ *     source, and the two are right for opposite reasons: hot-context is a
+ *     cache of a session that was deliberately thrown away, while the record
+ *     is the thing the operator wrote in order to survive throwing it away.
+ *   - `compact` — the SAME session continuing past a compaction.
+ *     {@link sourceGate} still injects the prose handoff (narrative
+ *     continuity carries no peer-isolation risk). {@link recycleEnvelopeGate}
+ *     does NOT inject the recycle-envelope record: the resolver's own Rule 1
+ *     never returns the reader's own record (a prior sentence here claimed
+ *     the opposite — that claim was never true against the resolver chosen
+ *     2026-09-09, and the council found no safe reading of the alternative
+ *     either — a non-own session id proves only difference, not lineage, so
+ *     consuming "the one other record" on `compact` can hand a session a
+ *     concurrent peer's in-progress state). Until a real predecessor-identity
+ *     signal exists, `compact` leaves every recycle-envelope record
+ *     untouched, exactly like `resume`/`fork`.
  *   - `resume` / `fork` — the host has already restored the conversation.
- *     Inject NOTHING. On `resume` an injection would duplicate context the host
- *     just replayed; on `fork` it is worse than duplication, because the fork
- *     would consume a record belonging to a session that is still alive.
- *   - anything else — inject nothing. An unrecognised source is a host this
- *     code has not been taught, and guessing is the failure mode, not the
- *     conservative choice.
+ *     Both gates inject NOTHING. On `resume` an injection would duplicate
+ *     context the host just replayed; on `fork` it is worse than
+ *     duplication, because the fork would consume a record belonging to a
+ *     session that is still alive.
+ *   - anything else — both gates inject nothing. An unrecognised source is a
+ *     host this code has not been taught, and guessing is the failure mode,
+ *     not the conservative choice.
  *
- * SUPPRESSION MUST NOT CONSUME. The gate runs BEFORE
- * {@link consume_recycle_envelope}, never inside it, because that function
- * moves the file aside on every outcome except `absent`. Calling it and then
- * discarding the result would destroy the record without anyone reading it —
- * the operator's recycle would silently evaporate on a `resume`.
+ * SUPPRESSION MUST NOT CONSUME. Each gate runs BEFORE its own consumer —
+ * {@link recycleEnvelopeGate} before {@link consume_recycle_envelope}, never
+ * inside it — because that function moves the file aside on every outcome
+ * except `absent`. Calling it and then discarding the result would destroy
+ * the record without anyone reading it — the operator's recycle would
+ * silently evaporate on a `resume`, and now also on a `compact`.
  */
 export const INJECTING_SOURCES: ReadonlySet<string> = new Set(['', 'startup', 'clear', 'compact']);
 
+/**
+ * The recycle-envelope RECORD's own injecting set — narrower than
+ * {@link INJECTING_SOURCES}. `compact` is deliberately absent: see the
+ * module docblock's `compact` bullet.
+ */
+export const RECYCLE_INJECTING_SOURCES: ReadonlySet<string> = new Set(['', 'startup', 'clear']);
+
 export interface SourceGate {
     inject: boolean;
     reason: string;
 }
 
-export function sourceGate(source: string): SourceGate {
+function _gate(source: string, injectingSources: ReadonlySet<string>): SourceGate {
     const s = source.trim();
-    if (INJECTING_SOURCES.has(s)) {
+    if (injectingSources.has(s)) {
         return { inject: true, reason: `source=${s === '' ? 'absent' : s}` };
     }
     if (s === 'resume' || s === 'fork') {
@@ -379,12 +402,31 @@ export function sourceGate(source: string): SourceGate {
                     : 'duplicate context the host just replayed'),
         };
     }
+    if (s === 'compact' && !injectingSources.has('compact')) {
+        return {
+            inject: false,
+            reason:
+                'source=compact — a non-own session id proves only difference, not lineage; ' +
+                'consuming the one other record on compact could hand a session a concurrent ' +
+                "peer's in-progress state (agents/evidence/council/compact-resume-2026-10.md)",
+        };
+    }
     return {
         inject: false,
         reason: `source=${s} is not a source this reader knows — injecting nothing rather than guessing`,
     };
 }
 
+/** Gate for the prose handoff ({@link consume_handoff_context}). */
+export function sourceGate(source: string): SourceGate {
+    return _gate(source, INJECTING_SOURCES);
+}
+
+/** Gate for the recycle-envelope record ({@link consume_recycle_envelope}). */
+export function recycleEnvelopeGate(source: string): SourceGate {
+    return _gate(source, RECYCLE_INJECTING_SOURCES);
+}
+
 // ---------------------------------------------------------------------
 // CLI — dispatcher concern entry point
 // ---------------------------------------------------------------------
@@ -415,21 +457,28 @@ export function main(): number {
                 envelope.payload && typeof envelope.payload === 'object' && !Array.isArray(envelope.payload)
                     ? (envelope.payload as Record<string, unknown>)
                     : {};
-            // 3.3. The gate is evaluated FIRST and short-circuits, because both
-            // consumers below move their file aside on every non-absent
-            // outcome. Consuming and then dropping the result would delete the
+            // 3.3 / compact-resume-2026-10 council. Each gate is evaluated
+            // FIRST and short-circuits ITS OWN consumer, because both
+            // consumers move their file aside on every non-absent outcome.
+            // Consuming and then dropping the result would delete the
             // record a suppressed source was supposed to leave alone.
-            const gate = sourceGate(String(payload['source'] ?? envelope['source'] ?? ''));
-            if (!gate.inject) {
-                process.stderr.write(`handoff-context-hook: no injection (${gate.reason})\n`);
+            const source = String(payload['source'] ?? envelope['source'] ?? '');
+            const handoffGate = sourceGate(source);
+            const recycleGate = recycleEnvelopeGate(source);
+            if (!handoffGate.inject && !recycleGate.inject) {
+                process.stderr.write(`handoff-context-hook: no injection (${handoffGate.reason})\n`);
                 return 0;
             }
-            const handoff = consume_handoff_context(root);
-            const recycle = consume_recycle_envelope(
-                root,
-                new Date(),
-                String(envelope['session_id'] ?? '').trim() || env_session_id(),
-            );
+            const handoff: ConsumeDecision = handoffGate.inject
+                ? consume_handoff_context(root)
+                : { action: 'absent', reason: handoffGate.reason };
+            const recycle: ConsumeDecision = recycleGate.inject
+                ? consume_recycle_envelope(
+                      root,
+                      new Date(),
+                      String(envelope['session_id'] ?? '').trim() || env_session_id(),
+                  )
+                : { action: 'absent', reason: recycleGate.reason };
             const blocks: string[] = [];
             const reasons: string[] = [];
             // Recycle envelope first — it is the task-state restore the