@event4u/agent-config 8.5.0 → 8.6.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": "8.5.0",
+    "version": "8.6.0",
     "keywords": [
       "agent-config",
       "skills",

package/CHANGELOG.md

@@ -989,6 +989,31 @@ our recommendation order, not its support status.
 > that forces a new era split (`# Era: 8.2.x`, etc.) — see
 > [`docs/contracts/CHANGELOG-conventions.md § Era splits`](docs/contracts/CHANGELOG-conventions.md).
 
+## [8.6.0](https://github.com/event4u-app/agent-config/compare/8.5.0...8.6.0) (2026-07-08)
+
+### Features
+
+* **cost-routing:** tier-downshift layer — telemetry fields, category defaults, tripwires, slice inference, verify-fail escalation ([e9839f5](https://github.com/event4u-app/agent-config/commit/e9839f5a034c3a0882e8956a2a3f580b3978056a))
+
+### Bug Fixes
+
+* **ci:** install task in the release workflow ([19072d9](https://github.com/event4u-app/agent-config/commit/19072d9bcbb6d30cd943804f287dd79c9c709167))
+
+### Documentation
+
+* **roadmaps:** add four frontier-prompt-harvest roadmaps ([e232e34](https://github.com/event4u-app/agent-config/commit/e232e342401bd6edafda79cd64ce8ed4ff6ddd93))
+* **proof:** regenerate proof.md with the backed downshift-cost-reduction claim ([6f28604](https://github.com/event4u-app/agent-config/commit/6f286048b609442be81ac60a8c64df544a369df0))
+* **roadmaps:** unify tripwire engine wording on the ADR-116 path ([f4ee375](https://github.com/event4u-app/agent-config/commit/f4ee37540ea6f9724014c63be05617e4abcdaa1b))
+* **adr:** pin the memory scale-tripwire activation path (ADR-116) ([7efe88a](https://github.com/event4u-app/agent-config/commit/7efe88a7cda064e659a830a2d6a70e506ab21408))
+* **claims:** back downshift-cost-reduction with the routing-downshift bench run ([38f3194](https://github.com/event4u-app/agent-config/commit/38f31942b16474fcc5977f0560da435ce84a81dd))
+
+### Chores
+
+* **condense:** recondense cost-routing context/command edits into dist ([33fe1a3](https://github.com/event4u-app/agent-config/commit/33fe1a353a3eef52d024079016b32b9fe02b0531))
+* **contexts:** durable verdict note for cost-aware model routing ([cbff1bd](https://github.com/event4u-app/agent-config/commit/cbff1bdc7f2b0b87843283443de534c48f5ddd54))
+
+Tests: 6943 (+7 since 8.5.0)
+
 ## [8.5.0](https://github.com/event4u-app/agent-config/compare/8.4.1...8.5.0) (2026-07-08)
 
 ### Features

package/dist/agent-src/commands/cost/report.md

@@ -118,6 +118,26 @@ Orchestration telemetry (YYYY-MM, N dispatches):
   guardrail breaches:  [token_blowup | spawn_failure | verify_skip | none]
 ```
 
+When orchestration lines carry the routing extension fields
+(`task_class` / `tier_chosen` / `escalated_from` / `verify_result_by_tier` —
+see `orchestration-telemetry.md`), append the per-tier routing view using
+`readTierRoutingMetrics`, `escalationPromotionCandidates`, and
+`verifyPassDrift` from the same module — the per-tier QUALITY view a
+spend-only dashboard misses:
+
+```
+Tier routing (YYYY-MM):
+  dispatches by tier:      lite N · medium N · high N
+  escalation rate by class: <class>: N.N% (promotion tripwire: >40%)
+  verify-pass rate by tier: lite N.N% · medium N.N%
+  tripwires fired:          [promote <class> | verify-pass drift on <tier> | none]
+```
+
+A fired tripwire is a recommendation to surface, never an auto-flip: the
+escalation tripwire suggests promoting the class's static default tier; the
+drift tripwire flags verifier/model drift for investigation (per
+`subagent-steering.md § Cost-routing tripwires`).
+
 If no orchestration lines exist yet (telemetry capture not yet running or
 no delegated dispatches this month), surface:
 

package/dist/agent-src/contexts/execution/auto-dispatch-classification.md

@@ -55,6 +55,36 @@ dwarfs the work). Below the floor → in-session.
 | `parallelizable: files\|independent` / independent slices | `do-in-parallel` |
 | change needing verification (any of the above) | implementer + cross-model judge per the `subagent-orchestration` Iron Law |
 
+## Per-slice tier inference (v1.5 — deterministic, task-TYPE-keyed)
+
+Once a slice is classified **delegable**, a second deterministic table infers
+its `model_tier` (road-to-cost-aware-model-routing, council 2026-07-08).
+Keyed **exclusively on the classifier's task-TYPE outputs** — never raw size
+metrics; diff size anti-correlates with difficulty in refactoring domains.
+
+```
+UNKNOWN / AMBIGUOUS → inherit (SESSION TIER). NEVER GUESS DOWN.
+SIZE SIGNALS ARE NEGATIVE GUARDS ONLY — THEY REVOKE A lite CANDIDACY,
+THEY NEVER CREATE ONE.
+```
+
+| Slice type (classifier output) | Inferred tier |
+|---|---|
+| Delegable + read-only fan-out (grep / inventory / discovery targets) | `lite` |
+| Delegable + mechanical / template-driven transform WITH test coverage | `lite` (verify-fail escalates to `medium` per the steering cascade) |
+| Delegable + mutating WITHOUT test coverage | `medium` |
+| Delegable + synthesis / judgment (review, analysis slice) | `medium` — judge one tier up per the orchestration Iron Law |
+| Any other / ambiguous shape | `inherit` — session tier, no downshift |
+
+**Negative size guard:** slice scope exceeding the mechanical envelope
+(multi-file mutation, diff surface beyond single responsibility) loses `lite`
+candidacy, resolves one row down — size never argues FOR a downshift, only
+against one.
+
+Every inferred decision records `tier_source: "inferred"` in orchestration
+telemetry (static pins record `"static"`; session-tier runs `"inherit"`) so
+the evidence gate scores inferred routing separately from static pinning.
+
 ## v2+ (deferred, gated on Phase 6 evidence)
 
 LLM-based classification — only if the deterministic rules prove too coarse

package/dist/agent-src/contexts/execution/orchestration-telemetry.md

@@ -19,7 +19,12 @@ v1 forward-compat rule on unknown fields).
   "wall_clock_ms": 0,
   "outcome": "DONE",
   "verify_mode": "deterministic",
-  "verdict_changed_outcome": null
+  "verdict_changed_outcome": null,
+  "task_class": null,
+  "tier_chosen": null,
+  "tier_source": null,
+  "escalated_from": null,
+  "verify_result_by_tier": null
 }
 ```
 
@@ -36,6 +41,15 @@ v1 forward-compat rule on unknown fields).
 | `outcome` | enum | One of `DONE` · `DONE_WITH_CONCERNS` · `NEEDS_CONTEXT` · `BLOCKED` · `killed`. |
 | `verify_mode` | enum | How output was verified: `deterministic` · `judge` · `none`. |
 | `verdict_changed_outcome` | bool \| null | **A3 extension (ADR-109 Track A).** For a review/verdict subagent (e.g. `production-validator`): did the verdict change the outcome vs the in-session baseline? `true` = caught a real issue the baseline missed / flipped a false `READY`→`NOT READY`; `false` = no lift; `null` = not a verdict dispatch / not measured. **Negative-control (clean single-file) tasks MUST record `false`** — a `true` on a control = spurious findings, fails Gate A. Additive field on THIS object, not a second schema. Boolean/counts only, no bodies. |
+| `task_class` | string \| null | **Routing extension (road-to-cost-aware-model-routing Phase 0).** Category id of the dispatched slice (e.g. `read-only-fanout`, `mechanical-edit`, `implementation`, `review-synthesis`). Enum-style id only, never free-form task text. `null` = pre-extension line / unclassified. |
+| `tier_chosen` | string \| null | Tier the slice was dispatched on (`lite` \| `medium` \| `high`). `null` = pre-extension line. |
+| `tier_source` | enum \| null | Where `tier_chosen` came from: `static` (frontmatter/category pin) · `inferred` (deterministic per-slice inference) · `inherit` (session tier — no downshift decision). Lets the evidence gate score inferred routing separately from static pinning. |
+| `escalated_from` | string \| null | When the slice re-dispatched after a verification failure: tier of the FAILED attempt (e.g. `lite` when a lite return failed verify and the slice re-ran on `medium`). `null` = no escalation. |
+| `verify_result_by_tier` | object \| null | Map tier → verification result per attempt of this slice (e.g. `{"lite":"fail","medium":"pass"}`). Values: `pass` \| `fail` \| `skipped`. Feeds the per-tier verify-pass-rate tripwire. Enums only, no verdict bodies. |
+
+All five routing fields are additive and optional — a line without them is
+still a valid orchestration line; readers ignore unknown fields per the v1
+forward-compat rule.
 
 ## Privacy floor
 

package/dist/agent-src/contexts/execution/subagent-steering.md

@@ -42,6 +42,38 @@ Only automatic response to a transient failure; structural/semantic errors (e.g.
 `BLOCKED` envelope) do **not** trigger a downshift — escalate to the orchestrator
 immediately.
 
+## Verify-fail escalation — the downshift cascade (M3)
+
+Cheap-first cascade for DOWNSHIFTED slices only
+(road-to-cost-aware-model-routing, council 2026-07-08). Transient failures
+(above) and verify-fails are distinct: transient retries downward once; a
+**verification failure escalates upward**.
+
+```
+VERIFY-FAIL ON A DOWNSHIFTED RETURN → RE-DISPATCH ONE TIER UP.
+COUNTS AGAINST THE EXISTING N=3 BUDGET — NEVER A NEW BUDGET.
+ATTEMPT 1 lite → ATTEMPT 2 medium → ATTEMPT 3 = SLICE FAILED,
+ORCHESTRATOR REPLANS AT SESSION TIER.
+ESCALATION TRIGGER IS THE JUDGE VERDICT / DETERMINISTIC VERIFY RESULT —
+NEVER THE SUBAGENT'S OWN CONFIDENCE.
+```
+
+- **Scope:** slices with `tier_source: static | inferred` only. `inherit`
+  slices keep existing same-tier retry semantics — no behavior change outside
+  the downshift path.
+- **Budget accounting:** each escalated attempt consumes one of the slice's
+  three attempts (`budgetHalt()` unchanged). Two failed attempts mark the
+  slice failed; the orchestrator replans — a slice's verify-fail never
+  poisons the orchestrator trajectory, only the final verified return (or
+  failure mark) enters its context.
+- **Telemetry:** the re-dispatch records `escalated_from: <failed tier>` and
+  appends to `verify_result_by_tier`.
+- **Economics guard:** a class escalating > 40% of the time is cheaper
+  started on the higher tier — the escalation-rate tripwire (below) promotes
+  its static default; the cascade is for the tail, not the norm.
+
+Deterministic reference: `escalateOnVerifyFail()`.
+
 ## Failure-type stop — the N=3 budget applied per subagent type
 
 Two consecutive **verification-failed** returns from one subagent type in a
@@ -88,6 +120,26 @@ The guardrail thresholds (`breachedGuardrails()`), read off the
 
 A breach is a maintainer/user signal, surfaced — never an automatic flip.
 
+## Cost-routing tripwires — steering policy for downshifted dispatch
+
+Two tripwires guard the cost-aware downshift path
+(road-to-cost-aware-model-routing, council 2026-07-08). Like the rollback
+guardrails they are **surfaced, never auto-flipped** — steering policy over
+the routing telemetry fields (`task_class`, `tier_chosen`, `escalated_from`,
+`verify_result_by_tier` in [`orchestration-telemetry`](orchestration-telemetry.md)),
+not a new mechanism:
+
+| Tripwire | Threshold | Action when fired |
+|---|---|---|
+| **Escalation-rate promotion** | per-class escalation rate > 40% over the rolling window | Class's default tier is wrong — cascading it costs more than starting high (decision-theoretic escalation analysis). Promote the class's static default one tier, log the promotion; do not keep cascading. |
+| **Verify-pass drift** | a tier's verify-pass rate drops below its trailing baseline | Verifier or model drift — a drifting verifier silently escalates everything (cost ~3x). Surface the drift with per-tier numbers; never silently absorb the extra escalations. |
+
+Deterministic references: `escalationPromotionCandidates()` and
+`verifyPassDrift()` over `readTierRoutingMetrics()` aggregates. Per-tier
+quality view (spend by tier, escalation count by class, verify-pass rate by
+tier) surfaces via `/cost:report` — the delayed-signal quality guard: cost
+dashboards alone look fine while quality regresses.
+
 ## Kill-switch
 
 ```
@@ -101,7 +153,8 @@ This is the canonical disable — no code change, effective on the next run.
 
 [`src/scripts/_lib/subagent_steering.ts`](../../../../src/scripts/_lib/subagent_steering.ts)
 (`isLayerDisabled`, `budgetHalt`, `typeStop`, `sliceDispatchAllowed`,
-`breachedGuardrails`), covered by
+`breachedGuardrails`, `readTierRoutingMetrics`,
+`escalationPromotionCandidates`, `verifyPassDrift`), covered by
 [`tests/scripts/_lib_subagent_steering.test.ts`](../../../../tests/scripts/_lib_subagent_steering.test.ts).
 
 ## Related

package/dist/agent-src/contexts/model-recommendations.md

@@ -39,6 +39,25 @@ tier is the reasoning band; `context: large` is the context-window need.
 | **Implementation after a `high`-tier plan** | `medium` | Plan is done, execution is mechanical |
 | **Trivial mechanical** (formatting, one-line config, rote rename) | `lite` | No reasoning required; fastest tier suffices |
 
+## Subagent Category → Tier Defaults (dispatch-time downshift)
+
+Normative defaults for DISPATCHED subagent slices (road-to-cost-aware-model-routing,
+council 2026-07-08). The orchestrator's own session model is never switched;
+these tiers apply to the sub-task the orchestrator spawns. Category-keyed —
+immune to per-instance misrouting; unknown/ambiguous category → `inherit`.
+
+| Subagent category | Tier | Why |
+|---|---|---|
+| Read-only fan-out (grep / inventory / file discovery) | `lite` | Returns get deterministic verification; quality risk ~0 by construction |
+| Mechanical single-file regen / template-driven transform | `lite`→`medium` fallback | Pattern application, no open-ended reasoning; verify-fail escalates one tier |
+| Implementation (bounded, planned slice) | `medium` | Plan exists; execution is pattern work |
+| Review / judge / synthesis / architecture | `medium`\|`high` | Reasoning depth is the product |
+
+**Judge asymmetry invariant:** the cross-model judge always runs one tier
+ABOVE the implementer tier (ladder in
+[`subagent-configuration`](subagent-configuration.md)). Downshifting an
+implementer never downshifts its judge.
+
 ## Detection Heuristics
 
 | Signal | Task Type | Tier |

package/dist/agent-src/contexts/subagent-configuration.md

@@ -25,6 +25,14 @@ If the session runs on **opus**, judge stays on opus (no higher tier
 available). If the session runs on **sonnet**, judge defaults to opus.
 If the session runs on **haiku**, judge defaults to sonnet.
 
+**Downshift never touches the judge.** When cost-aware routing runs an
+implementer on a downshifted tier (per the category → tier defaults in
+[`model-recommendations § Subagent Category → Tier Defaults`](model-recommendations.md)),
+the judge still resolves one tier above the IMPLEMENTER's resolved tier —
+a `lite` implementer gets at least a `medium` judge. Downshifting an
+implementer never downshifts its judge below what the verify contract
+requires; a judge is never `lite`.
+
 ## Resolution order
 
 For both implementer and judge:

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: "8.5.0"
+agent_config_version: "8.6.0"
 
 # --- Project identity ---
 project:

package/dist/discovery/deprecation-report.md

@@ -1,6 +1,6 @@
 # Discovery — Deprecation Report
 
-- Generated: `2026-07-08T12:48:25Z`
+- Generated: `2026-07-08T14:10:55Z`
 - Deprecated artefacts: **0**
 
 _None. Tree is clean._

package/dist/discovery/discovery-manifest.json

@@ -2925,7 +2925,7 @@
     },
     {
       "category": "command",
-      "checksum": "sha256:1809087ff3860b7d07fb42958e58f73297451a669c57573137b5cf8ea0284236",
+      "checksum": "sha256:90b89f5241ecad5adb6b6de797a2b71e0a87898b8e3f5a0958be4df293246a3a",
       "install": {
         "default": true,
         "removable": false
@@ -12769,7 +12769,7 @@
       "workspaces": []
     }
   ],
-  "checksum": "sha256:4dd1cf9aacb705067e017342c3d7633728bd2822ef8d6d8cacaf8406c7131334",
+  "checksum": "sha256:373d4519debcdb5a39c065b83e496247480fc44a91aeb6f495ba5024f2a7192b",
   "deprecations": [
     {
       "key": "tier",
@@ -12912,7 +12912,7 @@
       "reason": "scaffold template for ticket-bundle tickets (ADR-101); carries no runtime frontmatter — emit-tickets fills it in per ticket"
     }
   ],
-  "generated_at": "2026-07-08T12:48:25Z",
+  "generated_at": "2026-07-08T14:10:55Z",
   "packs": [
     {
       "artefact_count": 95,

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

@@ -1 +1 @@
-e6337c8304f42bebf186771bae9266ed3da8f3fc9958279cd316b2d7df0ec25a  discovery-manifest.json
+01ac916a948ce2e4232ae06f46e3c626f31a3e328c66904dbfd61ef731a13b1c  discovery-manifest.json

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

@@ -1,6 +1,6 @@
 # Discovery Manifest — Summary
 
-- Generated: `2026-07-08T12:48:25Z`
+- Generated: `2026-07-08T14:10:55Z`
 - Scanner: `f36b5a348348`
 - Artefacts: **533**
 - Unassigned: **0**

package/dist/discovery/orphan-report.md

@@ -1,6 +1,6 @@
 # Discovery — Orphan Report
 
-- Generated: `2026-07-08T12:48:25Z`
+- Generated: `2026-07-08T14:10:55Z`
 - 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:4dd1cf9aacb705067e017342c3d7633728bd2822ef8d6d8cacaf8406c7131334",
-  "generated_at": "2026-07-08T12:48:25Z",
+  "checksum": "sha256:373d4519debcdb5a39c065b83e496247480fc44a91aeb6f495ba5024f2a7192b",
+  "generated_at": "2026-07-08T14:10:55Z",
   "packs": [
     {
       "always_on": false,

package/dist/discovery/trust-report.md

@@ -1,6 +1,6 @@
 # Discovery — Trust Report
 
-- Generated: `2026-07-08T12:48:25Z`
+- Generated: `2026-07-08T14:10:55Z`
 - Workspaces tracked: **10**
 - Human-review-required artefacts: **3**
 

package/dist/discovery/workspaces.json

@@ -1,6 +1,6 @@
 {
-  "checksum": "sha256:4dd1cf9aacb705067e017342c3d7633728bd2822ef8d6d8cacaf8406c7131334",
-  "generated_at": "2026-07-08T12:48:25Z",
+  "checksum": "sha256:373d4519debcdb5a39c065b83e496247480fc44a91aeb6f495ba5024f2a7192b",
+  "generated_at": "2026-07-08T14:10:55Z",
   "scanner_version": "f36b5a348348",
   "workspaces": [
     {

package/dist/mcp/registry-manifest.json

@@ -9,7 +9,7 @@
     "homepage": "https://github.com/event4u-app/agent-config#readme",
     "name": "@event4u/agent-config",
     "repository": "https://github.com/event4u-app/agent-config",
-    "version": "8.5.0"
+    "version": "8.6.0"
   },
   "registries": [
     {

package/docs/CLAIMS.md

@@ -70,6 +70,13 @@
 - status: backed
 - last_verified: 2026-07-07
 
+### claim: downshift-cost-reduction
+- claim: On the READ-ONLY FAN-OUT slice family, tier-downshifted subagent dispatch (lite/haiku vs session-tier-proxy sonnet) nets a ≥30% USD-weighted token-cost reduction at held quality — measured 2026-07-08 (n=10 paired live dispatches, 20 telemetry lines): 10/10 exact-match on BOTH arms, 29.4% fewer raw tokens, 76.5% USD-weighted cost reduction at the 3x haiku↔sonnet price ratio. FAMILY-SCOPED — the mechanical-edit family is unmeasured and its downshift (incl. the deferred tier downgrades of existing units) stays gated. Negative control held: an open-ended synthesis/unknown slice never resolves below the session tier (inferSliceTier → medium/inherit, never lite).
+- kind: quant
+- evidence: internal/bench/routing-downshift/results-2026-07-08.md#FAMILY-SCOPED PROVE
+- status: backed
+- last_verified: 2026-07-08
+
 ---
 
 ## Unbacked inventory (documented debt — not yet markered in prose)

package/docs/decisions/ADR-116-memory-tripwire-activation-path.md

@@ -0,0 +1,125 @@
+---
+adr: 116
+status: accepted
+date: 2026-07-08
+decision: memory-tripwire-activation-path
+supersedes: —
+superseded_by: —
+phase: road-to-memory-retrieval-economy · Phase 6
+---
+
+# ADR-116 — Memory scale-tripwire activation path: one engine, measured at fire time
+
+- **Deciders:** maintainer + AI council (anthropic/claude-sonnet-4-5 +
+  openai/gpt-4o; disposition debate 2 rounds + engine tie-break 2 rounds,
+  2026-07-08 — tie-break converged after the in-repo `node:sqlite`
+  precedent was surfaced)
+
+## Context
+
+An external second-opinion review (round 2 of the Obsidian-reference
+comparison) surfaced a real documentation conflict: the memory-scale
+tripwire (>200 files in one memory/knowledge type, or >500 files total —
+guarded by `lint_knowledge_scale.ts`) had **three different pre-decided
+activation paths** across three artifacts, written by two councils one day
+apart:
+
+1. `agents/settings/contexts/second-brain-delta-verdict.md` Q4
+   (2026-07-07): "file-first in-memory BM25 (minisearch-class, re-index at
+   session-start, no persistence)".
+2. `agents/roadmaps/road-to-memory-retrieval-economy.md` Phase 6
+   (2026-07-07/08): "SQLite FTS5 over the memory files … replacing
+   `_score()`'s substring pass".
+3. `docs/decisions/ADR-061-corpus-grounding-layer.md`: "a new domain ships
+   a manifest + data + a named owner — **not a forked engine**", with a
+   tested in-house BM25 (`src/skills/corpus-grounding/scripts/bm25_search.ts`,
+   generic `class BM25` over `Row[]`) as the implied reuse candidate.
+
+The whole point of a pre-decided path is that the tripwire firing needs no
+new debate; in this state, firing would have required one.
+
+## Decision
+
+1. **One engine: SQLite FTS5 via Node's built-in `node:sqlite`.**
+   - Zero npm dependency — the repo already uses `node:sqlite` in
+     production code (`src/scripts/mcp_telemetry_store.ts` /
+     `mcp_telemetry_query.ts`) with the established pattern: lazy import +
+     runtime guard for Node < 22.5 (`src/scripts/_lib/node_sqlite.d.ts`).
+     `better-sqlite3` and a minisearch dependency are both rejected.
+   - **Persistence economics** decided the tie-break: at tripwire scale the
+     in-memory re-index per session-start is a startup tax that grows with
+     the corpus; FTS5 gives a persisted index plus incremental updates.
+     The in-house `class BM25` lacks a persistence layer; building one
+     (serialization, incremental updates, corruption handling) recreates
+     what SQLite ships.
+   - Index location: `agents/runtime/state/` (gitignored, never tracked).
+   - **Re-index is batch/lazy** — post-session or on first lookup, never
+     inline per write: during active sessions files churn (drafts,
+     rollbacks), and inline indexing would put fsync latency and lock
+     contention inside the write path (council round-2 caveat).
+   - FTS5 availability in the bundled SQLite is verified at implementation
+     time; on absence or Node < 22.5 the runtime guard falls back to the
+     current grep/substring path.
+
+2. **Measurement at activation, no speculative harness.** At today's
+   corpus (~85 auto-memory files / 412 KB) the ranked-retrieval lift over
+   grep is zero by construction — the honest-zero is already recorded in
+   the verdict. No grep-vs-ranked benchmark harness is built now. Instead,
+   the pre-decided path carries a clause: when the tripwire fires, reuse
+   the retrieval-economy Phase-0 replay set to measure the grep baseline
+   vs the FTS5 candidate on the then-current corpus BEFORE building; ship
+   only on measured retrieval lift, else record the honest-null and keep
+   grep.
+
+3. **ADR-061 boundary restated.** Memory lookup is a **Reference**
+   operation in ADR-061's four-operation model — memory is never
+   registered as a grounding corpus ("grounding theater"), and
+   `corpus-grounding`'s engine is not forked per domain. This ADR does not
+   amend ADR-061; it confirms the tripwire path lives outside the
+   grounding layer.
+
+4. **Wording migration.** The verdict Q4 "minisearch-class" sentence and
+   the tripwire-table row are amended in the same change; a grep sweep for
+   `minisearch` / "pre-decided BM25" catches stragglers in stable
+   artifacts.
+
+## Consequences
+
+- Firing the tripwire is now a wiring-plus-measurement task, not a design
+  debate: guard fires → replay-set comparison → on lift, ~30-line
+  `node:sqlite` FTS5 schema + query wrapper replacing `_score()`'s
+  substring pass.
+- No new npm dependency at any point on this path; Layer-2 sunset stands
+  (no vectors, no services, no always-on workers).
+- The rejected review items are recorded here so they are not relitigated:
+  a pre-built grep-vs-ranked harness (speculative — measures a known
+  zero), and a deterministic "next step" hot-context field (feature envy
+  absent a real resume-context gap; the LLM-summary ban from the verdict's
+  REJECT-list is untouched).
+
+## Alternatives
+
+- **In-house `bm25_search.ts` as a library** — rejected in the tie-break:
+  no persistence layer; the "zero new deps" advantage evaporated once
+  `node:sqlite` (also zero-dep) was on the table; retrofitting
+  persistence ≈ 200 LOC of database-shaped code SQLite already provides.
+- **minisearch dependency** (verdict Q4's original wording) — rejected:
+  new npm dependency for a problem the built-in module covers; same
+  missing-persistence shape.
+- **Two-step (in-house now, FTS5 escalation later)** — rejected: a
+  pre-decided path must be single and unambiguous; a conditional two-step
+  re-imports the debate the tripwire exists to avoid.
+- **Pre-building the measurement harness now** — rejected: honest expected
+  lift at the current corpus is zero; the replay set from Phase 0 will
+  exist independently and is reused at fire time.
+
+## References
+
+- `agents/roadmaps/road-to-memory-retrieval-economy.md` § Phase 6 (engine
+  note + measurement-at-activation clause).
+- `agents/settings/contexts/second-brain-delta-verdict.md` Q4 (amended
+  wording + tripwire table).
+- `docs/decisions/ADR-061-corpus-grounding-layer.md` (four-operation
+  model; engine-fork ban).
+- `src/scripts/mcp_telemetry_store.ts`, `src/scripts/_lib/node_sqlite.d.ts`
+  (in-repo `node:sqlite` precedent).

package/docs/decisions/INDEX.md

@@ -119,6 +119,7 @@ _Auto-generated by `scripts/adr/regenerate_index.py`. Do not edit._
 | [ADR-113](ADR-113-ci-native-release-label-trigger.md) | Ci Native Release Label Trigger | accepted | 2026-07-08 | — |
 | [ADR-114](ADR-114-commit-policy-iron-law-override.md) | Commit Policy Iron Law Override | — | — | — |
 | [ADR-115](ADR-115-command-cluster-consolidation-phase-4.md) | Command Cluster Consolidation Phase 4 | accepted | 2026-07-08 | — |
+| [ADR-116](ADR-116-memory-tripwire-activation-path.md) | Memory Tripwire Activation Path | accepted | 2026-07-08 | — |
 | [ADR-200](ADR-200-python-to-typescript-migration.md) | Python To Typescript Migration | accepted | 2026-06-11 | — |
 
 ## Unnumbered (legacy)

package/docs/proof.md

@@ -28,13 +28,14 @@ evidence pointer, or `task check-claims` fails the build.
 |---|---|---|---|
 | 172 commands. | quant | `src/scripts/check_artefact_count_messaging.ts#Artefact-count messaging gate` | ✅ |
 | On a weak host (claude-haiku-4-5) the package produces a significant, placebo-controlled discipline lift on scope/downstream traps; on a strong host the same measurement is a published null — the package transplants discipline a weak model lacks, not model intelligence. | quant | `docs/benchmark.md#weak-host-specific` | ✅ |
+| On the READ-ONLY FAN-OUT slice family, tier-downshifted subagent dispatch (lite/haiku vs session-tier-proxy sonnet) nets a ≥30% USD-weighted token-cost reduction at held quality — measured 2026-07-08 (n=10 paired live dispatches, 20 telemetry lines): 10/10 exact-match on BOTH arms, 29.4% fewer raw tokens, 76.5% USD-weighted cost reduction at the 3x haiku↔sonnet price ratio. FAMILY-SCOPED — the mechanical-edit family is unmeasured and its downshift (incl. the deferred tier downgrades of existing units) stays gated. Negative control held: an open-ended synthesis/unknown slice never resolves below the session tier (inferSliceTier → medium/inherit, never lite). | quant | `internal/bench/routing-downshift/results-2026-07-08.md#FAMILY-SCOPED PROVE` | ✅ |
 | The lift-carrying essential cut (kernel + downstream-changes) keeps a significant weak-host discipline lift at a fraction of the full load's tokens, and the lift is FAMILY- and HOST-SCOPED — measured on three hosts: claude-haiku-4-5 (weak) shows the family-scoped lift (trapE 0.533→1.000, 7/7 discordant, corpus cost 1.71x); claude-sonnet-4-6 (strong) is a ceiling null; gpt-5-mini (non-Claude weak, codex prompt-prepend surface) FAILED replication with headroom (corpus Δ=+0.024 p=0.70, capability trend n.s. — no harm claimed, injection-surface confound documented). Therefore discipline_profile: auto enables the lift only where measured (vendor-granular unknown_defaults). Non-claims — the balanced router profile was removed after a NULL measurement (p=0.81, n=24); no full-tier recommendation exists; no cross-vendor lift is claimed. | quant | `docs/benchmark.md#REPLICATION FAILED` | ✅ |
 | The whole layer is compiled into host agents with zero runtime daemon. | qual | `docs/contracts/no-runtime-boundary.md#file-first, no-runtime suite` | ✅ |
 | 95 governed rules. | quant | `src/scripts/check_artefact_count_messaging.ts#Artefact-count messaging gate` | ✅ |
 | 264 skills (README hero + feature list). | quant | `src/scripts/check_artefact_count_messaging.ts#Artefact-count messaging gate` | ✅ |
 | Removes only its own keys from a shared host config (matched by JSON-pointer + SHA-256), never a neighbour tool's entries. | qual | `docs/contracts/install-layout.md#JSON-pointer` | ✅ |
 
-**7 backed claim(s)** — all evidence pointers resolve in CI.
+**8 backed claim(s)** — all evidence pointers resolve in CI.
 
 Artefact counts in public prose (skills, commands, governed rules,
 guidelines, personas) are **generated from source and CI-drift-checked**:

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@event4u/agent-config",
-    "version": "8.5.0",
+    "version": "8.6.0",
     "description": "Universal AI Agent OS — audited skills, governance rules, commands, and templates for AI coding tools (Claude Code, Cursor, Windsurf, Copilot).",
     "license": "MIT",
     "private": false,

package/src/scripts/_lib/auto_dispatch.ts

@@ -93,3 +93,66 @@ export function classifyTask(signals: TaskSignals, activation: ActivationInputs)
     const action: DispatchAction = activation.auto === 'on' ? 'dispatch' : 'ask';
     return { delegable: true, action, mode, reason };
 }
+
+// ── Per-slice tier inference (v1.5 — road-to-cost-aware-model-routing) ──
+
+/**
+ * Task-TYPE outputs the tier inference keys on. NEVER raw size metrics —
+ * size enters only as the negative guard below. Contract:
+ * `auto-dispatch-classification.md § Per-slice tier inference`.
+ */
+export type SliceType =
+    | 'read-only-fanout' // grep / inventory / discovery targets
+    | 'mechanical-covered' // template-driven transform WITH test coverage
+    | 'mutating-uncovered' // mutation without test coverage
+    | 'synthesis' // review / analysis / judgment slice
+    | 'unknown';
+
+export interface SliceTierSignals {
+    slice_type: SliceType;
+    /**
+     * Negative size guard: slice scope exceeds the mechanical envelope
+     * (multi-file mutation / beyond single responsibility). Revokes a `lite`
+     * candidacy — never creates one.
+     */
+    exceeds_mechanical_envelope?: boolean;
+}
+
+export type InferredTier = 'lite' | 'medium' | 'inherit';
+
+export interface TierInference {
+    tier: InferredTier;
+    /** 'inferred' for a real downshift decision; 'inherit' when no inference fired. */
+    tier_source: 'inferred' | 'inherit';
+    reason: string;
+}
+
+/**
+ * Infer a delegable slice's model tier from its task TYPE. Deterministic,
+ * no LLM meta-call. Unknown/ambiguous → inherit (session tier) — never
+ * guess down.
+ */
+export function inferSliceTier(signals: SliceTierSignals): TierInference {
+    const guard = signals.exceeds_mechanical_envelope === true;
+
+    switch (signals.slice_type) {
+        case 'read-only-fanout':
+        case 'mechanical-covered': {
+            if (guard) {
+                return {
+                    tier: 'medium',
+                    tier_source: 'inferred',
+                    reason: `${signals.slice_type} slice, but scope exceeds the mechanical envelope — lite candidacy revoked`,
+                };
+            }
+            const cascade = signals.slice_type === 'mechanical-covered' ? ' (verify-fail escalates to medium)' : '';
+            return { tier: 'lite', tier_source: 'inferred', reason: `${signals.slice_type} slice${cascade}` };
+        }
+        case 'mutating-uncovered':
+            return { tier: 'medium', tier_source: 'inferred', reason: 'mutating slice without test coverage' };
+        case 'synthesis':
+            return { tier: 'medium', tier_source: 'inferred', reason: 'synthesis/judgment slice — judge one tier up' };
+        default:
+            return { tier: 'inherit', tier_source: 'inherit', reason: 'unknown/ambiguous slice type — session tier, never guess down' };
+    }
+}

package/src/scripts/_lib/subagent_routing.ts

@@ -18,6 +18,16 @@
 export type Tier = 'lite' | 'medium' | 'high' | 'inherit';
 export type QuotaPool = 'separate' | 'shared';
 
+/**
+ * Where a resolved tier came from (road-to-cost-aware-model-routing Phase 0):
+ * - 'static'   — declared by frontmatter / category pin,
+ * - 'inferred' — produced by the deterministic per-slice tier inference,
+ * - 'inherit'  — session tier; no downshift decision was made.
+ * Mirrors the `tier_source` telemetry field in
+ * `src/agent-src/contexts/execution/orchestration-telemetry.md`.
+ */
+export type TierSource = 'static' | 'inferred' | 'inherit';
+
 /** Per-tier model alias overrides (empty string = use the tier's runtime default). */
 export interface ModelMap {
     lite?: string;
@@ -35,6 +45,12 @@ export interface RoutingInputs {
     model_map: ModelMap;
     /** From the host-capability manifest. */
     separate_quota_pool: boolean;
+    /**
+     * How `task_tier` was produced: 'static' (frontmatter/category pin) or
+     * 'inferred' (deterministic per-slice inference). Optional — absent
+     * defaults to 'static'. Ignored when the slice runs on the session tier.
+     */
+    task_tier_origin?: Exclude<TierSource, 'inherit'>;
 }
 
 export interface RoutingDecision {
@@ -44,6 +60,8 @@ export interface RoutingDecision {
     model: string;
     /** Whether a separate quota pool is used (bonus) or the shared one. */
     quota_pool: QuotaPool;
+    /** Telemetry value for `tier_source`: 'inherit' when no downshift decision applied. */
+    tier_source: TierSource;
     reason: string;
 }
 
@@ -64,6 +82,11 @@ export function resolveSubagentRouting(inp: RoutingInputs): RoutingDecision {
     const tier: Tier = !inp.downshift || inp.task_tier === 'inherit' ? inp.session_tier : inp.task_tier;
     const downshifted = inp.downshift && inp.task_tier !== 'inherit' && tier !== inp.session_tier;
 
+    // Telemetry provenance: only a real downshift decision carries its origin;
+    // session-tier runs (inherit task, downshift off, or tier == session) are 'inherit'.
+    const applied = inp.downshift && inp.task_tier !== 'inherit';
+    const tier_source: TierSource = applied ? (inp.task_tier_origin ?? 'static') : 'inherit';
+
     // Quota arbitrage: a bonus, only when BOTH the setting and the host allow it.
     const useSeparate = inp.quota_arbitrage && inp.separate_quota_pool;
     const quota_pool: QuotaPool = useSeparate ? 'separate' : 'shared';
@@ -76,6 +99,7 @@ export function resolveSubagentRouting(inp: RoutingInputs): RoutingDecision {
         tier,
         model: modelForTier(tier, inp.model_map),
         quota_pool,
+        tier_source,
         reason: reasonParts.join(' · '),
     };
 }

package/src/scripts/_lib/subagent_steering.ts

@@ -117,6 +117,12 @@ export interface OrchEntry {
     token_delta: number;
     outcome: string;
     verify_mode: string;
+    /** Routing extension (road-to-cost-aware-model-routing) — null on pre-extension lines. */
+    task_class: string | null;
+    tier_chosen: string | null;
+    tier_source: string | null;
+    escalated_from: string | null;
+    verify_result_by_tier: Record<string, string> | null;
 }
 
 /**
@@ -129,9 +135,8 @@ export interface OrchEntry {
  *
  * user_override_rate cannot be measured from telemetry alone — returns 0.
  */
-export function readOrchestrationMetrics(
-    lines: string[],
-): GuardrailMetrics {
+/** Parse orchestration entries from audit-log-v1 JSONL lines (shared by all aggregators). */
+export function parseOrchEntries(lines: string[]): OrchEntry[] {
     const entries: OrchEntry[] = [];
     for (const line of lines) {
         const trimmed = line.trim();
@@ -141,17 +146,33 @@ export function readOrchestrationMetrics(
             if (parsed['input_kind'] !== 'orchestration') continue;
             const orch = parsed['orchestration'] as Record<string, unknown> | undefined;
             if (!orch) continue;
+            const vbt = orch['verify_result_by_tier'];
             entries.push({
                 task_size_estimate: Number(orch['task_size_estimate'] ?? 0),
                 spawn_count: Number(orch['spawn_count'] ?? 0),
                 token_delta: Number(orch['token_delta'] ?? 0),
                 outcome: String(orch['outcome'] ?? ''),
                 verify_mode: String(orch['verify_mode'] ?? ''),
+                task_class: orch['task_class'] == null ? null : String(orch['task_class']),
+                tier_chosen: orch['tier_chosen'] == null ? null : String(orch['tier_chosen']),
+                tier_source: orch['tier_source'] == null ? null : String(orch['tier_source']),
+                escalated_from: orch['escalated_from'] == null ? null : String(orch['escalated_from']),
+                verify_result_by_tier:
+                    vbt != null && typeof vbt === 'object' && !Array.isArray(vbt)
+                        ? Object.fromEntries(Object.entries(vbt as Record<string, unknown>).map(([k, v]) => [k, String(v)]))
+                        : null,
             });
         } catch {
             // skip malformed lines
         }
     }
+    return entries;
+}
+
+export function readOrchestrationMetrics(
+    lines: string[],
+): GuardrailMetrics {
+    const entries = parseOrchEntries(lines);
 
     if (entries.length === 0) {
         return { token_ratio: 1, spawn_failure_rate: 0, verify_skip_rate: 0, user_override_rate: 0 };
@@ -174,3 +195,192 @@ export function readOrchestrationMetrics(
         user_override_rate: 0, // cannot measure from telemetry alone
     };
 }
+
+/**
+ * Per-tier / per-class routing aggregates (road-to-cost-aware-model-routing
+ * Phase 0). Pure aggregation over the routing telemetry fields — feeds the
+ * `/cost:report` per-tier view and the Phase-2 tripwires. Pre-extension lines
+ * (null routing fields) are ignored per aggregate.
+ */
+export interface TierRoutingMetrics {
+    /** Dispatch count per tier_chosen. */
+    dispatches_by_tier: Record<string, number>;
+    /** Dispatch count per task_class. */
+    dispatches_by_class: Record<string, number>;
+    /** Escalation count per task_class (entries with escalated_from set). */
+    escalations_by_class: Record<string, number>;
+    /** escalations_by_class / dispatches_by_class, per class present in both. */
+    escalation_rate_by_class: Record<string, number>;
+    /** Per tier: pass / (pass + fail) over verify_result_by_tier attempts. */
+    verify_pass_rate_by_tier: Record<string, number>;
+}
+
+export function readTierRoutingMetrics(lines: string[]): TierRoutingMetrics {
+    const entries = parseOrchEntries(lines);
+
+    const dispatches_by_tier: Record<string, number> = {};
+    const dispatches_by_class: Record<string, number> = {};
+    const escalations_by_class: Record<string, number> = {};
+    const verifyCounts: Record<string, { pass: number; fail: number }> = {};
+
+    for (const e of entries) {
+        if (e.tier_chosen !== null) {
+            dispatches_by_tier[e.tier_chosen] = (dispatches_by_tier[e.tier_chosen] ?? 0) + 1;
+        }
+        if (e.task_class !== null) {
+            dispatches_by_class[e.task_class] = (dispatches_by_class[e.task_class] ?? 0) + 1;
+            if (e.escalated_from !== null) {
+                escalations_by_class[e.task_class] = (escalations_by_class[e.task_class] ?? 0) + 1;
+            }
+        }
+        if (e.verify_result_by_tier !== null) {
+            for (const [tier, result] of Object.entries(e.verify_result_by_tier)) {
+                const c = (verifyCounts[tier] ??= { pass: 0, fail: 0 });
+                if (result === 'pass') c.pass += 1;
+                else if (result === 'fail') c.fail += 1;
+                // 'skipped' counts toward neither pass nor fail.
+            }
+        }
+    }
+
+    const escalation_rate_by_class: Record<string, number> = {};
+    for (const [cls, n] of Object.entries(dispatches_by_class)) {
+        escalation_rate_by_class[cls] = (escalations_by_class[cls] ?? 0) / n;
+    }
+
+    const verify_pass_rate_by_tier: Record<string, number> = {};
+    for (const [tier, c] of Object.entries(verifyCounts)) {
+        const attempts = c.pass + c.fail;
+        if (attempts > 0) verify_pass_rate_by_tier[tier] = c.pass / attempts;
+    }
+
+    return {
+        dispatches_by_tier,
+        dispatches_by_class,
+        escalations_by_class,
+        escalation_rate_by_class,
+        verify_pass_rate_by_tier,
+    };
+}
+
+/**
+ * Cost-routing tripwires (road-to-cost-aware-model-routing Phase 2) —
+ * steering policy over the routing telemetry, surfaced never auto-flipped.
+ */
+export const ROUTING_TRIPWIRES = {
+    /**
+     * Per-class escalation rate above which the class's static default tier
+     * should be promoted: cascading a class that escalates this often costs
+     * more than starting on the higher tier.
+     */
+    escalation_promotion_rate: 0.4,
+    /** Verify-pass rate drop (absolute) below the trailing baseline that counts as drift. */
+    verify_pass_drift_tolerance: 0.1,
+    /** Minimum dispatches per class before the escalation tripwire may fire (noise floor). */
+    min_class_dispatches: 5,
+} as const;
+
+/**
+ * Tripwire (i): classes whose escalation rate exceeds the promotion
+ * threshold — their static default tier is wrong; promote it, stop cascading.
+ * Classes below the dispatch noise floor never fire.
+ */
+export function escalationPromotionCandidates(m: TierRoutingMetrics): string[] {
+    const candidates: string[] = [];
+    for (const [cls, rate] of Object.entries(m.escalation_rate_by_class)) {
+        const dispatches = m.dispatches_by_class[cls] ?? 0;
+        if (dispatches < ROUTING_TRIPWIRES.min_class_dispatches) continue;
+        if (rate > ROUTING_TRIPWIRES.escalation_promotion_rate) candidates.push(cls);
+    }
+    return candidates.sort();
+}
+
+/**
+ * Tripwire (ii): tiers whose current verify-pass rate dropped below the
+ * trailing baseline by more than the tolerance — verifier or model drift.
+ * Tiers absent from either side are skipped (no baseline → no drift claim).
+ */
+export function verifyPassDrift(
+    current: Record<string, number>,
+    trailingBaseline: Record<string, number>,
+): string[] {
+    const drifting: string[] = [];
+    for (const [tier, baseline] of Object.entries(trailingBaseline)) {
+        const now = current[tier];
+        if (now === undefined) continue;
+        if (now < baseline - ROUTING_TRIPWIRES.verify_pass_drift_tolerance) drifting.push(tier);
+    }
+    return drifting.sort();
+}
+
+/**
+ * Verify-fail escalation (road-to-cost-aware-model-routing Phase 4 / M3).
+ *
+ * A verification FAILURE on a downshifted return re-dispatches the slice one
+ * tier up, consuming the existing N=3 budget — never a new budget. Confined
+ * to tier_source static|inferred; inherit slices keep same-tier retry.
+ * The trigger is the judge verdict / deterministic verify result — never the
+ * subagent's self-reported confidence.
+ */
+export type EscalationTier = 'lite' | 'medium' | 'high';
+
+export interface VerifyFailInputs {
+    /** Tier of the attempt that just failed verification. */
+    failed_tier: EscalationTier;
+    /** Provenance of the slice's tier (telemetry `tier_source`). */
+    tier_source: 'static' | 'inferred' | 'inherit';
+    /** Consecutive failed attempts on this slice INCLUDING the one that just failed. */
+    consecutive_failures: number;
+}
+
+export interface VerifyFailDecision {
+    action: 'escalate' | 'retry-same-tier' | 'slice-failed';
+    /** Tier for the next attempt; null when the slice is failed. */
+    next_tier: EscalationTier | null;
+    reason: string;
+}
+
+const TIER_ABOVE: Record<EscalationTier, EscalationTier | null> = {
+    lite: 'medium',
+    medium: 'high',
+    high: null,
+};
+
+export function escalateOnVerifyFail(inp: VerifyFailInputs): VerifyFailDecision {
+    // Outside the downshift path → existing same-tier retry semantics, budget unchanged.
+    if (inp.tier_source === 'inherit') {
+        if (budgetHalt(inp.consecutive_failures)) {
+            return { action: 'slice-failed', next_tier: null, reason: 'N=3 budget exhausted on session tier' };
+        }
+        return {
+            action: 'retry-same-tier',
+            next_tier: inp.failed_tier,
+            reason: 'inherit slice — no downshift decision, same-tier retry semantics unchanged',
+        };
+    }
+
+    // Downshifted slice: two failed attempts mark the slice failed — the third
+    // "attempt" of the N=3 budget is the orchestrator's replan at session tier.
+    if (inp.consecutive_failures >= 2) {
+        return {
+            action: 'slice-failed',
+            next_tier: null,
+            reason: 'two failed attempts on a downshifted slice — mark failed, orchestrator replans at session tier',
+        };
+    }
+
+    const above = TIER_ABOVE[inp.failed_tier];
+    if (above === null) {
+        return {
+            action: 'slice-failed',
+            next_tier: null,
+            reason: 'verify-fail on the highest tier — no tier above, mark failed and replan',
+        };
+    }
+
+    return {
+        action: 'escalate',
+        next_tier: above,
+        reason: `verify-fail on ${inp.failed_tier} → re-dispatch one tier up (${above}); consumes the N=3 budget`,
+    };
+}