@event4u/agent-config 14.21.0 → 14.23.0

package/src/install/ruleLayerPartition.ts

@@ -5,7 +5,7 @@
  * ## Why the decision moved from per-run to per-directory
  *
  * The filter used to sit in `condense.ts::_scoped_rule_basenames()`, which runs
- * once per generation, so `partitionActive` — a claude-only fingerprint against
+ * once per generation, so the then-current `partitionActive` — a claude-only fingerprint against
  * `installed.lock` — decided for every host at once. That contradicted
  * `partitionEligibility.ts`'s own fail-safe reasoning, which refuses to withhold a
  * cursor artefact on claude's evidence because it "would deliver it nowhere", and
@@ -32,7 +32,7 @@
  * Four call sites consume it — the symlink emit plan, the cursor `.mdc` emitter,
  * the windsurf emitter, the augment projector — and four sites deciding this
  * separately is exactly how three of them came to disagree. It is in `src/install/`
- * beside {@link partitionActive} and {@link hostLayerCarries}, the two predicates
+ * beside {@link hostLayerCarries}, the predicate
  * it composes, rather than in the 2,700-line generator that calls it.
  *
  * ## The classification source is the PROJECTION, not the authored tree
@@ -48,7 +48,7 @@ import * as fs from 'node:fs';
 import * as os from 'node:os';
 import * as path from 'node:path';
 
-import { isExclusivelyPackageOnly, partitionActive } from './partitionEligibility.js';
+import { isExclusivelyPackageOnly } from './partitionEligibility.js';
 import { hostLayerCarries, toolIdForProjectRuleDir } from './globalRuleLayers.js';
 
 export interface PartitionRulesOptions {
@@ -56,28 +56,21 @@ export interface PartitionRulesOptions {
     readonly toolDir: string;
     /** Candidate rule basenames, already scope- and manual-filtered. */
     readonly rules: readonly string[];
-    /** Absolute project root — what `partitionActive` verifies against. */
+    /**
+     * Absolute project root.
+     *
+     * Retained after the 2026-09-07 change removed the only reader that needed
+     * it (`partitionActive`, which verified it against `installed.lock`). It
+     * stays because every call site already passes it and because a rule
+     * partition that cannot name the tree it is partitioning is harder to debug,
+     * not because a branch below reads it. Stated rather than quietly dropped.
+     */
     readonly projectRoot: string;
     /** Absolute directory the basenames resolve against for classification. */
     readonly rulesSource: string;
     readonly userHome?: string;
     /** Where the kept-full notice goes. Silent when omitted. */
     readonly announce?: (message: string) => void;
-    /**
-     * Override the partition-active decision instead of reading `installed.lock`.
-     *
-     * Split out for the reason `partitionEligibility.ts` states about its own
-     * `personaWithheldFor`: "so the decision is testable in BOTH directions". A
-     * test over the un-injected path can only assert whatever the machine happens
-     * to be — and this one bit differs between a maintainer checkout (installed,
-     * so active) and CI (nothing installed, so inactive), which made the first
-     * version of `rule_partition_per_host.test.ts` green locally and red on every
-     * CI shard. That is the environment-dependent gate this whole change exists to
-     * remove, reproduced in its own test suite.
-     *
-     * Production callers omit it.
-     */
-    readonly active?: boolean;
 }
 
 /**
@@ -90,10 +83,13 @@ export interface PartitionRulesOptions {
  */
 export function partitionRulesForDir(opts: PartitionRulesOptions): string[] {
     const { toolDir, rules, projectRoot, rulesSource } = opts;
-    const active = opts.active ?? partitionActive(projectRoot);
-    if (!active) {
-        return [...rules];
-    }
+    void projectRoot;
+    // There is no repo-wide gate above this any more (owner decision, 2026-09-07).
+    // `partitionActive` used to run first and veto every directory on one
+    // claude-only version-and-fingerprint check against `installed.lock` — the
+    // exact borrowed-evidence extrapolation this module's own header refuses. The
+    // per-directory evidence below was always the stronger test; it is now the
+    // only one.
     const toolId = toolIdForProjectRuleDir(toolDir);
     if (toolId === null) {
         // An unmapped directory has no global layer this code can point at, so

package/src/scripts/_cli/cmd_session_recycle.ts

@@ -33,8 +33,8 @@ import { fileURLToPath, pathToFileURL } from 'node:url';
 import { ORIGIN_CWD_FALLBACK, resolve_project_root } from '../_lib/agent_settings.js';
 import {
     RECYCLE_ENVELOPE_MAX_BYTES,
-    recycle_consumed_rel,
     recycle_envelope_rel,
+    resolvePredecessor,
 } from '../_lib/recycle_envelope_paths.js';
 import {
     CAPSULE_SCHEMA_VERSION,
@@ -84,30 +84,7 @@ export function templateEnvelope(): Record<string, unknown> {
     };
 }
 
-/**
- * Which session this one continues — read, never composed.
- *
- * The chain is derivable without any new artifact: when this session started,
- * its reader consumed the predecessor's record and MOVED it to this session's
- * consumed path (`recycle_consumed_rel`). So the file sitting there is, by
- * construction, the record this session resumed from, and its `session_id` is
- * the predecessor.
- *
- * Returns the explicit string `none` when there is nothing there. `none` is a
- * CLAIM — "this session starts a chain" — and is deliberately not an empty
- * value: a reader must be able to tell "no predecessor" from "nobody wrote the
- * field", because only the second one is a reason to go looking.
- */
-export function resolvePredecessor(projectRoot: string, sessionId: string | null): string {
-    try {
-        const consumed = path.join(projectRoot, recycle_consumed_rel(sessionId));
-        const raw = JSON.parse(fs.readFileSync(consumed, 'utf-8')) as { session_id?: unknown };
-        const prior = String(raw.session_id ?? '').trim();
-        return prior === '' ? 'none' : prior;
-    } catch {
-        return 'none';
-    }
-}
+export { resolvePredecessor };
 
 interface ParsedArgv {
     ok: boolean;

package/src/scripts/_cli/handoff_sessions.ts

@@ -32,7 +32,13 @@ import * as path from 'node:path';
 
 import { projectStoreSlug } from '../_lib/cc_transcript.js';
 import { derive_session_tag, list_sessions, read_entries } from '../chat_history.js';
-import { eolSessionKey, readEolCounters, type StoredEolCounters } from '../_lib/session_eol.js';
+import {
+    eolSessionKey,
+    is_substantive,
+    readEolCounters,
+    type StoredEolCounters,
+    SUBSTANTIVE_TOKEN_FLOOR,
+} from '../_lib/session_eol.js';
 
 export const DEFAULT_CAP = 15;
 /**
@@ -42,24 +48,16 @@ export const DEFAULT_CAP = 15;
  * on the observed store 10 of 217 sessions are filtered (~5%), so 3× covers
  * that comfortably while keeping the per-file scan bounded.
  */
+/**
+ * Re-exported from `_lib/session_eol.ts`, where both now live so the Stop-path
+ * hook can reach them without importing this CLI module. Kept exported HERE
+ * because the resume picker is the surface every existing importer names.
+ */
+export { is_substantive, SUBSTANTIVE_TOKEN_FLOOR };
+
 const FETCH_OVERSHOOT = 3;
 const SUMMARY_SNIPPET_CHARS = 120;
 
-/**
- * Committed substantive-content floor, in parsed transcript tokens (billable
- * input of the last main-chain assistant record, per `cc_transcript.ts`) — the
- * OR-arm for a session that produced real discussion without ever calling a
- * tool.
- *
- * Derivation (`agents/evidence/analysis/handoff-substantive-threshold.md`,
- * 217 sessions of the local Claude store, 2026-08-10): 206 of the 207 sessions
- * carrying an assistant record also carry a `tool_use` block, so this arm
- * serves the ~0.5 % tail and the hosts whose transcripts log no tool blocks at
- * all. 10 000 sits **25× below** the p10 of real working sessions (254 939),
- * so it cannot hide one, and above a single trivial exchange. Changing it is a
- * PR citing evidence, never a drive-by edit.
- */
-export const SUBSTANTIVE_TOKEN_FLOOR = 10_000;
 
 export type HandoffSource = 'chat-history' | 'claude-transcript' | 'codex-session';
 
@@ -454,34 +452,6 @@ function _sort_key(s: HandoffSession): string {
     return s.endedAt ?? s.startedAt ?? '';
 }
 
-/**
- * Does this session hold anything worth resuming?
- *
- * `≥ 1 assistant turn AND (≥ 1 tool call OR parsed tokens ≥ the committed
- * floor)`, read from the counts-only session-eol state.
- *
- * **Fail-open, deliberately** (Phase 1.2): absent, unreadable or mis-shaped
- * state LISTS the candidate rather than filtering it, and a `tool_calls` key
- * missing from a state file written before that counter existed reads as
- * *unknown*, never as zero. A wrongly listed candidate is noise the user
- * scrolls past; a wrongly hidden one is data loss they cannot even see.
- */
-export function is_substantive(counters: StoredEolCounters | null): boolean {
-    if (counters === null) return true;
-    // Every "unknown" below is a NUMBER test, not an `=== undefined` test.
-    // Absent, null and NaN are all unknown, and each one reaches this code by
-    // a real path: a state file written before the counter existed is absent,
-    // `JSON.stringify` turns NaN into null on the way to disk, and a
-    // half-written file yields a parseable object with missing keys. Reading
-    // any of them as "counted zero" hides a session that did real work.
-    if (!Number.isFinite(counters.assistant_records)) return true;
-    if ((counters.assistant_records as number) < 1) return false;
-    if (!Number.isFinite(counters.tool_calls)) return true;
-    if ((counters.tool_calls as number) >= 1) return true;
-    if (!Number.isFinite(counters.final_context_tokens)) return true;
-    return (counters.final_context_tokens as number) >= SUBSTANTIVE_TOKEN_FLOOR;
-}
-
 function _derive_tag(id: string): string | null {
     try {
         return derive_session_tag(id);

package/src/scripts/_dispatch.bash

@@ -463,8 +463,9 @@ print_version() {
 # dependency since the road-to-credible-install Phase 1 flip — the consumer
 # runtime tree ships no tsx, so every consumer-reachable surface must resolve
 # a precompiled bundle instead (hooks → dist/hooks/dispatch.js, mcp:run →
-# dist/mcp/server.mjs, the `_cli` delegate commands → dist/cli-delegate/,
-# see exec_ts below). This resolver therefore only ever fires in a DEV tree
+# dist/mcp/server.mjs, the `_cli` AND `dist/agent-src/scripts/` delegate
+# commands → dist/cli-delegate/, see exec_ts below). This resolver therefore
+# only ever fires in a DEV tree
 # (node_modules/.bin/tsx present) or as a genuine last-resort fallback.
 # `npx tsx` is that last resort: npx runs against the CONSUMER project's cwd,
 # so its npm config and devEngines/engines constraints apply — a consumer
@@ -495,14 +496,23 @@ require_tsx() {
   exit 127
 }
 
-# Map a `src/scripts/_cli/<name>.ts` path to its precompiled bundle entry
-# under `dist/cli-delegate/<name>.js`, echoing the bundle path when it exists
-# and node is available. Empty output means "no bundle — use the tsx path".
+# Map a delegate source path to its precompiled bundle entry under
+# `dist/cli-delegate/<name>.js`, echoing the bundle path when it exists and node
+# is available. Empty output means "no bundle — use the tsx path".
 #
-# Scoped to `_cli/` on purpose: that directory is the consumer-tier delegate
-# command surface (`sync`, `doctor`, `validate`, `upgrade`, …) and its
-# basenames are unique, so the mapping is collision-free. Other exec_ts
-# callers (resolve_script results, the work engine, …) are unaffected.
+# TWO source roots are mapped, both bundled into that one outdir:
+#   - `src/scripts/_cli/` — the consumer-tier delegate commands (`sync`,
+#     `doctor`, `validate`, `upgrade`, …), per ADR-204.
+#   - `dist/agent-src/scripts/` — the roadmap command family (`roadmap:progress`,
+#     `roadmap:set-step`, `roadmap:archive`, `roadmap:gates`, `stubs:due`).
+#     ADR-204 closed the `npx tsx` exposure for `_cli/` and left this root on it:
+#     these commands still reached `require_tsx`, and `npx` resolves against the
+#     CONSUMER's cwd, so a project pinning `devEngines.runtime` away from the
+#     local Node hard-failed with EBADDEVENGINES.
+#
+# Basenames are unique ACROSS both roots (`_cli/` is all `cmd_*`, agent-src is
+# none), so one flat outdir stays collision-free. Other exec_ts callers (the
+# remaining resolve_script results, the work engine, …) are unaffected.
 #
 # In a DEV tree the bundle is also suppressed when any `src/**/*.ts` is newer
 # than it — see cli_delegate_bundle_is_stale.
@@ -510,6 +520,7 @@ cli_delegate_bundle() {
   local ts_abs="$1"
   case "$ts_abs" in
     "$PACKAGE_ROOT/src/scripts/_cli/"*) ;;
+    "$PACKAGE_ROOT/dist/agent-src/scripts/"*) ;;
     *) return 0 ;;
   esac
   local name
@@ -540,12 +551,40 @@ cli_delegate_bundle() {
 # edit is never silently ignored in favour of a stale compile.
 cli_delegate_bundle_is_stale() {
   local bundle="$1"
+  # The dev-tree test is package-local tsx, NOT `-d src`. The published tarball
+  # SHIPS `src/` (files[] carries `src/scripts/` and `src/agent-src/scripts/`),
+  # so the `-d src` test called every consumer install a dev tree — and npm's
+  # extraction leaves shipped sources newer than the prepack-built bundle.
+  # Measured 2026-09-07 on a global 14.21.0 install: 1348 shipped `src/**/*.ts`
+  # were newer than `dist/cli-delegate/cmd_versions.js`, so `cli_delegate_bundle`
+  # returned empty and `agent-config versions` fell through to `npx tsx` —
+  # ADR-204's fast path was inert in every published install, which is also why
+  # it never protected the roadmap family this change adds.
+  # Without a local tsx the only alternative to a "stale" bundle is `npx tsx`
+  # against the CONSUMER's npm config, which is strictly worse than a compile
+  # that may lag a source edit no consumer can make.
+  [[ -x "$PACKAGE_ROOT/node_modules/.bin/tsx" ]] || return 1
   [[ -d "$PACKAGE_ROOT/src" ]] || return 1
   local newer
   newer="$(find "$PACKAGE_ROOT/src" -name '*.ts' -newer "$bundle" -print -quit 2>/dev/null)"
   [[ -n "$newer" ]]
 }
 
+# Echo a usable `dist/cli-delegate/` bundle for a path RELATIVE to that dir, or
+# nothing. Used by the two probes that run on EVERY invocation — the pin
+# resolver and the update banner — which have their own soft tsx lookup rather
+# than going through exec_ts. Both reached `npx tsx` in a consumer install and
+# therefore printed the consumer's own npm failure (EBADDEVENGINES on a
+# mismatched `devEngines`) on stderr before every single command.
+delegate_aux_bundle() {
+  local rel="$1"
+  local bundle="$PACKAGE_ROOT/dist/cli-delegate/$rel"
+  [[ -f "$bundle" ]] || return 0
+  command -v node >/dev/null 2>&1 || return 0
+  cli_delegate_bundle_is_stale "$bundle" && return 0
+  printf '%s' "$bundle"
+}
+
 # Run an absolute script path. The argument is an absolute path that may carry
 # a `.py` (legacy) or `.ts` extension; we resolve the `.ts` twin.
 #
@@ -1622,20 +1661,28 @@ maybe_pin_reexec() {
     help|--help|-h|--version|-V|update|migrate|init|"") return 0 ;;
   esac
   # Best-effort: soft tsx probe (no hard-exit — this runs around dispatch).
-  local tsx_bin=""
-  if [[ -x "$PACKAGE_ROOT/node_modules/.bin/tsx" ]]; then
-    tsx_bin="$PACKAGE_ROOT/node_modules/.bin/tsx"
-  elif command -v npx >/dev/null 2>&1; then
-    tsx_bin="npx tsx"
+  local runner=""
+  local target=""
+  local aux
+  aux="$(delegate_aux_bundle '_lib/pin_resolver.js')"
+  if [[ -n "$aux" ]]; then
+    runner="node"
+    target="$aux"
+  elif [[ -x "$PACKAGE_ROOT/node_modules/.bin/tsx" ]]; then
+    runner="$PACKAGE_ROOT/node_modules/.bin/tsx"
+    target="$PACKAGE_ROOT/src/scripts/_lib/pin_resolver.ts"
   else
+    # Deliberately NO `npx tsx` last resort here: this probe runs before EVERY
+    # command, and npx resolves against the CONSUMER's cwd, so a project whose
+    # `devEngines` rejects the local Node made every invocation print npm's
+    # error. A missing runner means no pin re-exec, which is the same
+    # best-effort outcome the `|| true` below already accepts.
     return 0
   fi
   local installed
   installed="$(print_version)"
   [[ -z "$installed" || "$installed" == "unknown" ]] && return 0
-  # shellcheck disable=SC2086
-  $tsx_bin "$PACKAGE_ROOT/src/scripts/_lib/pin_resolver.ts" \
-    --cwd "$CONSUMER_ROOT" --installed "$installed" -- "$@" || true
+  "$runner" "$target" --cwd "$CONSUMER_ROOT" --installed "$installed" -- "$@" || true
 }
 
 # Post-subcommand banner: best-effort daily update-check notice on
@@ -1649,19 +1696,22 @@ run_update_check_banner() {
   case "$cmd" in
     help|--help|-h|--version|-V|"") return 0 ;;
   esac
-  # Best-effort: soft tsx probe (no hard-exit — banner is post-dispatch).
-  local tsx_bin=""
-  if [[ -x "$PACKAGE_ROOT/node_modules/.bin/tsx" ]]; then
-    tsx_bin="$PACKAGE_ROOT/node_modules/.bin/tsx"
-  elif command -v npx >/dev/null 2>&1; then
-    tsx_bin="npx tsx"
+  # Best-effort: bundle first, then a dev-tree tsx. No `npx tsx` last resort —
+  # same reason as maybe_pin_reexec: npx runs against the CONSUMER's npm config.
+  local runner=""
+  local target=""
+  local aux
+  aux="$(delegate_aux_bundle 'check_update_banner.js')"
+  if [[ -n "$aux" ]]; then
+    runner="node"
+    target="$aux"
+  elif [[ -x "$PACKAGE_ROOT/node_modules/.bin/tsx" && -f "$PACKAGE_ROOT/src/scripts/check_update_banner.ts" ]]; then
+    runner="$PACKAGE_ROOT/node_modules/.bin/tsx"
+    target="$PACKAGE_ROOT/src/scripts/check_update_banner.ts"
   else
     return 0
   fi
-  local banner_script="$PACKAGE_ROOT/src/scripts/check_update_banner.ts"
-  [[ -f "$banner_script" ]] || return 0
-  # shellcheck disable=SC2086
-  $tsx_bin "$banner_script" --cwd "$CONSUMER_ROOT" 2>/dev/null || true
+  "$runner" "$target" --cwd "$CONSUMER_ROOT" 2>/dev/null || true
 }
 
 # Global `--root <path>` / `--root=<path>` parsing (Step 8 A3).

package/src/scripts/_lib/auto_dispatch.ts

@@ -191,8 +191,8 @@ export function classifyLookup(
                 reason:
                     primitive === p.primitive
                         ? `lookup-class ${p.cls} — deterministic primitive, no spawn`
-                        : `lookup-class ${p.cls} — capped grep; the code-graph accelerant is ` +
-                          'gated on hooks.code_graph.enabled and it is not on',
+                        : `lookup-class ${p.cls} — capped grep; the code-graph accelerant needs a ` +
+                          'usable graph and the caller passed none',
             };
         }
     }

package/src/scripts/_lib/catalogue_layer_parity.ts

@@ -0,0 +1,146 @@
+/**
+ * Do the two lists that name `~/.claude/<family>` agree?
+ *
+ * **The defect this exists to make visible.**
+ *
+ * Two independently authored constants name the SAME directories and, until
+ * 2026-09-07, referenced each other nowhere:
+ *
+ *   - the DELIVERY side — `claudeLayerCarriage.CLAUDE_ARTEFACT_DIRS` and
+ *     `hostLayerFingerprint.hostLayerInputs` — which decides what the project
+ *     layer withholds because the host layer already carries it;
+ *   - the READER side — `skill_catalogue.DEFAULT_CATALOGUE_ROOTS` — which
+ *     decides which trees the skill ranker sees.
+ *
+ * `git grep` over the dependency sets of both returned two disjoint sets. So
+ * `~/.claude/skills` was a directory the delivery side treated as authoritative
+ * and the reader side did not read AT ALL — for as long as both existed, and
+ * with nothing anywhere that could notice.
+ *
+ * The cost was measured on 2026-09-07: the reader resolved ONE root and stopped,
+ * so `suggest_skill_for_task` and the `skill-route` concern ranked whichever
+ * single tree came first and reported it as if it were the catalogue. A consumer
+ * whose project carries its own skills while the shipped set sits in
+ * `~/.claude/skills` got an answer over half its catalogue, with no signal that
+ * it was half.
+ *
+ * **Why a comparison and not an instruction.**
+ *
+ * The reasoning failure behind it — repairing a mechanism's PARAMETER while
+ * inheriting its SHAPE — is model-carried and nothing can observe it. But the
+ * RESULT is two lists of strings, and two lists of strings can be compared. This
+ * module is that comparison, so the omission stops being a thing someone has to
+ * notice and becomes a thing that reds.
+ *
+ * **What it does NOT claim.**
+ *
+ * It compares the directories the two sides NAME. It does not establish that a
+ * reader ranks well, that a family needs a reader, or that the host actually
+ * loads any of it. A family with no reader is legal and common — it just has to
+ * SAY so, which is what {@link FAMILIES_WITHOUT_READER} is for.
+ */
+
+import { CLAUDE_ARTEFACT_DIRS, type ClaudeArtefactFamily } from '../../install/claudeLayerCarriage.js';
+import { hostLayerInputs } from '../../install/hostLayerFingerprint.js';
+import {
+    DEFAULT_CATALOGUE_ROOTS,
+    HOST_CATALOGUE_ROOT,
+    PROJECT_CATALOGUE_ROOTS,
+} from './skill_catalogue.js';
+
+/**
+ * Families the delivery side knows and NO reader resolves — each with the reason.
+ *
+ * An entry here is a declaration, not a suppression: a family absent from both
+ * this map and the reader coverage below is the omission this module reds on.
+ * Adding a reader later means deleting one line here.
+ */
+export const FAMILIES_WITHOUT_READER: Readonly<Partial<Record<ClaudeArtefactFamily, string>>> = {
+    personas: 'personas are selected by name from a catalog, never ranked over a tree',
+    commands: 'commands reach the host by path; no ranker reads the commands tree',
+};
+
+/** Family → the project- and host-relative roots a reader must cover. */
+const READER_COVERAGE: Readonly<Partial<Record<ClaudeArtefactFamily, () => string[]>>> = {
+    skills: () => [...PROJECT_CATALOGUE_ROOTS, `~/${HOST_CATALOGUE_ROOT}`],
+};
+
+/** One disagreement between the two sides. */
+export interface ParityFinding {
+    readonly family: string;
+    readonly reason: string;
+}
+
+/**
+ * Every disagreement, or an empty array.
+ *
+ * Total function, no I/O: it reads constants, so the verdict is the same on every
+ * machine — which is the point. The reader lists are injectable so the polarity
+ * of each branch is testable without editing a production constant.
+ */
+export function catalogueLayerParity(
+    deliveryDirs: Readonly<Record<string, string>> = CLAUDE_ARTEFACT_DIRS,
+    coverage: Readonly<Record<string, () => string[]>> = READER_COVERAGE as Readonly<
+        Record<string, () => string[]>
+    >,
+    withoutReader: Readonly<Record<string, string>> = FAMILIES_WITHOUT_READER as Readonly<
+        Record<string, string>
+    >,
+): ParityFinding[] {
+    const findings: ParityFinding[] = [];
+    for (const [family, projectDir] of Object.entries(deliveryDirs)) {
+        const cover = coverage[family];
+        if (cover === undefined) {
+            if (withoutReader[family] === undefined) {
+                findings.push({
+                    family,
+                    reason:
+                        `the delivery side treats \`${projectDir}\` as an artefact source, but no ` +
+                        'reader covers it and no reason is declared in FAMILIES_WITHOUT_READER',
+                });
+            }
+            continue;
+        }
+        const roots = cover();
+        // The PROJECT-relative directory the delivery side names must be a root.
+        if (!roots.includes(projectDir)) {
+            findings.push({
+                family,
+                reason: `the reader does not read \`${projectDir}\`, which the delivery side names`,
+            });
+        }
+        // And so must the HOST-relative twin — the leg that was missing entirely.
+        const hostForm = `~/${projectDir.replace(/^\.claude\//u, '.claude/')}`;
+        if (!roots.includes(hostForm)) {
+            findings.push({
+                family,
+                reason: `the reader does not read \`${hostForm}\`, the host layer the partition withholds against`,
+            });
+        }
+    }
+    return findings;
+}
+
+/**
+ * The three constants that must name the same `~/.claude/skills`.
+ *
+ * `hostLayerInputs` is the third author of that path — the fingerprint side —
+ * and it is included because a rename there would silently un-verify the layer
+ * the reader reads. Returns the resolved absolute paths for one home so a caller
+ * can compare them directly.
+ */
+export function hostSkillsDirTriple(home: string): {
+    readonly fingerprint: string | null;
+    readonly delivery: string;
+    readonly reader: string;
+} {
+    const fp = hostLayerInputs(home).find((l) => l.label === 'skills');
+    return {
+        fingerprint: fp?.root ?? null,
+        delivery: `${home}/${CLAUDE_ARTEFACT_DIRS.skills}`,
+        reader: `${home}/${HOST_CATALOGUE_ROOT}`,
+    };
+}
+
+/** For the test's own message, and to prove the list is read rather than assumed. */
+export const READER_ROOT_LABELS: readonly string[] = [...DEFAULT_CATALOGUE_ROOTS];