@event4u/agent-config 14.21.0 → 14.23.0

package/src/scripts/session_memory_index.ts

@@ -22,10 +22,18 @@
  * default is off, per the roadmap's "off unless proven".
  */
 
-import { CURATED_TYPES, retrieve_v1 } from './memory_lookup.js';
+import { CURATED_TYPES, MEMORY_ROOT, retrieve_v1 } from './memory_lookup.js';
 import { load_agent_settings } from './_lib/agent_settings.js';
+import {
+    capRows,
+    orderRows,
+    SESSION_INDEX_ROW_CAP,
+    verifyMemoryRoot,
+    type TrustGrant,
+    type TrustVerdict,
+} from './_lib/session_index_trust.js';
 
-export const SESSION_INDEX_ROW_CAP = 30;
+export { SESSION_INDEX_ROW_CAP };
 
 interface IndexRow {
     id: string;
@@ -54,21 +62,72 @@ export function session_index_enabled(root: string): boolean {
  * Expects the caller to have chdir'd to the workspace root — memory roots
  * are cwd-relative, same contract as the MCP tool handlers.
  */
+/**
+ * How many entries retrieval is asked for before the declared order picks.
+ *
+ * R2 finding 2: asking retrieval for the CAP made P4 decorative. Every curated
+ * hit scores an identical 0.1 with an empty key set, so `retrieve` sliced the
+ * first 30 in STORE order at `memory_lookup.ts:995` and `orderRows` then sorted
+ * a set the cap had already chosen. Measured by the reviewer: a 40-entry corpus
+ * with the 5 cheapest last emitted zero cheap rows.
+ *
+ * The number must therefore exceed any realistic curated corpus, not merely the
+ * cap. 500 is a STATED DEFAULT, not a measured optimum — the cost of asking for
+ * more than exists is bounded by what exists, since `detail: 'index'` returns a
+ * row rather than a body. Its falsifier is recorded in the roadmap: a corpus
+ * larger than this bound makes store order decide again, silently.
+ */
+export const SESSION_INDEX_RETRIEVAL_LIMIT = 500;
+
 export function session_index_rows(cap: number = SESSION_INDEX_ROW_CAP): IndexRow[] {
-    const envelope = retrieve_v1([...CURATED_TYPES], [], cap, { detail: 'index' });
+    // Retrieval is asked for far more than the cap, so the declared order below
+    // is what chooses which rows survive truncation. P4 and P6 are one
+    // decision: retrieve wide, order, THEN cap — and never the reverse.
+    const envelope = retrieve_v1([...CURATED_TYPES], [], SESSION_INDEX_RETRIEVAL_LIMIT, { detail: 'index' });
     const entries = (envelope['entries'] as Array<Record<string, unknown>>) ?? [];
-    return entries.slice(0, cap).map((e) => ({
+    const rows: IndexRow[] = entries.map((e) => ({
         id: String(e['id'] ?? ''),
         title: String(e['title'] ?? ''),
         tokens_estimate: Number(e['tokens_estimate'] ?? 0),
     }));
+    return capRows(orderRows(rows), cap);
+}
+
+/**
+ * The trust gate, separated from the render so a caller can log WHY nothing
+ * was injected. `null` from {@link build_session_index_block} is ambiguous by
+ * construction — empty corpus and refused root look identical — and the
+ * distinction is the point of the contract, so it is available here.
+ *
+ * The workspace root is REQUIRED. `MEMORY_ROOT` is relative, so without a root
+ * to resolve it against there is nothing to check identity or containment
+ * against, and a default would be a bypass wearing a convenience.
+ */
+export function session_index_trust(workspaceRoot: string, now?: Date): TrustVerdict {
+    // `exactOptionalPropertyTypes` refuses `now: undefined` on an optional
+    // field, so the key is omitted rather than passed as undefined.
+    return verifyMemoryRoot({
+        workspaceRoot,
+        relativeMemoryRoot: MEMORY_ROOT,
+        ...(now === undefined ? {} : { now }),
+    });
 }
 
 /**
- * Render the injectable block, or `null` when the corpus is empty (no
- * block beats an empty scaffold).
+ * RENDER a block from whatever `MEMORY_ROOT` currently resolves to. Checks
+ * nothing, serves nothing.
+ *
+ * Split out on R2 findings 6 and 7. The trust check used to be an OPTIONAL
+ * parameter, which made the serving path opt-in — and `session_index_cost()`
+ * omitted it, so the one function whose name suggests it only measures was also
+ * the one that could render unchecked. Now the two operations have two names:
+ * this one renders (for cost measurement and for the unit seam that injects an
+ * absolute fixture root via `_setMemoryRoot`, which by construction sits
+ * outside any workspace), and {@link serve_session_index_block} is the only way
+ * to obtain a block for INJECTION — it takes a granted verdict, so there is no
+ * unchecked serving path to forget.
  */
-export function build_session_index_block(cap: number = SESSION_INDEX_ROW_CAP): string | null {
+export function render_session_index_block(cap: number = SESSION_INDEX_ROW_CAP): string | null {
     const rows = session_index_rows(cap);
     if (rows.length === 0) return null;
     const lines = [
@@ -81,13 +140,27 @@ export function build_session_index_block(cap: number = SESSION_INDEX_ROW_CAP):
     return lines.join('\n');
 }
 
+/**
+ * The only path to a block that will be INJECTED.
+ *
+ * Takes a granted verdict rather than a root, so the check happens once, at the
+ * caller, and cannot be skipped here — R2 finding 7 was that the hook and the
+ * builder each computed it, for a diagnostic the dispatcher does not forward.
+ * The type is `TrustGrant`, not `TrustVerdict`: a refusal cannot be passed in,
+ * so "did you check?" is answered by the signature instead of by a convention.
+ */
+export function serve_session_index_block(_grant: TrustGrant, cap: number = SESSION_INDEX_ROW_CAP): string | null {
+    return render_session_index_block(cap);
+}
+
 /**
  * Deterministic fixed cost of the block in real tokens (cl100k_base) —
  * the measurable arm of the roadmap's ship-criterion. Lazy-loads the
  * tokenizer so the enabled=off fast path never pays it.
  */
 export async function session_index_cost(cap: number = SESSION_INDEX_ROW_CAP): Promise<number> {
-    const block = build_session_index_block(cap);
+    // Renders rather than serves: this measures a cost, it injects nothing.
+    const block = render_session_index_block(cap);
     if (block === null) return 0;
     const { gpt_tokens } = await import('./_lib/token_count.js');
     return gpt_tokens(block).tokens;

package/src/scripts/skill_tools/score_skill_relevance.ts

@@ -66,9 +66,16 @@ export const ROOT = path.resolve(path.dirname(_HERE), '..', '..', '..');
  * start ranking different trees. `null` when no candidate root exists, and the
  * CLI turns that into a distinct exit code rather than an empty list.
  */
-import { DEFAULT_CATALOGUE_ROOTS, resolveSkillsRoot } from '../_lib/skill_catalogue.js';
+import { DEFAULT_CATALOGUE_ROOTS, resolveSkillCatalogueRoots } from '../_lib/skill_catalogue.js';
 
-export const DEFAULT_SKILLS_DIR: string | null = resolveSkillsRoot(ROOT);
+/**
+ * Every readable catalogue root, in precedence order — possibly empty.
+ *
+ * The default the CLI and the hook rank across. `DEFAULT_SKILLS_DIR` below is
+ * the first of them and stays exported for the surfaces that name one directory.
+ */
+export const DEFAULT_SKILLS_ROOTS: readonly string[] = resolveSkillCatalogueRoots(ROOT);
+export const DEFAULT_SKILLS_DIR: string | null = DEFAULT_SKILLS_ROOTS[0] ?? null;
 
 /** Mirror Python len(str) — count Unicode code points, not UTF-16 units. */
 function pyLen(s: string): number {
@@ -164,6 +171,27 @@ export interface Skill {
     triggerText: string[];
 }
 
+/**
+ * Load one root, or several with the FIRST occurrence of a name winning.
+ *
+ * Precedence by name, never by root: every root is read, and a collision
+ * resolves to the earliest root that carries it — `resolveSkillCatalogueRoots`
+ * owns what that order means. Reading only the first root is the defect this
+ * replaced; silently ranking one name twice would be the next one.
+ */
+function _load_skills_across(roots: readonly string[]): Skill[] {
+    const out: Skill[] = [];
+    const seen = new Set<string>();
+    for (const root of roots) {
+        for (const s of _load_skills(root)) {
+            if (seen.has(s.name)) continue;
+            seen.add(s.name);
+            out.push(s);
+        }
+    }
+    return out;
+}
+
 function _load_skills(skillsDir: string): Skill[] {
     const skills: Skill[] = [];
     for (const skillMd of _globSkillMd(skillsDir)) {
@@ -246,9 +274,16 @@ function _score(taskTerms: Set<string>, skill: Skill, opts: RankOptions = {}): n
 
 export type RankRow = [string, number, string[]];
 
-export function rank(task: string, skillsDir: string, opts: RankOptions = {}): RankRow[] {
+/**
+ * @param skillsDir one root, or several to rank across (see `_load_skills_across`).
+ */
+export function rank(
+    task: string,
+    skillsDir: string | readonly string[],
+    opts: RankOptions = {},
+): RankRow[] {
     const taskTerms = _tokenize(task);
-    const skills = _load_skills(skillsDir);
+    const skills = _load_skills_across(typeof skillsDir === 'string' ? [skillsDir] : skillsDir);
     const rows: RankRow[] = [];
     for (const s of skills) {
         const score = _score(taskTerms, s, opts);
@@ -384,6 +419,15 @@ interface Args {
     task: string;
     /** `null` when no catalogue root exists — a DIFFERENT answer from an empty ranking. */
     skills_dir: string | null;
+    /**
+     * Did the operator NAME the directory?
+     *
+     * An explicit `--skills-dir` means one root and only that root: an operator
+     * pointing at a tree is asking about that tree, and quietly unioning the
+     * host catalogue into their answer would make the flag mean something else.
+     * Absent, the default ranks across every readable root.
+     */
+    skills_dir_explicit: boolean;
     top: number;
     json: boolean;
     sample: boolean;
@@ -407,6 +451,7 @@ export function parse_args(argv: string[]): Args {
     const args: Args = {
         task: '',
         skills_dir: DEFAULT_SKILLS_DIR,
+        skills_dir_explicit: false,
         top: 0,
         json: false,
         sample: false,
@@ -431,8 +476,10 @@ export function parse_args(argv: string[]): Args {
                 _argError('argument --skills-dir: expected one argument');
             }
             args.skills_dir = v;
+            args.skills_dir_explicit = true;
         } else if (a.startsWith('--skills-dir=')) {
             args.skills_dir = a.slice('--skills-dir='.length);
+            args.skills_dir_explicit = true;
         } else if (a === '--top') {
             const v = argv[++i];
             if (v === undefined) {
@@ -497,7 +544,24 @@ export function main(argv: string[] | null = null): number {
     // operator who passes a wrong path is in exactly the position the silent
     // failure was about, and answering them with "(no relevant skills found)"
     // is the same wrong answer with a different cause.
-    const unreadable = catalogueDeficit(args.skills_dir);
+    // One root when the operator named it; otherwise every readable root, so the
+    // ranking covers what the session can actually reach.
+    const roots: readonly string[] = args.skills_dir_explicit
+        ? args.skills_dir === null
+            ? []
+            : [args.skills_dir]
+        : DEFAULT_SKILLS_ROOTS;
+    // An EXPLICIT directory is always deficit-checked, even when it resolved to a
+    // one-element list: a wrong path must not degrade to "(no relevant skills
+    // found)", which is the silent failure the check exists for and which the
+    // first draft of this branch reintroduced. For the DEFAULT, the deficit is
+    // "not one readable root anywhere" — a single empty candidate is no longer a
+    // deficit, because the others may still carry the catalogue.
+    const unreadable = args.skills_dir_explicit
+        ? catalogueDeficit(args.skills_dir)
+        : roots.length === 0
+          ? catalogueDeficit(null)
+          : null;
     if (unreadable !== null) {
         if (args.json) {
             process.stdout.write(
@@ -520,7 +584,7 @@ export function main(argv: string[] | null = null): number {
     }
     // Non-null past the deficit check above, which returns before this line
     // whenever the root cannot be ranked.
-    const rows = rank(task, args.skills_dir as string);
+    const rows = rank(task, roots);
     if (args.json) {
         const sliced = args.top ? rows.slice(0, args.top) : rows;
         const payload = sliced.map(([n, s, p]) => ({ name: n, score: s, personas: p }));

package/src/scripts/skill_tools/suggest_skill_for_task.ts

@@ -32,7 +32,7 @@ import { audit, type PersonaRow } from './audit_persona_coverage.js';
 /** Sentinel for "no catalogue root resolved" — never a readable path. */
 const NO_CATALOGUE = '<no-skills-catalogue>';
 
-import { DEFAULT_SKILLS_DIR, rank } from './score_skill_relevance.js';
+import { DEFAULT_SKILLS_DIR, DEFAULT_SKILLS_ROOTS, rank } from './score_skill_relevance.js';
 
 const _HERE = fileURLToPath(import.meta.url);
 // src/scripts/skill_tools/suggest_skill_for_task.ts → parents[3] of the .py
@@ -78,13 +78,27 @@ export interface Combo {
     why: string;
 }
 
+/**
+ * @param skillsDir the root the PERSONA audit reads — one directory by necessity.
+ * @param rankRoots roots to RANK across; defaults to `[skillsDir]`.
+ *
+ * The two parameters are separate because the two questions are. Ranking wants
+ * every catalogue the session can reach (`resolveSkillCatalogueRoots`); the
+ * persona-coverage audit walks one tree and pairs it with one persona directory.
+ * Collapsing them was the state a neutral review found on 2026-09-07: the MCP
+ * handler ranked the union while this CLI ranked the first root, so a consumer
+ * carrying its own project skills got a different answer from each — exactly the
+ * two-resolvers-over-one-catalogue split the resolver's docstring warns about,
+ * reproduced by the change that claimed to fix it.
+ */
 export function suggest(
     task: string,
     skillsDir: string,
     personasDir: string,
     top = 3,
+    rankRoots: readonly string[] = [skillsDir],
 ): Combo[] {
-    const ranked = rank(task, skillsDir).slice(0, top);
+    const ranked = rank(task, rankRoots).slice(0, top);
     const personaRows = audit(skillsDir, personasDir);
     const status = _persona_status(personaRows);
     return ranked.map(([name, score, personas]) => ({
@@ -193,6 +207,8 @@ const PROG = 'suggest_skill_for_task.py';
 interface Args {
     task: string;
     skills_dir: string;
+    /** Did the operator NAME the directory? One tree then, and only that tree. */
+    skills_dir_explicit: boolean;
     personas_dir: string;
     top: number;
     json: boolean;
@@ -219,6 +235,7 @@ export function parse_args(argv: string[]): Args {
         // DEFAULT_SKILLS_DIR removed. When no catalogue resolves, this reads
         // as the literal marker below and the caller's own check reports it.
         skills_dir: DEFAULT_SKILLS_DIR ?? NO_CATALOGUE,
+        skills_dir_explicit: false,
         personas_dir: DEFAULT_PERSONAS,
         top: 3,
         json: false,
@@ -244,8 +261,10 @@ export function parse_args(argv: string[]): Args {
                 _argError('argument --skills-dir: expected one argument');
             }
             args.skills_dir = v;
+            args.skills_dir_explicit = true;
         } else if (a.startsWith('--skills-dir=')) {
             args.skills_dir = a.slice('--skills-dir='.length);
+            args.skills_dir_explicit = true;
         } else if (a === '--personas-dir') {
             const v = argv[++i];
             if (v === undefined) {
@@ -279,7 +298,22 @@ export function main(argv: string[] | null = null): number {
     if (!task) {
         _argError('--task is required (or pass --sample)');
     }
-    const combos = suggest(task, args.skills_dir, args.personas_dir, args.top);
+    // Rank across every readable root; audit personas against the first. An
+    // explicit --skills-dir names one tree and is honoured as one tree.
+    //
+    // Keyed on the FLAG, not on value-equality against the default. Corrected
+    // after a second neutral review: comparing paths meant
+    // `--skills-dir <the resolved default>` silently ranked the union including
+    // `~/.claude/skills`, so the comment above was false for exactly the operator
+    // who spelled the default out. And when no catalogue resolves at all,
+    // `skills_dir` is the `NO_CATALOGUE` sentinel while `DEFAULT_SKILLS_DIR` is
+    // null, so the old comparison was false there too — the branch was dead in
+    // the state it was written for.
+    const rankRoots =
+        !args.skills_dir_explicit && DEFAULT_SKILLS_ROOTS.length > 0
+            ? DEFAULT_SKILLS_ROOTS
+            : [args.skills_dir];
+    const combos = suggest(task, args.skills_dir, args.personas_dir, args.top, rankRoots);
     if (args.json) {
         process.stdout.write(pyJsonDumpsIndent2({ task, suggestions: combos }));
         process.stdout.write('\n');

package/src/server/schemas/settings.ts

@@ -31,7 +31,8 @@ const confidenceBand = z.enum(['off', 'low', 'medium', 'high']);
 const onBlock = z.enum(['stop', 'ask', 'warn']);
 const onBlockFallback = z.enum(['stop', 'warn']);
 const modelAutoSwitch = z.enum(['auto', 'suggest', 'off']);
-const leanProjectionMode = z.enum(['eager-all', 'thin']);
+const leanProjectionMode = z.enum(['eager-all', 'thin', 'delivery']);
+const leanProjectionHost = z.enum(['claude-code', 'cursor', 'cline']);
 const projectionMode = z.enum(['legacy-all', 'scoped']);
 const memoryCadence = z.enum(['auto', 'always', 'never']);
 const projectAudience = z.enum(['self', 'internal', 'client', 'public']);
@@ -64,9 +65,19 @@ export const settingsSchema = z.object({
     ),
     lean_projection: z.object({
         mode: leanProjectionMode.default('eager-all').describe(
-            'How the per-tool projector emits the rule layer. eager-all = every rule body inlined into every projection (default, safe). thin = kernel rules full-bodied + non-kernel rules as router-resolved pointers (~45k GPT-tok lighter per session). EXPERIMENTAL: validate with the live A/B before flipping; one-flip revert to eager-all.',
-        ),
-    }).default({ mode: 'eager-all' }),
+            'How the per-tool projector emits the rule layer. eager-all = every rule body inlined into every projection (safe; what an ABSENT key still resolves to, per ADR-267 decision point 4). thin = kernel rules full-bodied + non-kernel rules as router-resolved pointers (~45k GPT-tok lighter per session), with no delivery mechanism. delivery = thin stubs PLUS the rule-inject hook concern, which delivers a body back on a trigger match; this is the value the SHIPPED TEMPLATE carries for Claude Code since ADR-267, and the activation charge for it is paid in src/config/hook-token-budget.json (user_prompt_submit slot sum 4,096 -> 16,384).',
+        ),
+        hosts: z.array(leanProjectionHost).default(['claude-code']).describe(
+            'Which hosts a thinning mode may thin (ADR-267). Absent resolves to [claude-code]. '
+            + 'Only the three hosts with a per-rule rule tree are accepted, and this enum is the '
+            + 'AUTHORING layer: an id outside it is a hard validation FAILURE here and under '
+            + 'validate_agent_settings, never a warning. resolveLeanProjectionHosts is the '
+            + 'READ-TIME backstop for a hand-edited .agent-settings.yml that passed neither, and '
+            + 'THERE the id is dropped with a warning (R2 finding 6 — the two layers answer '
+            + 'differently and neither said so). Every host outside this list receives exactly '
+            + 'what eager-all writes, asserted byte-for-byte by check_host_tree_parity.',
+        ),
+    }).default({ mode: 'eager-all', hosts: ['claude-code'] }),
     cost: z.object({
         budgets: z.object({
             daily: z.number().min(0).default(0).describe(
@@ -438,6 +449,14 @@ export const settingsSchema = z.object({
             ),
         }),
     }),
+    continuity: z.object({
+        auto_record: z.enum(['on', 'off']).default('off').describe(
+            'Deterministic continuity-record writer at session end (road-to-continuity-writer-activation Phase 1). on = the session-eol concern writes the continuity_record capsule variant on Stop for a substantive session that has claimed a roadmap; every field is computed from on-disk state, with no model spend and no subprocess. off (default) = no automatic record — while session:recycle is still the normal path, a second producer on it before the parity evidence is in would be unverified.',
+        ),
+        run_checkpoints: z.enum(['on', 'off']).default('on').describe(
+            'Deterministic run-checkpoint production at session end (road-to-continuity-writer-activation Phase 1.4). on (default) = a session above the recycle threshold and inside a running roadmap contract leaves agents/runtime/state/checkpoints/<run>.json, so a killed run resumes from a derived checkpoint rather than from bookkeeping. off = no checkpoint; continuity writing, the recycle advisory and the context-fill surface are unaffected. Default ON because it is the behaviour the tree already had — the switch exists to make the three session-end handlers independently disableable, not to change what ships.',
+        ),
+    }),
     memory: z.object({
         cadence: memoryCadence.default('always').describe(
             'Cadence of the 🧠 memory-visibility line after a memory-consulting step. always (default) = show whenever a memory type was asked; auto = show only when 3+ types were consulted (less noise); never = suppress. Distinct from rule_loading_tier — owns its own key since the 2026-06-01 untangle.',

package/src/vendor/grammars/README.md

@@ -0,0 +1,86 @@
+# Vendored tree-sitter grammars
+
+Compiled WebAssembly grammars for the native code-graph engine
+(`src/scripts/code_graph/`). They are vendored — carried in this repository and
+published inside the npm tarball — so that a consumer who runs
+`npm install @event4u/agent-config` can build a code graph on the next command
+with no manual parser install (ADR-259).
+
+## Why vendored rather than a dependency
+
+`tree-sitter-wasms` carries 36 grammars (49 MiB on disk). Depending on it at
+runtime would hand every consumer all 36, which is the option ADR-259 §
+Alternatives rejects on exactly that measurement. Only the three grammars below
+are loadable by the engine — `GRAMMAR_WASM` in `src/scripts/code_graph/types.ts`
+has three entries — so the other 33 would be payload with no reader.
+
+**No grammar is ever fetched at runtime** (Kill register K1). These files are in
+the tarball; the loader reads them from disk.
+
+## The set
+
+| Language | File | SHA-256 |
+|---|---|---|
+| php | `tree-sitter-php.wasm` | `55bb617b6f01e14bab997861f0b20a2420cf6ba3199ffeb295b9ec398966d8a3` |
+| typescript (also serves `.tsx`) | `tree-sitter-typescript.wasm` | `8515404dceed38e1ed86aa34b09fcf3379fff1b4ff9dd3967bcd6d1eb5ac3d8f` |
+| javascript | `tree-sitter-javascript.wasm` | `63812b9e275d26851264734868d27a1656bd44a2ef6eb3e85e6b03728c595ab5` |
+
+All three are built against **grammar ABI 14** (`EXPECTED_GRAMMAR_ABI` in
+`src/scripts/code_graph/types.ts`). The loader asserts the ABI on every load, so
+a drifted grammar fails loudly rather than parsing wrongly.
+
+## Provenance
+
+Copied byte-for-byte from `tree-sitter-wasms@0.1.13`
+(<https://github.com/Gregoor/tree-sitter-wasms>, Unlicense), which compiles them
+from the upstream `tree-sitter/tree-sitter-{php,typescript,javascript}` grammars
+(MIT). The compiled artifacts are derivatives of the MIT grammar sources, so
+they are annotated MIT in `REUSE.toml` and credited in `CREDITS.md`.
+
+`tree-sitter-wasms` remains a **devDependency**: it is the source these copies
+are refreshed from, and the ABI smoke test in `tests/scripts/code_graph.test.ts`
+runs against it. It is deliberately not a runtime dependency.
+
+## Verification
+
+Two checks, and they answer different questions.
+
+`src/config/packed-binary-manifest.json` plus `_lib/packed_binary_predicate.ts`
+verify that these bytes are what the manifest says they are — eleven conditions,
+all of them re-derived from the bytes. Every one of them reads the manifest, so
+a commit that edits a row and its file together satisfies all eleven.
+
+`_lib/vendored_grammar_upstream.ts` verifies that these bytes are what the
+**locked upstream** says they are: it byte-compares each file against
+`node_modules/tree-sitter-wasms/out/`, after asserting that the installed
+version is the one `package-lock.json` pins. An absent or unlocked upstream is a
+refusal, never a pass. It is exercised by
+`tests/scripts/vendored_grammar_upstream.test.ts`, which also drives every
+refusal path and a real mutated grammar to failure.
+
+What neither check covers is a `package-lock.json` row pointing at a hostile
+package; that is review's job, and `packed_binary_predicate.ts`'s docblock says
+so in those words.
+
+## Refreshing
+
+The pair is ABI-coupled and must move together:
+
+```bash
+npm i -D web-tree-sitter@<v> tree-sitter-wasms@<v>
+for g in php typescript javascript; do
+  cp node_modules/tree-sitter-wasms/out/tree-sitter-$g.wasm src/vendor/grammars/
+done
+shasum -a 256 src/vendor/grammars/*.wasm   # update the table above
+```
+
+Then update, in the same change:
+
+- the three entries in `src/config/packed-binary-manifest.json` (they are
+  path-, sha256- and size-bound, so any refresh invalidates them by design).
+  This used to name `BINARY_PAYLOAD_EXCEPTIONS` in `src/scripts/check_pack_size.ts`,
+  a constant that no longer exists — `grep -rn BINARY_PAYLOAD_EXCEPTIONS` returned
+  this line and nothing else, so a refresher following it would have skipped the
+  manifest and reddened the pack-size gate with no pointer to why;
+- `EXPECTED_GRAMMAR_ABI` in `src/scripts/code_graph/types.ts` if the ABI moved;
+- the install-size line in `MIGRATION.md`.

package/src/scripts/_lib/carrier_status.ts

@@ -1,118 +0,0 @@
-/**
- * The `status: carrier` predicate, and the reasoning five readers share.
- *
- * A carrier is a roadmap whose job is to hold obligations deferred out of a
- * parent that is already archived. Every item in it has an unmet resumption
- * trigger, and it has no `## Phase` headings, so it is skipped wherever a draft
- * is: the dashboard, `/roadmap:process-*`, the trackability check and the plan
- * risk register. It differs from a draft in what it costs to remove — a draft
- * may be deleted freely, a carrier may not.
- *
- * This module exists because the predicate had two implementations within one
- * change and five callers within one week. Two implementations of one frontmatter
- * test drift, and the one nobody runs locally drifts first — the same
- * memory-twin failure this repository has already recorded against a fixture
- * corpus. One test, one place, and the reasoning above lives beside it rather
- * than being restated in each caller.
- *
- * The read is frontmatter-scoped on purpose. A fenced `status: carrier` inside a
- * roadmap that documents the syntax is not a declaration, and a body-wide match
- * turned exactly that into a hard failure before a review caught it.
- */
-
-/** The frontmatter values that mean "not schedulable work, and not disposable". */
-export const CARRIER_VALUES: ReadonlySet<string> = new Set(['carrier']);
-
-/** The leading `---\n…\n---` block, or null when the text carries none. */
-export function frontmatterBlock(text: string): string | null {
-    const m = /^---\n([\s\S]*?)\n---/.exec(text);
-    return m === null ? null : (m[1] ?? '');
-}
-
-/** True when `text`'s FRONTMATTER declares one of {@link CARRIER_VALUES}. */
-export function declaresCarrier(text: string | null | undefined): boolean {
-    if (text === null || text === undefined) {
-        return false;
-    }
-    const fm = frontmatterBlock(text);
-    if (fm === null) {
-        return false;
-    }
-    const m = /^status:[ \t]*([A-Za-z-]+)[ \t]*$/m.exec(fm);
-    return m !== null && CARRIER_VALUES.has((m[1] ?? '').toLowerCase());
-}
-
-/**
- * Count the top-level roadmaps in `roadmapRoot` that declare themselves carriers.
- *
- * Lives here rather than in the estate gate because it is the same fact as the
- * predicate above, read over a directory instead of a string, and the gate that
- * needs it is already at its source-size ceiling.
- *
- * @param isCandidate the caller's own roadmap-filename test, so this module does
- *        not acquire a second opinion about what counts as a roadmap.
- */
-export function countDeclaredCarriers(
-    roadmapRoot: string,
-    isCandidate: (name: string) => boolean,
-    fsLike: {
-        readdirSync: (p: string) => string[];
-        statSync: (p: string) => { isFile: () => boolean };
-        readFileSync: (p: string, enc: 'utf-8') => string;
-    },
-    join: (...parts: string[]) => string,
-): number {
-    let names: string[];
-    try {
-        names = fsLike.readdirSync(roadmapRoot);
-    } catch {
-        return 0;
-    }
-    let n = 0;
-    for (const name of names) {
-        if (!name.endsWith('.md') || !isCandidate(name)) {
-            continue;
-        }
-        const abs = join(roadmapRoot, name);
-        try {
-            if (!fsLike.statSync(abs).isFile()) {
-                continue;
-            }
-            if (declaresCarrier(fsLike.readFileSync(abs, 'utf-8'))) {
-                n += 1;
-            }
-        } catch {
-            continue;
-        }
-    }
-    return n;
-}
-
-/**
- * Fixture design — why two of the estate self-test cases are shaped as they are.
- *
- * The reasoning behind two of `check_estate_count`'s self-test cases, kept here
- * because the gate that holds them is at its source-size ceiling and because
- * both facts are about the carrier status rather than about that gate.
- *
- * **The deletion case's addition is a DRAFT, and that is the whole design.**
- * A carrier holds obligations lifted out of an already-archived parent, so
- * paying an offset for removing one rewards the loss: the deletion buys nothing
- * and the addition stays unpaid. With an *ordinary* addition the growth half and
- * the unpaid half coincide — growth iff `n > a`, unpaid iff `n > a` — so the
- * case rejected on two independent grounds and stayed red with the carrier
- * branch reverted, asserting nothing about the feature it named. A draft is
- * invisible to `collect()`, so the count half cannot move and only the offset
- * scoring decides.
- *
- * **The count case asserts the flip BACK, not the flip TO.** A reclassification
- * is not a disposal in either direction, but the flip *to* carrier cannot be
- * asserted by exit code: it lowers the count, a count below the floor is a
- * drawdown, and a drawdown is free whichever way carriers are counted. Its
- * consequence is assertable — with carriers uncounted the flip lowers the floor,
- * so flipping the same file back reads as growth and must be paid for. That is
- * the fixture's state, with the carrier already in the base tree, and it rejects
- * with the carrier term removed from the count. The neutrality of the forward
- * flip is asserted directly in `check_estate_count.test.ts`, where a count is
- * readable.
- */