@event4u/agent-config 14.1.0 → 14.2.0

package/.claude-plugin/marketplace.json

@@ -6,7 +6,7 @@
   },
   "metadata": {
     "description": "Bootstrap shim for the event4u agent-config suite. This plugin ships ONLY the dispatcher hooks plus one install-pointer skill — ALL content (skills, rules, commands) is installed via `npx -y @event4u/agent-config init`, which writes the file projection AND registers the same hooks in ~/.claude/settings.json. DEPRECATED as a content channel; kept so the marketplace listing stays discoverable and existing installs keep working hooks.",
-    "version": "14.1.0",
+    "version": "14.2.0",
     "keywords": [
       "agent-config",
       "skills",

package/CHANGELOG.md

@@ -366,6 +366,48 @@ Entry-shape contract: [`docs/contracts/CHANGELOG-conventions.md`](docs/contracts
 > that forces a new era split (`# Era: 14.1.x`, etc.) — see
 > [`docs/contracts/CHANGELOG-conventions.md § Era splits`](docs/contracts/CHANGELOG-conventions.md).
 
+## [14.2.0](https://github.com/event4u-app/agent-config/compare/14.1.0...14.2.0) (2026-08-18)
+
+### Release highlights
+
+<!-- Curated head: fill before merge, keep it under 10 lines, and leave `_none_` where it is genuinely the answer. The generated log below is unchanged. -->
+- **Behaviour changes:** _none_
+- **Default changes + migration:** _none_
+- **Security and correctness:** _auto-derived, rewrite before merge:_ security-scoped commits or fixes to executable surface in 61fdf7d, 604632b, c41b89a, 42e8955, cc19737, bbb60a8.
+- **Honest nulls:** _none_
+- **Known limitations:** _none_
+
+### Features
+
+* **hooks:** stop skill-route pointing at skills the host delivered bare ([508bba9](https://github.com/event4u-app/agent-config/commit/508bba908e074c1c69dc1b36ef2dd679b9e9f1ba))
+* **catalogue:** add the delivery reducer the runtime router was missing ([1b65432](https://github.com/event4u-app/agent-config/commit/1b65432d719094b148bc4e30cf328d3e80b3c597))
+
+### Bug Fixes
+
+* **r2:** report the extraction, not the roadmap, and stop truncating criteria ([61fdf7d](https://github.com/event4u-app/agent-config/commit/61fdf7d26f1d9eb634c02451621c573784216bbe))
+* **r2:** read inline acceptance criteria, stop faking an empty extraction ([604632b](https://github.com/event4u-app/agent-config/commit/604632b3c991933fb354e3afb50423697489d692))
+* **metrics:** name the suppression denominator and register the invisible case ([03fe473](https://github.com/event4u-app/agent-config/commit/03fe4732dabab6b267a8dc1706b4da2a72a74a6d))
+* **hooks:** count suppression over the pointer window and pin the envelope wiring ([c41b89a](https://github.com/event4u-app/agent-config/commit/c41b89a1cb21eac3f5e651c4271bd91811a3d66c))
+* **catalogue:** let the LATEST record decide the bare set, not the mode filter ([42e8955](https://github.com/event4u-app/agent-config/commit/42e8955148a78314adc3f13cf695ed82e2fe0086))
+* **hooks:** let a delete-only push skip the content gates ([cc19737](https://github.com/event4u-app/agent-config/commit/cc197371a66a7b1ee7ddb05ea1a505193434d2b8))
+* **ci:** serialize the two publish triggers on the version, not the ref ([bbb60a8](https://github.com/event4u-app/agent-config/commit/bbb60a895b650b1d1e7ce91b49f5ddd025cf00a9))
+
+### Documentation
+
+* **review:** close all six R2 findings and re-bind the artefact ([fe639e5](https://github.com/event4u-app/agent-config/commit/fe639e548109892724b15f4f299132d77658d745))
+* **review:** record the R2 findings for the inline-AC fix, all rows open ([5dc1298](https://github.com/event4u-app/agent-config/commit/5dc1298bbc82d3fc7bcd9fe776c56b0be3ce4cd6))
+* **review:** re-bind the R2 artefact after the fix pass ([a4b320c](https://github.com/event4u-app/agent-config/commit/a4b320cf371b0828d49799948b0bed94eee6e970))
+* **roadmap:** un-checkbox AC-3, make its verify runnable, record what R2 found ([0720e1d](https://github.com/event4u-app/agent-config/commit/0720e1d434bf658dd668bef64ca742897f72594d))
+* **review:** bind the R2 completion review for catalogue-host-fit Phase 3 ([1e7b2fd](https://github.com/event4u-app/agent-config/commit/1e7b2fde7ff752f45f907187b61f8f83902a0e75))
+* **roadmap:** close catalogue-host-fit Phase 3 and record what its fixture found ([852a8c4](https://github.com/event4u-app/agent-config/commit/852a8c4dbe3a8c9d0b52e7a229460a4d2752d0d3))
+* **release:** stop promising an approval checkpoint that does not fire ([7327d2e](https://github.com/event4u-app/agent-config/commit/7327d2ea4aec42e290f951572f972b0f441e563e))
+
+### Chores
+
+* **metrics:** register the bare-suppression rate beside the pointer rate ([707f332](https://github.com/event4u-app/agent-config/commit/707f332a0af8f5d81ff7bf6b73aa46006776422c))
+
+Tests: 14629 (+37 since 14.1.0)
+
 ## [14.1.0](https://github.com/event4u-app/agent-config/compare/14.0.0...14.1.0) (2026-08-18)
 
 ### Release highlights

package/dist/agent-src/templates/agents/agent-project-settings.example.yml

@@ -39,7 +39,7 @@ schema_version: 1
 # CI guard: a release bump of `package.json` must update this value
 # in lockstep — see scripts/check_template_pin_drift.ts (road-to-
 # portable-runtime-and-update-check P3.3).
-agent_config_version: "14.1.0"
+agent_config_version: "14.2.0"
 
 # --- Project identity ---
 project:

package/dist/discovery/deprecation-report.md

@@ -1,6 +1,6 @@
 # Discovery — Deprecation Report
 
-- Generated: `2026-08-18T12:03:29Z`
+- Generated: `2026-08-18T16:49:04Z`
 - Deprecated artefacts: **0**
 
 _None. Tree is clean._

package/dist/discovery/discovery-manifest.json

@@ -14578,7 +14578,7 @@
       "reason": "scaffold template for ticket-bundle tickets (ADR-101); carries no runtime frontmatter — emit-tickets fills it in per ticket"
     }
   ],
-  "generated_at": "2026-08-18T12:03:29Z",
+  "generated_at": "2026-08-18T16:49:04Z",
   "packs": [
     {
       "artefact_count": 118,

package/dist/discovery/discovery-manifest.json.sha256

@@ -1 +1 @@
-c20518e62eeec14688645cf600074ae569563d32a4188ce8ce00d9d022a4631d  discovery-manifest.json
+68f3e14e4cfaf98bb9cbfee5bf5da3cf62a28c74bfb9d0450e6f01cd3c0c4bc0  discovery-manifest.json

package/dist/discovery/discovery-manifest.summary.md

@@ -1,6 +1,6 @@
 # Discovery Manifest — Summary
 
-- Generated: `2026-08-18T12:03:29Z`
+- Generated: `2026-08-18T16:49:04Z`
 - Scanner: `de0a22b4ac4c`
 - Artefacts: **609**
 - Unassigned: **0**

package/dist/discovery/dormancy-report.md

@@ -1,6 +1,6 @@
 # Discovery — Dormancy Report
 
-- Generated: `2026-08-18T12:03:29Z`
+- Generated: `2026-08-18T16:49:04Z`
 - Window: **6 months** without a commit
 
 > Dormancy triggers **review, never auto-deprecation**

package/dist/discovery/orphan-report.md

@@ -1,6 +1,6 @@
 # Discovery — Orphan Report
 
-- Generated: `2026-08-18T12:03:29Z`
+- Generated: `2026-08-18T16:49:04Z`
 - Orphan artefacts: **0**
 
 > An orphan is an artefact whose declared pack has no other members.

package/dist/discovery/packs.json

@@ -1,6 +1,6 @@
 {
   "checksum": "sha256:3d01d440e67f335028a06d9a4609a7e6f885f829cec1eff42914a3e1690cfdeb",
-  "generated_at": "2026-08-18T12:03:29Z",
+  "generated_at": "2026-08-18T16:49:04Z",
   "packs": [
     {
       "always_on": false,

package/dist/discovery/trust-report.md

@@ -1,6 +1,6 @@
 # Discovery — Trust Report
 
-- Generated: `2026-08-18T12:03:29Z`
+- Generated: `2026-08-18T16:49:04Z`
 - Workspaces tracked: **10**
 - Human-review-required artefacts: **3**
 

package/dist/discovery/workspaces.json

@@ -1,6 +1,6 @@
 {
   "checksum": "sha256:3d01d440e67f335028a06d9a4609a7e6f885f829cec1eff42914a3e1690cfdeb",
-  "generated_at": "2026-08-18T12:03:29Z",
+  "generated_at": "2026-08-18T16:49:04Z",
   "scanner_version": "de0a22b4ac4c",
   "workspaces": [
     {

package/dist/hooks/dispatch.js

@@ -27491,6 +27491,51 @@ var OBSERVATION_LOG = path66.join(
   "metrics",
   "skill-catalogue.jsonl"
 );
+function truncationModeOf(record) {
+  return record.truncation_mode ?? "per-entry";
+}
+function _supersedes(candidate, incumbent) {
+  if (candidate.observed_at !== incumbent.observed_at) {
+    return candidate.observed_at > incumbent.observed_at;
+  }
+  return (candidate.dropped_count ?? 0) > (incumbent.dropped_count ?? 0);
+}
+function headlineRecordPerHost(records) {
+  const out = /* @__PURE__ */ new Map();
+  for (const record of records) {
+    const previous = out.get(record.host);
+    if (previous === void 0 || _supersedes(record, previous)) {
+      out.set(record.host, record);
+    }
+  }
+  return out;
+}
+function readObservationLog(logPath) {
+  if (!fs65.existsSync(logPath)) return [];
+  const out = [];
+  for (const line of fs65.readFileSync(logPath, "utf-8").split("\n")) {
+    const trimmed = line.trim();
+    if (trimmed.length === 0) continue;
+    try {
+      out.push(JSON.parse(trimmed));
+    } catch {
+      continue;
+    }
+  }
+  return out;
+}
+
+// src/scripts/_lib/skill_catalogue_series.ts
+function knownBareNames(records, host) {
+  const dated = records.filter(
+    (record) => record.host === host && typeof record.observed_at === "string"
+  );
+  const latest = headlineRecordPerHost(dated).get(host);
+  if (latest === void 0) return null;
+  if (truncationModeOf(latest) !== "per-entry") return null;
+  if (!Array.isArray(latest.bare_names)) return null;
+  return new Set(latest.bare_names.filter((name) => typeof name === "string"));
+}
 
 // src/scripts/skill_tools/score_skill_relevance.ts
 import * as fs66 from "node:fs";
@@ -27978,22 +28023,45 @@ var TOP_K = 3;
 function _isObject15(v) {
   return typeof v === "object" && v !== null && !Array.isArray(v);
 }
-function routePointers(prompt, skillsDir) {
-  if (skillsDir === null) return [];
+function knownBareForHost(workspaceRoot2, host) {
+  if (host === null || host === "") return null;
   try {
-    if (_tokenize(prompt).size < MIN_TASK_TERMS) return [];
+    return knownBareNames(readObservationLog(path68.join(workspaceRoot2, OBSERVATION_LOG)), host);
   } catch {
-    return [];
+    return null;
+  }
+}
+function filterKnownBare(rows, bare) {
+  if (bare === null || bare.size === 0) return [...rows];
+  return rows.filter(([name]) => !bare.has(name));
+}
+function routeDecision(prompt, skillsDir, bareProvider) {
+  const silent = { rows: [], suppressed: 0 };
+  if (skillsDir === null) return silent;
+  try {
+    if (_tokenize(prompt).size < MIN_TASK_TERMS) return silent;
+  } catch {
+    return silent;
   }
   let rows;
   try {
     rows = rank(prompt, skillsDir);
   } catch {
-    return [];
+    return silent;
+  }
+  let bare = null;
+  if (bareProvider !== void 0) {
+    try {
+      bare = bareProvider();
+    } catch {
+      bare = null;
+    }
   }
-  const top = rows[0];
-  if (top === void 0 || top[1] < MIN_TOP_SCORE) return [];
-  return rows.slice(0, TOP_K);
+  const deliverable = filterKnownBare(rows, bare);
+  const suppressed = bare === null ? 0 : rows.slice(0, TOP_K).filter(([name]) => bare.has(name)).length;
+  const top = deliverable[0];
+  if (top === void 0 || top[1] < MIN_TOP_SCORE) return { rows: [], suppressed };
+  return { rows: deliverable.slice(0, TOP_K), suppressed };
 }
 function buildRouteLine(rows) {
   const pointers = rows.map(([name, score]) => `${name} (${score})`).join(", ");
@@ -28026,12 +28094,21 @@ function main43() {
   const prompt = _extractPrompt3(payload);
   if (!prompt) return EXIT_ALLOW18;
   if (isSyntheticPrompt(prompt)) return EXIT_ALLOW18;
-  const rows = routePointers(prompt, resolveSkillsRoot(_workspaceRoot4(env)));
+  const root = _workspaceRoot4(env);
+  const platform = env["platform"];
+  const host = typeof platform === "string" && platform ? platform : null;
+  const { rows, suppressed } = routeDecision(
+    prompt,
+    resolveSkillsRoot(root),
+    () => knownBareForHost(root, host)
+  );
   if (rows.length === 0) return EXIT_ALLOW18;
   process.stdout.write(
     `${JSON.stringify({
       decision: "warn",
-      reason: `skill-route: ${rows.length} pointer(s), top ${rows[0][1]}/100`,
+      reason: `skill-route: ${rows.length} pointer(s), top ${rows[0][1]}/100` + // The suppression metric's numerator. Named only when non-zero, so the
+      // common line keeps its shape and its registered byte budget.
+      (suppressed > 0 ? `, ${suppressed} suppressed as host-bare` : ""),
       additional_context: buildRouteLine(rows)
     })}
 `

package/dist/mcp/registry-manifest.json

@@ -9,7 +9,7 @@
     "homepage": "https://event4u-app.github.io/agent-config",
     "name": "@event4u/agent-config",
     "repository": "https://github.com/event4u-app/agent-config",
-    "version": "14.1.0"
+    "version": "14.2.0"
   },
   "registries": [
     {

package/dist/mcp/server.json

@@ -9,12 +9,12 @@
       "transport": {
         "type": "stdio"
       },
-      "version": "14.1.0"
+      "version": "14.2.0"
     }
   ],
   "repository": {
     "source": "github",
     "url": "https://github.com/event4u-app/agent-config"
   },
-  "version": "14.1.0"
+  "version": "14.2.0"
 }

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "@event4u/agent-config",
     "mcpName": "io.github.event4u-app/agent-config",
-    "version": "14.1.0",
+    "version": "14.2.0",
     "description": "Governed skills, rules and commands for AI coding tools (Claude Code, Cursor, Windsurf, Copilot) — every claim machine-checked, including \"zero runtime daemon\".",
     "license": "MIT",
     "private": false,

package/src/config/hook-token-budget.json

@@ -56,6 +56,12 @@
             "instrument": "rule-trips.json warn counters for the skill-route concern (fires) + conformance audits for whether the pointed-at skill was opened (adoption); HONEST GAP: no deterministic counter exists for 'the agent acted on the pointer' - the numerator is audit-carried and registered as such rather than implied to be automatic",
             "threshold": "none committed before data - baseline first, threshold at review date (2026-11-10)"
         },
+        "skill_route_bare_suppression_rate": {
+            "definition": "road-to-catalogue-host-fit Phase 3 step 3.2: of the prompts where skill-route FIRES, the share whose warn reason carries `N suppressed as host-bare` - i.e. how often a skill the ranker wanted to POINT AT is one the current host is KNOWN to have delivered without its description. `N` counts the pointer window (TOP_K of the unfiltered ranking), never the whole ranked list: `rank` returns every non-zero-scoring skill, so counting the tail would let a bare name at rank 40 - never pointable, never a loss - bump the count on nearly every fire (R2 finding 1). Registered beside skill_route_pointer_rate because it measures the same concern's behaviour under the same owner and review date. NO THRESHOLD IS COMMITTED, and the refusal is inherited from the sibling rather than restated: the FILTER is derived from a measurement (all 16 bare entries in the 2026-08-12 claude observation are in the ranker's catalogue, `capture_skill_catalogue --pointable-bare`), the OUTCOME - whether suppressing them changes what the agent does - is not.",
+            "instrument": "the dispatcher's warn reason string for the skill-route concern (`, N suppressed as host-bare`, appended only when non-zero) + agents/evidence/metrics/skill-catalogue.jsonl for the population; TWO HONEST GAPS, both registered as gaps rather than implied to be automatic. (1) rule-trips.json counts fires per concern and does NOT retain the reason, so the numerator is log-carried, not counter-carried - the same posture the sibling metric takes for its own audit-carried numerator. (2) TOTAL suppression is INVISIBLE here by construction (R2 finding 4): when the filter empties the pointer set the concern returns before writing stdout, so no reason line exists for the one case the roadmap calls load-bearing. `RouteDecision.suppressed` carries it at the API boundary and nothing reads that in production.",
+            "threshold": "none committed before data - baseline first, threshold at the shared review date (2026-11-10)",
+            "falsifiers": "For the FILTER half only, never for the outcome. UPPER: a live rate far above the share of the pointer window the host degrades means the ranker preferentially ranks exactly what the host drops - a finding about the projection, which belongs to Phase 2. Name the populations rather than a bare ratio, because three different denominators are in play and an earlier draft of this row conflated them (R2 finding 11): the 2026-08-12 claude observation carries `entries_total` 336, of which only 35 were enumerated at all (16 bare + 19 described), against a ranker catalogue of 338 entries at probe time. The comparable share is 16 of the 35 ENUMERATED entries; 16/336 and 16/338 describe different things and neither is this metric's denominator. LOWER: a rate of 0 does NOT establish that the ranker and the host's bare set fail to intersect - gap (2) above makes complete suppression indistinguishable from no suppression in this instrument. `capture_skill_catalogue --pointable-bare` is the instrument that separates them, and it must be read before any zero here is interpreted."
+        },
         "full_rewrite_small_diff_rate": {
             "definition": "edit-shape fires / Write calls per session (the full-rewrite-with-small-diff rate). Kill criterion per the shipped nudge standard: a nudge whose verdicts are measurably ignored (adoption near zero over the review window, from conformance audits) gets its trigger tightened or the injected line removed.",
             "instrument": "rule-trips.json warn counters (the dispatcher already counts every warn per concern) + conformance audits for adoption"

package/src/scripts/_lib/skill_catalogue_series.ts

@@ -409,3 +409,94 @@ export function formatPointableBare(
     }
     return lines.join('\n');
 }
+
+/* ------------------------------------------------------------------ *
+ * The delivery filter — what the runtime router must not name.
+ * ------------------------------------------------------------------ */
+
+/**
+ * The bare names one host is KNOWN to have delivered, or `null` when nothing
+ * about that host's per-entry delivery was ever enumerated.
+ *
+ * `joinPointableBare` above answers "how large is the D-4 divergence" for an
+ * operator report. This answers the runtime question the same log can settle:
+ * given this host, which skill names must a pointer line not name? It is the
+ * reducer `skill_route_hook` consumes, and it lives here rather than in that
+ * hook for one reason — every guard below is already argued in this module's
+ * prose, and a second reducer over the same log is how two readers start
+ * breaking the same tie in opposite directions (`_supersedes`, in the parent
+ * module, exists because that happened once and printed two drop counts for one
+ * host on one day).
+ *
+ * THE THREE-WAY DISTINCTION IS THE WHOLE POINT, and collapsing any two of them
+ * is the failure:
+ *
+ *   - **`null` — nothing was enumerated.** No record for this host, or none of
+ *     its records is a `per-entry` observation, or the latest one carries no
+ *     `bare_names` array. The consumer must fail OPEN: filtering on this would
+ *     be a zero inferred from silence, and a filter that quietly narrows on
+ *     missing data is worse than the divergence it treats.
+ *   - **An EMPTY set — enumerated, and nothing was bare.** A legitimate answer,
+ *     and behaviourally identical to `null` at today's only consumer. It is
+ *     still returned distinctly, because "measured clean" and "never measured"
+ *     are different facts and this module refuses to let them look alike.
+ *   - **A NON-EMPTY set — these names went dark.** The pointer must not name
+ *     them.
+ *
+ * A `budget-strip-and-drop` host is therefore always `null` here, never an
+ * empty set: it publishes no per-entry list at all, so its empty `bare_names`
+ * records that nothing was counted. That is the same skip `joinPointableBare`
+ * makes, for the same reason, and it is why a codex install gets no filtering
+ * rather than a filter that believes nothing was degraded.
+ *
+ * LATEST WINS, per host, by `observed_at` — the `latestPointableBarePerHost`
+ * tie-break rather than a union across the series. A union would let a
+ * superseded observation keep suppressing a skill the host now delivers fine,
+ * which is a filter that only ever narrows; the whole series is available to an
+ * operator report, and a runtime filter wants the current reading.
+ *
+ * `bare_names` is guarded with `Array.isArray`, and `observed_at` with a
+ * `typeof` check, because `readObservationLog` produces records by an unchecked
+ * `JSON.parse … as` over an append-only log with more than one producer — the
+ * same guard, for the same recorded reason, that `joinPointableBare` and
+ * `knownHostLimits` carry. Both guards resolve to `null`, never to an older
+ * reading: a malformed LATEST record means the current state is unknown, and
+ * falling back to a superseded one would be the stale-suppression failure this
+ * function's own tie-break exists to prevent.
+ */
+export function knownBareNames(
+    records: readonly ObservationRecord[],
+    host: string,
+): Set<string> | null {
+    // The latest record for the host decides, and the mode is read OFF that
+    // record rather than used to select it. R2 finding 2: filtering `per-entry`
+    // first meant a NEWER `budget-strip-and-drop` record could never supersede
+    // an older `per-entry` one, so a host that changed truncation mode kept
+    // being filtered against a bare set from before the change — the precise
+    // failure the LATEST-WINS paragraph above claims to prevent.
+    //
+    // `headlineRecordPerHost` rather than a fourth inline tie-break (R2 finding
+    // 7): this module already imports it, already defines
+    // `latestPointableBarePerHost`, and its own comment cites `_supersedes` as
+    // the reason duplicate reducers are dangerous. Restating the rule here would
+    // have meant the runtime filter silently not inheriting any precedence the
+    // parent adds later.
+    //
+    // The `observed_at` pre-filter is R2 finding 6, and it is a pre-filter
+    // rather than a change to `_supersedes` because that reducer is shared.
+    // `_supersedes` compares dates with `!==` then `>`, and BOTH
+    // `undefined > "2026-08-12"` and `"2026-08-12" > undefined` are false — so a
+    // record with a missing or non-string date, once it becomes the incumbent,
+    // can never be displaced by a well-formed later one. One malformed line in
+    // an append-only log with two producers would pin the filter to it forever.
+    // Feeding the shared reducer only well-dated records avoids that without
+    // changing behaviour for its other callers.
+    const dated = records.filter(
+        (record) => record.host === host && typeof record.observed_at === 'string',
+    );
+    const latest = headlineRecordPerHost(dated).get(host);
+    if (latest === undefined) return null;
+    if (truncationModeOf(latest) !== 'per-entry') return null;
+    if (!Array.isArray(latest.bare_names)) return null;
+    return new Set(latest.bare_names.filter((name): name is string => typeof name === 'string'));
+}

package/src/scripts/dispatch_r2_reviewer.ts

@@ -426,35 +426,170 @@ export function expectedHashes(args: {
     return {
         scope_hash: sha256(args.scopeDiffText),
         roadmap_hash: args.roadmapText == null ? 'none' : sha256(args.roadmapText),
-        ac_hash: args.acText == null ? 'none' : sha256(args.acText),
+        // ONE predicate, shared with the prompt builder. An empty extraction
+        // used to hash to e3b0c44298fc…b855 — the SHA-256 of the empty string,
+        // which looks like a real hash in the manifest and re-derives
+        // identically on `--verify-current`, so the gate confirmed a criteria
+        // set that was never there. `'none'` is the value that already means
+        // "no input" for `roadmap_hash`; an absent AC block gets the same word.
+        ac_hash: hasAcceptanceCriteria(args.acText) ? sha256(args.acText as string) : 'none',
     };
 }
 
 /**
- * Extract the `## Acceptance Criteria` section — from that heading (inclusive)
- * to the next `## ` heading or EOF. No section → empty string.
+ * Does an extraction carry acceptance criteria?
+ *
+ * The single predicate behind BOTH the manifest's `ac_hash` and the reviewer
+ * prompt's roadmap line. It exists because the first version of this fix encoded
+ * the same question twice — truthiness in {@link expectedHashes}, an explicit
+ * `!== null && !== ''` at the call site — and the two agreed only for as long as
+ * `''` stayed the sole reachable falsy value. Refining one alone (this `.trim()`,
+ * for instance) would then have made the manifest record a hash while the prompt
+ * told the reviewer there were no criteria: the same two-places-disagree failure
+ * this module was being repaired for, one level up. Caught by the R2 review of
+ * that very fix.
+ *
+ * Whitespace-only counts as absent. The inline collector can emit blank lines
+ * between a criterion and its loose-list continuation, so a result that is
+ * structurally non-empty and semantically empty is reachable.
+ */
+export function hasAcceptanceCriteria(acText: string | null | undefined): boolean {
+    return typeof acText === 'string' && acText.trim() !== '';
+}
+
+/**
+ * Extract a roadmap's acceptance criteria in either form the tree uses.
+ *
+ * Two forms, because roadmap authors write both and the reviewer needs whichever
+ * one is present:
+ *
+ * 1. A `## Acceptance Criteria` section — from that heading (inclusive) to the
+ *    next `## ` heading or EOF.
+ * 2. Inline `- **AC-n:**` bullets, declared per phase with no section heading —
+ *    collected with their indented continuation lines.
+ *
+ * Neither form → empty string, and every caller must treat that as "no criteria"
+ * rather than as an extracted-and-empty block: see {@link expectedHashes} and the
+ * prompt's roadmap line.
+ *
+ * The heading form is tried first and wins outright when found. Measured
+ * 2026-08-18 over the 44 active roadmaps: 21 heading-only, 7 inline-only, 0
+ * carrying both, 16 carrying neither — so the two forms do not currently
+ * co-occur and a precedence rule is a guard against a future file rather than a
+ * choice between live populations.
+ *
+ * WHY THE INLINE FORM WAS MISSING, stated because this is the second instance of
+ * the same defect class in this one function. The first was case sensitivity
+ * (`## Acceptance criteria` extracted nothing, found by the zcs-close R2 review
+ * 2026-08-09). The second is this: an inline-only roadmap yielded `''`, nothing
+ * downstream noticed, and the reviewer was handed a 0-byte
+ * `acceptance-criteria.md` under a prompt that said the criteria had been
+ * extracted. The R2 reviewer is the independent check on AC conformance, so
+ * blinding it while the artefact reads as though it checked is the
+ * gate-that-scans-nothing-exits-green shape one layer up.
  */
 export function extractAcceptanceCriteria(roadmapText: string): string {
     const lines = roadmapText.split('\n');
     let start = -1;
     for (let i = 0; i < lines.length; i++) {
-        // Case-insensitive: the tree carries both `## Acceptance Criteria` and
+        // Case-insensitive, and NOT anchored at the end of the line.
+        //
+        // Case first: the tree carries both `## Acceptance Criteria` and
         // `## Acceptance criteria`; a case-sensitive match silently extracted
         // nothing for the latter (found by the zcs-close R2 review, 2026-08-09).
-        if (/^## acceptance criteria\s*$/i.test(lines[i] as string)) {
+        //
+        // The end-anchor was the same defect wearing a different mask, and it was
+        // LIVE: `\s*$` rejected a heading carrying a qualifier, so
+        // `## Acceptance criteria (per phase, on promotion to ready)` and
+        // `## Acceptance criteria (anti-dump — the review-s own rule)` extracted
+        // nothing. Two roadmaps, measured 2026-08-18 — and they had been counted
+        // as "declares no criteria" by the very census that motivated this fix,
+        // which is how a matcher tuned to its own measurement hides its misses.
+        if (/^##\s+acceptance criteria\b/i.test(lines[i] as string)) {
             start = i;
             break;
         }
     }
-    if (start === -1) return '';
-    let end = lines.length;
-    for (let i = start + 1; i < lines.length; i++) {
-        if (/^## /.test(lines[i] as string)) {
-            end = i;
-            break;
+    if (start !== -1) {
+        let end = lines.length;
+        for (let i = start + 1; i < lines.length; i++) {
+            if (/^## /.test(lines[i] as string)) {
+                end = i;
+                break;
+            }
+        }
+        return lines.slice(start, end).join('\n');
+    }
+    return extractInlineAcceptanceCriteria(lines);
+}
+
+/**
+ * An inline criterion bullet, at any indent and with either bullet marker.
+ *
+ * Indent-tolerant so a nested criterion is emitted as its own row rather than
+ * folded into its parent as a continuation line — folding made the extraction
+ * shape, and therefore `ac_hash`, a function of indentation depth. Neither the
+ * `*` marker nor a nested criterion occurs in the tree today (measured
+ * 2026-08-18 across all 44 active roadmaps: zero of each), so this is a guard
+ * against a future file, not a fix for a live population.
+ */
+const AC_BULLET_RE = /^\s*[-*]\s+\*\*AC-/;
+
+/**
+ * Collect inline `- **AC-n:**` bullets and their continuation lines.
+ *
+ * A continuation line is indented and non-blank. Bullets are emitted in file
+ * order and separated by nothing but their own newline: each one is
+ * self-labelling (`AC-0`, `AC-1`, …), so a synthetic section heading would be
+ * text this function invented rather than text the roadmap declared.
+ *
+ * Two stopping rules, and the second is the subtle one:
+ *
+ * - another criterion bullet ends the current one, at any indent — see
+ *   {@link AC_BULLET_RE};
+ * - a blank line ends it ONLY when the next non-blank line is not an indented
+ *   continuation. Markdown loose lists separate a bullet from its second
+ *   paragraph with exactly that blank line, so breaking on the blank
+ *   unconditionally truncated the criterion and emitted a PARTIAL extraction —
+ *   which then hashed to a real value and read as complete. That is the
+ *   looks-like-success shape this whole function exists to remove, relocated
+ *   from "empty but claimed" to "half but claimed"; caught by the R2 review of
+ *   the first version. No roadmap uses a loose continuation today (measured
+ *   2026-08-18: zero across all 44), so this is latent-defect removal.
+ */
+function extractInlineAcceptanceCriteria(lines: readonly string[]): string {
+    const out: string[] = [];
+    for (let i = 0; i < lines.length; i++) {
+        if (!AC_BULLET_RE.test(lines[i] as string)) continue;
+        out.push(lines[i] as string);
+        let j = i + 1;
+        while (j < lines.length) {
+            const line = lines[j] as string;
+            // A sibling or nested criterion owns itself; hand it back to the
+            // outer loop rather than absorbing it.
+            if (AC_BULLET_RE.test(line)) break;
+            if (/^\s+\S/.test(line)) {
+                out.push(line);
+                j++;
+                continue;
+            }
+            if (line.trim() !== '') break;
+            // Blank: look past the run of blanks for an indented continuation.
+            let k = j;
+            while (k < lines.length && (lines[k] as string).trim() === '') k++;
+            const resumes =
+                k < lines.length &&
+                /^\s+\S/.test(lines[k] as string) &&
+                !AC_BULLET_RE.test(lines[k] as string);
+            if (!resumes) break;
+            for (let b = j; b < k; b++) out.push(lines[b] as string);
+            j = k;
         }
+        // Resume the outer scan AT the line that stopped the walk, so a
+        // criterion bullet that ended this one is still matched.
+        i = j - 1;
     }
-    return lines.slice(start, end).join('\n');
+    return out.join('\n');
 }
 
 /**
@@ -576,11 +711,29 @@ function reviewerPrompt(args: {
     headSha: string;
     scopeHash: string;
     roadmapGiven: boolean;
+    acGiven: boolean;
     changedFiles: readonly string[];
 }): string {
-    const roadmapLine = args.roadmapGiven
-        ? '- roadmap under review: `roadmap.md` (Acceptance Criteria extracted to `acceptance-criteria.md`)'
-        : '- roadmap under review: none (`acceptance-criteria.md` is empty)';
+    // Three states, not two. Branching on `roadmapGiven` alone told the reviewer
+    // "Acceptance Criteria extracted" whenever a roadmap was supplied — including
+    // when the extraction returned nothing and the file beside it was 0 bytes. A
+    // reviewer told the criteria are in a file it finds empty has no way to tell
+    // an extraction failure from a roadmap that genuinely declares none, so it
+    // cannot report the gap.
+    //
+    // The empty branch reports the EXTRACTION, never the roadmap. Its first
+    // version said "it declares NO acceptance criteria" — a claim the extractor
+    // cannot establish, since an unrecognised shape produces the identical empty
+    // result. That turned a silent failure into an affirmative false statement
+    // handed to the one independent check on AC conformance, which is strictly
+    // worse: silence invites a look, a false assertion forecloses it. Caught by
+    // the R2 review of the first version, and it was not hypothetical — the
+    // trailing-text heading it names was live in two roadmaps.
+    const roadmapLine = !args.roadmapGiven
+        ? '- roadmap under review: none (`acceptance-criteria.md` is empty)'
+        : args.acGiven
+          ? '- roadmap under review: `roadmap.md` (Acceptance Criteria extracted to `acceptance-criteria.md`)'
+          : '- roadmap under review: `roadmap.md` — NO acceptance criteria could be EXTRACTED from it, in either recognised form (an `## Acceptance criteria` heading, or inline `- **AC-n:**` bullets), so `acceptance-criteria.md` is empty. Two different things produce that result and the dispatcher cannot tell them apart: the roadmap declares none, or it declares them in a shape the extractor does not recognise. Open `roadmap.md`, decide which, and report a finding if the criteria are there.';
     return [
         `# R2 completion review — ${args.slug}`,
         '',
@@ -1037,6 +1190,7 @@ function runDispatch(args: Args): number {
         headSha,
         scopeHash: hashes.scope_hash,
         roadmapGiven: roadmapText !== null,
+        acGiven: hasAcceptanceCriteria(acText),
         changedFiles,
     });
     const manifest = deriveManifest({

package/src/scripts/hooks/skill_route_hook.ts

@@ -43,6 +43,66 @@
  * need an invalidation story for a tree that changes under the session, and
  * 12.3 ms does not buy one.
  *
+ * HOST-HONEST, AND FAIL-OPEN BY CONSTRUCTION (road-to-catalogue-host-fit Phase
+ * 3). The ranker reads the on-disk tree; the host does not necessarily deliver
+ * it. A skill the host truncated is still rankable and still pointable, and the
+ * pointer then names a skill whose description the model never received — worse
+ * than silence, because a pointer reads as a delivered capability. That is the
+ * roadmap's D-4, and it is MEASURED rather than assumed: 16 of 16 bare entries
+ * in the 2026-08-12 claude observation are still in this ranker's catalogue
+ * (`capture_skill_catalogue --pointable-bare`), among them `design-review`,
+ * `design-intelligence` and `fe-design` — skills this estate's own rules route
+ * to. So the pointer set is filtered against the latest per-entry observation
+ * for the CURRENT host.
+ *
+ * The filter only ever narrows on a positive reading, and every uncertain state
+ * resolves to no filtering at all: no observation log, no record for this host,
+ * a host that publishes no per-entry list, a malformed line, an unknown host, or
+ * any throw. `knownBareNames` returns `null` for each of them and
+ * `filterKnownBare` treats `null` as a pass-through, so behaviour is
+ * byte-identical to the unfiltered line. A filter that quietly hides skills on
+ * missing data is worse than the divergence it treats — the roadmap's own words,
+ * and the reason fail-open is a construction here rather than a convention.
+ *
+ * IT COSTS ZERO ON THE PATH THE HEADER ABOVE PROMISES IS FREE, AND 0.015 ms ON
+ * THE ONE THAT PAYS. The log read is passed in as a thunk, not a value, and
+ * `routePointers` calls it only after the term floor AND the rank both pass. A
+ * prompt below `MIN_TASK_TERMS` therefore still reads no files at all, which is
+ * the claim the 0 ms paragraph makes and an eagerly-read log would have quietly
+ * falsified.
+ *
+ * The FIRING path was measured rather than assumed, because R2 finding 10 is
+ * right that the paragraph above describes a path this branch changed. Measured
+ * 2026-08-18 on this tree, same method as the 12.3 ms figure: `knownBareForHost`
+ * alone is **0.015 ms median / 0.022 ms p95** (n=2000, warm) against a ranked
+ * pass of 8.3 ms median — three orders of magnitude below the ranker it rides
+ * on, and under 0.01 % of the slot's 250 ms p95 budget. The log is seven lines;
+ * a cache would need an invalidation story and 0.015 ms does not buy one, which
+ * is the same reasoning the ranker's own no-cache decision records.
+ *
+ * Note what the existing bench does NOT cover, so nobody reads it as coverage:
+ * `bench_hook_latency`'s synthetic payload carries neither `prompt` nor
+ * `platform`, so this concern returns before the ranker on every bench
+ * iteration. The figures above come from a direct probe, not from that harness.
+ *
+ * THE FLOOR APPLIES TO WHAT IS DELIVERED, NOT TO WHAT WAS RANKED. Filtering
+ * happens BEFORE `MIN_TOP_SCORE` and before the `TOP_K` slice, so the confidence
+ * question is asked of the best pointer the model can actually use. One rule, in
+ * one order: rank → drop the undeliverable → apply the floor → take the top
+ * three.
+ *
+ * That ordering makes silence a real outcome, and the number says so rather than
+ * the prose guessing: on `"review the authorization policy and tenant scope for
+ * this endpoint"` the ranker returns `authz-review` at 47 and the next entry at
+ * 23, against a floor of 31. Suppress the top-1 and NOTHING clears the floor —
+ * the line goes silent instead of naming a 23/100 pointer because the 47 one was
+ * undeliverable. That is the intended reading of a floor calibrated for
+ * confidence, and promoting a sub-floor pointer to fill the gap would be the
+ * "advisory worse than silence" failure this file's risk paragraph ranks first.
+ * `suppressed` is what distinguishes that silence from an unranked prompt, and
+ * `tests/hooks/skill_route_hook.test.ts` pins both cases against the real
+ * corpus rather than a constructed one.
+ *
  * NO ADOPTION THRESHOLD IS COMMITTED HERE. Whether the line changes behaviour
  * is a question for data, not for this header: `skill_route_pointer_rate` is
  * registered in `hook-token-budget.json` under the same owner/review discipline
@@ -51,6 +111,13 @@
  * removed. The score floor above is a TRIGGER calibration and is measured; the
  * adoption threshold is an OUTCOME claim and is deliberately absent.
  *
+ * `skill_route_bare_suppression_rate` is registered beside it under the same
+ * owner, review date and kill discipline, and inherits the same refusal: how
+ * often the filter fires is a number to collect, not one to promise. Its
+ * numerator is carried in the warn `reason` below — `N suppressed` — because no
+ * dedicated counter exists, and that gap is registered as a gap rather than
+ * implied to be automatic.
+ *
  * DELIVERY PATH — the verified one, copied rather than re-derived. A
  * `user_prompt_submit` concern returning `{decision:"allow", context:…}` at
  * exit 0 produces zero stdout: `host_semantics.emitFor` drops the field for
@@ -73,7 +140,8 @@ import { fileURLToPath, pathToFileURL } from "node:url";
 
 import { readHookStdin } from "./hook_stdin.js";
 import { isSyntheticPrompt } from "../_lib/prompt_shape.js";
-import { resolveSkillsRoot } from "../_lib/skill_catalogue.js";
+import { OBSERVATION_LOG, readObservationLog, resolveSkillsRoot } from "../_lib/skill_catalogue.js";
+import { knownBareNames } from "../_lib/skill_catalogue_series.js";
 import { _tokenize, rank, type RankRow } from "../skill_tools/score_skill_relevance.js";
 
 const EXIT_ALLOW = 0;
@@ -119,31 +187,115 @@ function _isObject(v: unknown): v is JsonObject {
   return typeof v === "object" && v !== null && !Array.isArray(v);
 }
 
+/**
+ * Names this host is known to have delivered bare, or `null` for no filtering.
+ *
+ * Every failure mode collapses to `null` — an unknown host, a missing log, an
+ * unreadable one, a host that enumerates nothing, a throw from anywhere in the
+ * read. The three-way distinction `knownBareNames` draws is preserved: an empty
+ * set means *measured clean*, `null` means *never measured*, and only the second
+ * one is produced here by accident.
+ */
+export function knownBareForHost(workspaceRoot: string, host: string | null): Set<string> | null {
+  if (host === null || host === "") return null;
+  try {
+    return knownBareNames(readObservationLog(path.join(workspaceRoot, OBSERVATION_LOG)), host);
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Drop the ranked rows this host is known to have delivered bare.
+ *
+ * `null` is a pass-through and returns the input order untouched, which is the
+ * fail-open half of the header's contract and what makes an absent observation
+ * byte-identical to today.
+ */
+export function filterKnownBare(
+  rows: readonly RankRow[],
+  bare: Set<string> | null,
+): RankRow[] {
+  if (bare === null || bare.size === 0) return [...rows];
+  return rows.filter(([name]) => !bare.has(name));
+}
+
+/** What one routing pass decided, including what it refused to name. */
+export interface RouteDecision {
+  rows: RankRow[];
+  /**
+   * Would-be POINTERS dropped as known-bare — the suppression metric's numerator.
+   *
+   * Scoped to the pointer window (`TOP_K` of the unfiltered ranking), not to the
+   * whole ranked list. R2 finding 1: `rank` returns every non-zero-scoring skill
+   * and this catalogue has hundreds, so counting drops across all of them would
+   * let a bare name at rank 40 — never pointable, never a loss — bump the count
+   * on almost every fire. The registered metric defines this as skills the
+   * ranker wanted to POINT AT, and its upper falsifier would otherwise fire on a
+   * perfectly healthy join.
+   */
+  suppressed: number;
+}
+
 /**
  * Rank a prompt and return the pointers worth injecting, or `[]` for silence.
  *
  * Total by construction: a missing root, an unreadable catalogue, or a ranker
  * error all resolve to `[]`. A routing advisory that can crash a turn is worse
  * than one that says nothing.
+ *
+ * `bareProvider` is a THUNK, deliberately — see the header's zero-cost
+ * paragraph. It is called only once both the term floor and the rank have
+ * passed, so the short-prompt path still touches no files. Omitting it disables
+ * filtering entirely, which is what keeps every caller that predates the filter
+ * behaviourally unchanged.
  */
-export function routePointers(prompt: string, skillsDir: string | null): RankRow[] {
-  if (skillsDir === null) return [];
+export function routeDecision(
+  prompt: string,
+  skillsDir: string | null,
+  bareProvider?: () => Set<string> | null,
+): RouteDecision {
+  const silent: RouteDecision = { rows: [], suppressed: 0 };
+  if (skillsDir === null) return silent;
   // Denominator floor BEFORE the catalogue read: a prompt too short to score
   // meaningfully cannot produce a pointer worth 337 file reads either.
   try {
-    if (_tokenize(prompt).size < MIN_TASK_TERMS) return [];
+    if (_tokenize(prompt).size < MIN_TASK_TERMS) return silent;
   } catch {
-    return [];
+    return silent;
   }
   let rows: RankRow[];
   try {
     rows = rank(prompt, skillsDir);
   } catch {
-    return [];
+    return silent;
+  }
+  let bare: Set<string> | null = null;
+  if (bareProvider !== undefined) {
+    try {
+      bare = bareProvider();
+    } catch {
+      bare = null; // fail open, never silent-narrow
+    }
   }
-  const top = rows[0];
-  if (top === undefined || top[1] < MIN_TOP_SCORE) return [];
-  return rows.slice(0, TOP_K);
+  const deliverable = filterKnownBare(rows, bare);
+  // The pointer WINDOW, not the ranked list — see `RouteDecision.suppressed`.
+  const suppressed =
+    bare === null ? 0 : rows.slice(0, TOP_K).filter(([name]) => bare.has(name)).length;
+  // The floor asks its question of the best DELIVERABLE pointer, not of a
+  // pointer the model cannot use. See the header's one-rule-one-order note.
+  const top = deliverable[0];
+  if (top === undefined || top[1] < MIN_TOP_SCORE) return { rows: [], suppressed };
+  return { rows: deliverable.slice(0, TOP_K), suppressed };
+}
+
+/** The rows alone. Kept because most callers and fixtures want only these. */
+export function routePointers(
+  prompt: string,
+  skillsDir: string | null,
+  bareProvider?: () => Set<string> | null,
+): RankRow[] {
+  return routeDecision(prompt, skillsDir, bareProvider).rows;
 }
 
 /**
@@ -191,13 +343,22 @@ export function main(): number {
   if (!prompt) return EXIT_ALLOW;
   if (isSyntheticPrompt(prompt)) return EXIT_ALLOW; // harness turn, not a task
 
-  const rows = routePointers(prompt, resolveSkillsRoot(_workspaceRoot(env)));
+  const root = _workspaceRoot(env);
+  const platform = env["platform"];
+  const host = typeof platform === "string" && platform ? platform : null;
+  const { rows, suppressed } = routeDecision(prompt, resolveSkillsRoot(root), () =>
+    knownBareForHost(root, host),
+  );
   if (rows.length === 0) return EXIT_ALLOW; // silence is the default
 
   process.stdout.write(
     `${JSON.stringify({
       decision: "warn",
-      reason: `skill-route: ${rows.length} pointer(s), top ${rows[0]![1]}/100`,
+      reason:
+        `skill-route: ${rows.length} pointer(s), top ${rows[0]![1]}/100` +
+        // The suppression metric's numerator. Named only when non-zero, so the
+        // common line keeps its shape and its registered byte budget.
+        (suppressed > 0 ? `, ${suppressed} suppressed as host-bare` : ""),
       additional_context: buildRouteLine(rows),
     })}\n`,
   );

package/src/scripts/install-hooks.sh

@@ -35,6 +35,32 @@ cat > "$HOOKS_DIR/pre-push" << 'EOF'
 # so any derived-output drift blocks the push here. Runtime ~15-40s (it
 # regenerates the tool trees) — cheaper than a red CI run and a fixup re-push.
 
+# A delete-only push has no content to gate, so every check below is answering
+# a question nobody asked. Measured 2026-08-18 during the 14.0.0 release:
+# `git push origin --delete release/14.0.0` was refused by the branch-freshness
+# gate because the CHECKED-OUT branch was behind main — a fact with no bearing
+# on removing a remote ref. The deletion had to go through the GitHub API to
+# happen at all, which routes around the whole hook rather than around one gate.
+#
+# Git feeds pre-push one line per ref on stdin:
+#   <local ref> <local sha> <remote ref> <remote sha>
+# and a deletion carries the all-zero local sha. Reading stdin is safe here:
+# nothing below consumes it.
+delete_only=1
+saw_ref=0
+while read -r _local_ref local_sha _remote_ref _remote_sha; do
+    [ -z "${local_sha:-}" ] && continue
+    saw_ref=1
+    # Any non-zero character means a real object is being pushed.
+    case "$local_sha" in
+        *[!0]*) delete_only=0 ;;
+    esac
+done
+if [ "$saw_ref" = "1" ] && [ "$delete_only" = "1" ]; then
+    echo "🗑️  Delete-only push — no ref advances, so the content gates have nothing to check. Skipping."
+    exit 0
+fi
+
 fail=0
 
 if ! command -v task >/dev/null 2>&1; then