@event4u/agent-config 9.8.0 → 9.10.0

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

@@ -21,20 +21,20 @@ A task is classified **delegable** when **any** of these holds:
    `parallelizable: steps | files | independent` in its frontmatter.
    - `steps` → ordered plan → `do-in-steps`.
    - `files` / `independent` → independent slices → `do-in-parallel`.
-2. **Ordered-plan structure** — explicit ordered plan (numbered steps / a roadmap
-   phase / a checklist) → `do-in-steps`. Deterministic markers:
-   - `1. … 2. … 3.` numbered list in the user message.
-   - References a roadmap phase or checklist.
-   - "first … then … finally" with distinct deliverables.
-   - "in N steps" or "phase by phase".
+2. **Ordered-plan structure** — the task is an explicit ordered plan (numbered
+   steps / a roadmap phase / a checklist) → `do-in-steps`. Deterministic markers:
+   - User message contains `1. … 2. … 3.` numbered list.
+   - User message references a roadmap phase or checklist.
+   - User message uses "first … then … finally" with distinct deliverables.
+   - User message says "in N steps" or "phase by phase".
 3. **Independent-slices structure** — N ≥ 3 independent targets of the same shape
    → `do-in-parallel`. Deterministic markers (N ≥ 3 of the same form):
-   - N file paths, each a separate analysis/edit target.
-   - N named modules/components for the same action.
+   - N file paths listed where each is a separate analysis/edit target.
+   - N named modules/components to perform the same action on.
    - N named test files, adapters, endpoints, or services to convert/review/audit.
-   - "for each X in [list]" where list ≥ 3 items, no cross-item dependency.
-   Do **not** fire on interdependent lists (e.g. "add these 3 sequential
-   migrations") — those are ordered plans (signal 2).
+   - "for each X in [list]" where list has ≥ 3 items and no cross-item dependency.
+   Do **not** fire on lists where items are interdependent (e.g. "add these 3
+   sequential migrations") — those are ordered plans (signal 2).
 
 AND the **task-size floor** is cleared: the task's estimated size exceeds a
 minimum (trivial one-line edits never delegate — the dispatch overhead
@@ -58,9 +58,10 @@ dwarfs the work). Below the floor → in-session.
 ## 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.
+its `model_tier` (road-to-cost-aware-model-routing, council 2026-07-08). The
+inference is keyed **exclusively on the classifier's task-TYPE outputs** —
+never on raw size metrics; diff size anti-correlates with difficulty in
+refactoring domains.
 
 ```
 UNKNOWN / AMBIGUOUS → inherit (SESSION TIER). NEVER GUESS DOWN.
@@ -76,14 +77,86 @@ THEY NEVER CREATE ONE.
 | 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.
+**Negative size guard:** a slice whose scope exceeds the mechanical envelope
+(multi-file mutation, or a diff surface beyond a single responsibility) loses
+its `lite` candidacy and 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.
+Every inferred decision records `tier_source: "inferred"` in the
+orchestration telemetry (statically pinned tiers record `"static"`;
+session-tier runs record `"inherit"`) so the evidence gate can score inferred
+routing separately from static pinning.
+
+## Dispatch-primitive output — fork vs. named subagent (road-to-cache-economy Phase 4)
+
+A third, ORTHOGONAL classifier output — independent of form and tier — on a
+host that exposes a fork primitive alongside named-subagent dispatch:
+
+```
+TOOL AND SCOPE FIT IS FIRST-ORDER. CACHE INHERITANCE IS SECOND-ORDER.
+NEVER "ALWAYS FORK" — THE BENEFIT CANNOT BE PREDICTED BEFORE THE FORK HAPPENS.
+```
+
+| Slice shape | `dispatch_primitive` |
+|---|---|
+| Continues the parent's task under IDENTICAL tools and constraints (no isolation need, no nested dispatch) | `fork` — its first request reads the parent's cache |
+| Needs isolation, a different tool set, or nested dispatch | `subagent` — a fork cannot nest and cannot change tools |
+| Ambiguous / host has no fork primitive | `subagent` — the only primitive this suite's `Agent`-tool dispatch uses today |
+
+A fork forces background mode, which changes the tool set and therefore
+invalidates the very prefix that motivated the fork — so a slice that would
+need a different tool set mid-flight is a `subagent` candidate even when it
+started as a fork candidate. This output never downgrades the form or tier
+decisions above; it only picks the primitive once a `parallel` / `steps` /
+`judge` form has already been selected. See
+[`subagent-orchestration/SKILL.md`](../../skills/subagent-orchestration/SKILL.md)
+§ Form gate and
+[`prompts/README.md`](../../skills/subagent-orchestration/prompts/README.md)
+§ Prompt-cache discipline for the full rationale.
+
+## Lookup-class rung (L0 — road-to-lean-agent-init, BELOW the tiers)
+
+Before any spawn decision, a lookup-shaped task routes to a **deterministic
+primitive** — no subagent, no tier. Live evidence (2026-07-28): four
+`general-purpose` workers burned ~1.21M tokens on four lookup tasks a
+primitive answers for <1k each.
+
+```
+LOOKUP-SHAPED TASK → DETERMINISTIC PRIMITIVE. NO SUBAGENT SPAWN.
+INDEX-MISS OR GENUINE AMBIGUITY → REGULAR ESCALATION TO A SUBAGENT —
+NEVER A SILENTLY DEGRADED ANSWER. NO LLM CLASSIFIER FALLBACK (CUT C3).
+```
+
+| Task pattern | Lookup class | Primitive |
+|---|---|---|
+| "where is X defined" / "confirm X's definition location" | `definition` | capped `rg` (definition-shaped patterns, `--max-count`); `code_graph query` only as an opportunistic accelerant when an index is present + fresh + `hooks.code_graph.enabled: true` |
+| "who calls / imports X" / "confirm call sites" | `references` | capped `rg` (reference-shaped patterns); same optional `code_graph affected` accelerant clause |
+| "does string Y exist" / "probe candidate strings" | `string-existence` | FTS one-shot (`memory_lookup` for the knowledge corpus) or capped `rg -n --max-count` for the codebase |
+| "run report Z" / "run check_*" | `report-run` | direct script run, wrapped per the **measured** rtk allowlist (`internal/bench/rtk-savings/RESULTS.md` — wrap only the ~55%-savings class) |
+
+**Why rg-first for definition/references** (council debate 2026-07-28,
+claude-sonnet-4-5 + gpt-4o, 2 rounds): the pre-registered benchmark behind the
+`code-graph-retrieval-null` claim (`docs/CLAIMS.md`) measured native-graph
+recall 0.365 vs grep 0.797 on graph-shaped questions, root cause an **indexing
+gap** (TS arrow-function exports produce no symbol nodes) that hits structured
+lookups exactly as it hits NL retrieval — and the recorded consequence bound
+keeps `code_graph.enabled` false permanently. The accelerant clause is the
+escape hatch that bound names ("unless external evidence appears"); today it
+is inert.
+
+**Escalation, not degradation:** a primitive that returns nothing (index miss,
+pattern too ambiguous, report script absent) — **or an unusable result**
+(empty, ambiguous between candidates, or visibly off-target because the
+lookup pattern matched a task that was not actually a lookup, e.g. a
+dynamically constructed symbol name) — escalates to the regular
+classification path above — the answer quality bar never drops. The
+"primitive ran but the result is unusable" case escalates exactly like the
+"class unknown" case. `unknown` resolves to the regular path (`inherit`
+semantics), never down-guessed.
+
+Correctness floor: the golden comparison in `internal/bench/lean-init/`
+(primitive answer ≡ agent answer on ≥10 lookup tasks, including the four
+observed shapes); any mismatch is a routing bug, not a rounding error.
 
 ## v2+ (deferred, gated on Phase 6 evidence)
 
@@ -95,8 +168,11 @@ budgeted (consume part of the N=3 autonomous budget) and opt-in. Not in v1.
 
 The deterministic rules are encoded in
 [`src/scripts/_lib/auto_dispatch.ts`](../../../../src/scripts/_lib/auto_dispatch.ts)
-(`classifyTask`), covered by
-[`tests/scripts/_lib_auto_dispatch.test.ts`](../../../../tests/scripts/_lib_auto_dispatch.test.ts).
+(`classifyTask`, `classifyLookup` for the lookup-class rung), covered by
+[`tests/scripts/_lib_auto_dispatch.test.ts`](../../../../tests/scripts/_lib_auto_dispatch.test.ts)
+and the lookup corpus in
+[`src/scripts/_lib/auto_dispatch.corpus.test.ts`](../../../../src/scripts/_lib/auto_dispatch.corpus.test.ts)
+(`LOOKUP_CORPUS` — the four live-observed shapes + negative controls).
 
 ## Related
 

package/dist/agent-src/contexts/execution/auto-orchestration-activation.md

@@ -12,7 +12,7 @@ whether dispatch is physically possible on the host).
 | Key | Default | Purpose |
 |---|---|---|
 | `subagents.enabled` | `true` | Global master switch. `false` = the whole layer is off — the canonical kill-switch. No auto-dispatch, no routing, everything runs in-session. |
-| `subagents.auto` | `on` | Auto-dispatch mode: `off` \| `ask` \| `on`. Default `on` on subagent-capable hosts (flipped from `ask` 2026-07-09, ADR-117), `off` elsewhere. |
+| `subagents.auto` | `on` | Auto-dispatch mode: `off` \| `ask` \| `on`. Shipped default `on` on subagent-capable hosts (flipped from `ask` 2026-07-09, ADR-117), `off` elsewhere. |
 | `subagents.downshift` | `true` | Route delegable sub-tasks to the lowest-capable tier (Phase 2). |
 | `subagents.quota_arbitrage` | `true` | Prefer a separate-quota-pool model where the host manifest allows it (Phase 2 bonus). |
 | `subagents.model_map` | `{}` | Optional per-tier model override for downshift routing. |

package/dist/agent-src/contexts/execution/autonomy-examples.md

@@ -53,7 +53,7 @@ or `auto`-after-opt-in, act on them.
 - "Should we commit now or after the next change?" — answered by the
   commit-default in [`commit-policy`](../../rules/commit-policy.md), no need to ask.
 - "How should I split the commits?" — never asked; either you are
-  invoked via `/commit-in-chunks` (split and commit) or you are not
+  invoked via `/commit:in-chunks` (split and commit) or you are not
   (don't commit at all).
 - "Should I run the linter / tests now or after the change?" — run
   what [`verify-before-complete`](../../rules/verify-before-complete.md)

package/dist/agent-src/contexts/execution/autonomy-mechanics.md

@@ -129,12 +129,13 @@ knob. The per-dimension uncertainty score (see
 [`notes-first-reasoning`](../../rules/notes-first-reasoning.md)) feeds this
 decision. Engage per [`rdp-gate`](rdp-gate.md).
 
-**Concrete diminishing-returns stop-signal.** Operationalize "marginal evidence
-drops" so it is checkable, not vibes: when **two consecutive investigative probes**
-(a read, a grep, a query) yield **no new load-bearing information** — nothing that
-changes the plan or the hypothesis — stop gathering and act on what you have (or
-ask). The diminishing-returns twin of N=3: N=3 stops fruitless *fixing*, this stops
-fruitless *searching*. Never overrides the read-loop abort in
+**Concrete diminishing-returns stop-signal.** "Marginal evidence drops" is
+otherwise fuzzy; operationalize it so it is checkable, not vibes: when **two
+consecutive investigative probes** (a read, a grep, a query) yield **no new
+load-bearing information** — nothing that changes the plan or the hypothesis —
+stop gathering and act on what you have (or ask). This is the diminishing-returns
+twin of the N=3 hard cap: N=3 stops fruitless *fixing*, this stops fruitless
+*searching*. It never overrides the read-loop abort in
 [`context-hygiene`](../../rules/context-hygiene.md) — that is the hard ceiling;
 this is the earlier soft signal.
 

package/dist/agent-src/contexts/execution/evidence-discipline.md

@@ -1,9 +1,10 @@
 # Evidence Discipline — Report format, provenance, enforcement reality
 
-Canonical definitional spine for evidence-first structure discipline. Loaded by
-[`source-discovery`](../../rules/source-discovery-gate.md) rule and skill. Skill
-holds the *procedure*; this file holds the *definitions* every later phase, the
-linter, and ADRs refer back to.
+Canonical definitional spine for the evidence-first structure discipline. Loaded
+by the [`source-discovery`](../../rules/source-discovery-gate.md) rule and the
+[`source-discovery`](../../skills/source-discovery/SKILL.md) skill. The skill
+holds the *procedure* (how to discover each surface); this file holds the
+*definitions* every later phase, the linter, and the ADR refer back to.
 
 ## The invariant
 
@@ -13,78 +14,86 @@ EVERY FIELD, ENDPOINT, COLUMN, AND VALUE TRACES TO file:line · SDL · migration
 LOCAL BEFORE REMOTE. REAL SOURCE BEFORE GUESSING.
 ```
 
-Product is a **discipline**, not a knowledge database. A card is only an optional
-cache for *expensive* evidence — never a source of truth, never a build input.
+The product is a **discipline**, not a knowledge database. A card is only an
+optional cache for *expensive* evidence — never a source of truth, never a
+build input.
 
-## Evidence Report — discovery output
+## Evidence Report — the discovery output
 
-Gitignored session scratchpad (`agents/memory/knowledge/session/`, overwritten each
-task), produced **before** the plan, soft-capped to ~10–20 decision-relevant facts.
-Three buckets:
+A gitignored session scratchpad (`agents/memory/knowledge/session/`, overwritten
+each task), produced **before** the plan, soft-capped to ~10–20 decision-relevant
+facts (a smell-test, not a hard gate). Three buckets:
 
 - **Verified** — confirmed **this session** against a real source, **or** durable
-  committed-card content (negative facts + pointers, pointer-CI green). Nothing else qualifies.
-- **Assumed (from card)** — positive structural claims from a committed card but
-  **not** confirmed this session; explicitly a hypothesis. A card's positive structure
-  is **never** "Verified", even with a green pointer (R4 P1).
+  committed-card content (negative facts + pointers, pointer-CI green). Nothing
+  else qualifies.
+- **Assumed (from card)** — positive structural claims taken from a committed
+  card but **not** confirmed this session; explicitly a hypothesis. A card's
+  positive structure is **never** "Verified", even with a green pointer (R4 P1).
 - **Gaps** — missing evidence the decision needs (negative facts in the making).
 
-Feeds the plan. Not a forensic log, not hard enforcement. Produce cheaply via
-`evidence_report.ts` so it never gets skipped.
+It feeds the plan. It is **not** a forensic log and is **not** hard enforcement.
+Produce it cheaply via `evidence_report.ts` (template automation) so it never
+gets skipped.
 
 ## Provenance and freshness
 
-- Every item carries `observed_at`, `source`, `version` where one exists. Card
-  **positive-structure lines** carry **per-line** `observed_at` / `source_version` (R4 P5).
-- **Within a session:** read is fresh until file's **mtime** changes.
-- **Invalidate all session reads when `git rev-parse HEAD` changes** — new HEAD means
-  tree may have moved.
-- **Fail-fast mid git-op:** if rebase/merge/cherry-pick is in progress
-  (`.git/MERGE_HEAD`, `.git/CHERRY_PICK_HEAD`, or `.git/rebase-merge`/`rebase-apply`
-  present), do **not** read an intermediate tree — stop and surface it (R4 P6,
-  hole-3). *(`.git/REBASE_HEAD` excluded — lingers as stale ref after completed
-  rebase, not a live-op marker.)* `evidence_report.ts git-state` is the
-  deterministic check.
+- Every evidence item carries `observed_at`, `source`, and `version` where one
+  exists. Card **positive-structure lines** carry **per-line** `observed_at` /
+  `source_version` (R4 P5).
+- **Within a session:** a read is fresh until the file's **mtime** changes.
+- **Invalidate all session reads when `git rev-parse HEAD` changes** — a new HEAD
+  means the tree may have moved under you.
+- **Fail-fast mid git-op:** if a rebase/merge/cherry-pick is in progress
+  (`.git/MERGE_HEAD`, `.git/CHERRY_PICK_HEAD`, or a `.git/rebase-merge`/
+  `rebase-apply` directory present), do **not** read an intermediate tree — stop
+  and surface it (R4 P6, hole-3). *(`.git/REBASE_HEAD` is excluded — it lingers as
+  a stale ref after a completed rebase and is not a live-op marker.)* The
+  `evidence_report.ts git-state` subcommand is the deterministic check.
 - **Across sessions:** always re-read. No file hashing, no content-hash theater.
 
 ## Two-file split
 
 | File | Home | Tracked? | Holds |
 |---|---|---|---|
-| **Ephemeral session cache** | `agents/memory/knowledge/session/` | gitignored | Evidence Report + raw probe/introspection dumps + absence-search log |
+| **Ephemeral session cache** | `agents/memory/knowledge/session/` | gitignored | Evidence Report + raw probe/introspection dumps + the absence-search log |
 | **Committed card** | `agents/knowledge/<source>.md` | tracked | thin distillation: `trust: durable` negative facts + pointers; positive structure as per-line last-verified hypothesis |
 
-Committed card extends `context-document` mechanism (a specialized context type)
-— **not** a second knowledge system.
+The committed card extends the `context-document` mechanism (a specialized
+context type) — it is **not** a second knowledge system.
 
 ## DB-not-in-codebase boundary (R4 P2)
 
-- **In-codebase** = schema defined by repo migrations / models / ORM / app code —
-  **including** schemaless stores the app controls (Mongoose, Prisma, Firestore
-  rules). → always **local, read fresh, no card**.
+- **In-codebase** = the schema is defined by repo migrations / models / ORM /
+  app code — **including** schemaless stores whose shape the app controls
+  (Mongoose, Prisma, Firestore rules). → always **local, read fresh, no card**.
 - **DB-not-in-codebase** = no repo migrations/models/app-code define the schema
-  **and** app does not control it (vendor SaaS, partner, legacy DB). → may be
+  **and** the app does not control it (vendor SaaS, partner, legacy DB). → may be
   **card-worthy** (remote evidence).
 
 ## Negative facts (R4 P4)
 
 A negative fact is a **current-state fact** — "searched X, did not find Y" — not a
-card-worthiness *decision* (belongs in notes/ADR, never an anti-hallucination card).
-Write a negative-fact card **only after search is exhausted across all relevant
-sources**, logging `searched` *and* `not_searched`, attach a `revalidate_if` trigger.
+card-worthiness *decision* (that belongs in notes/ADR, never an anti-hallucination
+card). Write a negative-fact card **only after the search is exhausted across all
+relevant sources** for that claim, logging `searched` *and* `not_searched`, and
+attach a `revalidate_if` trigger (e.g. "an OpenAPI spec / contracts dir is added").
 
 ## Card-worthiness threshold (R3 F-3, R4 P2/P7)
 
 Card-worthy = **(external package / remote API / DB-not-in-codebase)** AND **(≥3
-distinct methods/fields *intended* to be used OR source exposes >50 methods and ≥1
-is used OR prior hallucination OR local types/README insufficient)**. Judged on
-**intended** use at discovery. Cross-feature duplication check flags structure
-discovered in >1 session without a card as "should-have-been-card-worthy".
+distinct methods/fields *intended* to be used OR the source exposes >50 methods
+and ≥1 is used OR a prior hallucination on it OR local types/README are
+insufficient)**. Judged on **intended** use at discovery — a card may be upgraded
+later if usage grows, so it is still built *before* coding. A cross-feature
+duplication check flags structure discovered in >1 session without a card as
+"should-have-been-card-worthy".
 
 ## L0–L4 — descriptive, not prescriptive
 
-L0–L4 are human shorthand for discovery depth; documentation only. **Same** evidence
-rules apply at every tier — no enforced state machine, no per-tier relaxation.
+L0–L4 are human shorthand for how deep a discovery went; they are documentation
+only. The **same** evidence rules apply at every tier — no enforced state
+machine, no per-tier evidence relaxation.
 
 ## Honest enforcement reality
 
@@ -94,55 +103,61 @@ A MODEL THAT INVENTS A FIELD CAN ALSO WRITE A FALSE "VERIFIED".
 THE TEETH ARE POINTER-CI (DETERMINISTIC) + THE ANTI-HALLUCINATION EVAL (EMPIRICAL).
 ```
 
-- **Instrumentation (soft):** Evidence Report and any `card_claims` self-log. Useful
-  signal; never oversold as a guarantee.
+- **Instrumentation (soft):** the Evidence Report and any `card_claims` self-log.
+  Useful signal; never oversold as a guarantee.
 - **Teeth (hard):** pointer-resolution CI (path exists / URL 200, strict-mode
-  content-compare) + multi-evidence git-ancestry consistency check +
-  per-surface anti-hallucination eval with variance baseline.
+  content-compare) + the multi-evidence git-ancestry consistency check +
+  the per-surface anti-hallucination eval with a variance baseline.
 
 ## Global layer (v2 — cross-project card sharing, ADR-100)
 
-An *expensive* (remote) card may be promoted from project-local `agents/knowledge/`
-to per-user **file-first** global store at `~/.event4u/agent-config/knowledge/`
-(no daemon / DB / vector index / decay — 2026-06-14 Layer-2 sunset's core preserved).
-**Storage, not governed** like a committed card: unversioned, a cache, never a source
-of truth. Gated by `knowledge.global_sharing` setting (**default OFF until
-cross-project reuse is measured across ≥ 2 real projects** — ADR-103 amends ADR-100
-Phase 0; `enabled: false` fully no-ops the layer — v1 unaffected; operator opts in
-explicitly; default flips back only on positive reuse signal).
-
-- **Global card is a distillation, not a copy.** `trust: durable` core is
-  **negative facts + pointers**; positive structure is explicit per-line
-  **hypothesis** — never copied as build input.
-- **Leads-only consumption.** Global card enters Evidence Report as **"Assumed (from
-  card · GLOBAL, unverified)"** — positive structure must be re-confirmed against
-  live source *this session*. Negative facts + pointers are usable as leads.
-  Global-sourced positive structure is **never** "Verified".
-- **Origin-tier scoping is the privacy floor.** `public` auto-shareable; `vendor`
-  shareable **post-redaction**; `proprietary` **manual-only, default-off regardless
-  of `enabled`** — no client-A schema leaks into client-B.
-- **Redaction on write.** Promotion runs the `low-impact-corpus-privacy-floor` +
-  `source-confidentiality` pattern set and **halts** on any hit — never
+An *expensive* (remote) card may be promoted from project-local
+`agents/knowledge/` to a per-user **file-first** global store at
+`~/.event4u/agent-config/knowledge/` (no daemon / DB / vector index / decay —
+the 2026-06-14 Layer-2 sunset's core is preserved). It is **storage, not
+governed** like a committed card: unversioned, a cache, never a source of
+truth — the per-card provenance footer is its audit trail. Gated by the
+user-global `knowledge.global_sharing` setting (**default OFF until cross-project
+reuse is measured across ≥ 2 real projects** — ADR-103 amends ADR-100 Phase 0;
+`enabled: false` fully no-ops the layer — v1 unaffected; an operator opts in
+explicitly and the default flips back only on a positive reuse signal).
+
+- **A global card is a distillation, not a copy.** Its `trust: durable` core is
+  **negative facts + pointers**; positive structure is an explicit per-line
+  **hypothesis** — the same shape as a committed card, never positive structure
+  copied as a build input.
+- **Leads-only consumption.** A global card loaded in a consuming project enters
+  the Evidence Report under **"Assumed (from card · GLOBAL, unverified)"** — its
+  positive structure must be re-confirmed against the live source *this session*
+  before use (version skew, schema drift). Negative facts + pointers are usable
+  as leads. Global-sourced positive structure is **never** "Verified".
+- **Origin-tier scoping is the privacy floor.** `public` (registry / GitHub /
+  docs) auto-shareable; `vendor` (Stripe / AWS / …) shareable **post-redaction**;
+  `proprietary` (in-house DB / private API / client schemas) **manual-only,
+  default-off regardless of `enabled`** — no client-A schema leaks into client-B.
+- **Redaction on write.** Promotion runs the `low-impact-corpus-privacy-floor`
+  + `source-confidentiality` pattern set and **halts** on any hit — never
   silent-shares, never auto-rewrites.
-- **Promotion is hybrid.** Card seen in ≥`auto_promote_threshold` distinct repos
-  triggers a one-tap **suggestion**; never a silent write.
+- **Promotion is hybrid.** A `public`/`vendor` card seen in ≥`auto_promote_threshold`
+  distinct repos triggers a one-tap **suggestion**; never a silent write.
 
 ## Evidence v2 rollback target (Phase 0)
 
 Evidence v2 (self-building project context — Class A config-pointers, Class B
-observed conventions, Class C learned lessons) is an **additive** layer. Rollback
-target is fixed and measurable:
+observed conventions, Class C learned lessons) is an **additive** layer. Its
+rollback target is fixed and measurable:
 
 ```
 v2 ROLLBACK = DISABLE ALL CURATED ACCUMULATED CONTEXT EXCEPT CLASS-A CONFIG-POINTERS.
 THE MEASURABLE BASELINE TO REVERT TO IS v1 DISCIPLINE WITH NO ACCUMULATED CONTEXT.
 ```
 
-Class A (config-derived pointers) is deterministic, drift-proof, no accumulation
-risk → survives rollback. Class B/C are accumulation layers; if v2 eval shows
-accumulated context raises error rate or cost is disproportionate, those layers are
-disabled and agent runs v1 alone — acceptable outcome. "Self-improving" is a
-hypothesis, not a law; rollback target makes the hypothesis falsifiable.
+Class A (config-derived pointers) is deterministic, drift-proof, and carries no
+accumulation risk, so it survives a rollback. Class B/C are the accumulation
+layers; if a v2 eval shows accumulated context raises the error rate or its cost
+is disproportionate, those layers are disabled and the agent runs on v1 discipline
+alone — an acceptable outcome (v1's value stood on its own). "Self-improving" is a
+hypothesis, not a law; the rollback target is what makes the hypothesis falsifiable.
 
 ## See also
 

package/dist/agent-src/contexts/execution/orchestration-benchmark-gate.md

@@ -1,19 +1,20 @@
 # Orchestration Benchmark & Demotion Gate (Phase 6 → telemetry-demotion)
 
 Originally the falsification gate the auto-orchestration roadmap was built
-around: shipped default for `subagents.auto` would flip toward `on` only on a
-benchmark proving a net win at held quality.
+around: the shipped default for `subagents.auto` would flip toward `on` only
+when a real benchmark proved a net win at held quality.
 
 **As of 2026-07-09 the shipped default IS `on`** on subagent-capable hosts
 (ADR-117; [`orchestration-default-flip-verdict`](../../../../agents/settings/contexts/orchestration-default-flip-verdict.md)
-§ 2026-07-09). Flipped on a **bounded-downside re-evaluation**, not a passed
-benchmark: rigorous paired bench:ab not producible here (no runtime executing
-model `Task`/`Agent` calls), win-validation deadlocked (telemetry needs `on`,
-`on` gated on telemetry). Re-eval broke the deadlock — downside of `on` is
-structurally small (delegable slices cost-routed to cheapest tier,
-classification fires only on real structural signals, every return verified) →
-`on` gathers realized telemetry responsibly. This gate now governs
-**demotion**: measured regression flips default back to `ask`.
+§ 2026-07-09). It was flipped on a **bounded-downside re-evaluation**, not a
+passed benchmark: a rigorous paired bench:ab is not producible in this harness
+(no runtime that executes model `Task`/`Agent` calls), and the win-validation
+was deadlocked (telemetry needs `on`, `on` was gated on telemetry). The
+re-evaluation broke the deadlock by showing the downside of `on` is
+structurally small — delegable slices are cost-routed to the cheapest capable
+tier, classification fires only on real structural signals, every return is
+verified — so `on` gathers the realized telemetry responsibly. This gate now
+governs **demotion**: a measured regression flips the default back to `ask`.
 
 ## Measurement — pin the method
 
@@ -42,18 +43,18 @@ HONEST-NULL EXIT: no win, or quality regressed → KEEP the conservative default
 
 ## Default state + demotion — host-gated
 
-Shipped default for `subagents.auto` is `on` on hosts whose manifest reports
-`subagent_spawn: true` (`off` elsewhere) — set directly in
+The shipped default for `subagents.auto` is `on` on hosts whose capability
+manifest reports `subagent_spawn: true` (`off` elsewhere) — set directly in
 `src/config/agent-settings.template.yml`. `resolveShippedDefault()` remains the
-host-gated resolver, now serving **demotion**: fed a `fail` verdict from
-accumulated real-world orchestration telemetry, resolves back to `ask`
-(conservative). A `pass` keeps `on`. Demotion path is a one-line edit,
-host-gated by the manifest at runtime.
+host-gated resolver and now serves **demotion**: fed a `fail` verdict from
+accumulated real-world orchestration telemetry, it resolves back to `ask`
+(conservative). A `pass` verdict keeps `on`. The demotion path is a one-line
+edit, host-gated by the manifest at runtime.
 
-The 2026-07-09 flip reconciles the user's "default on" goal with the council's
-"prove-first": rather than wait on a benchmark that cannot be produced here,
-`on` ships because its downside is bounded and reversible, and realized
-telemetry is now free to accrue and drive demotion if it regresses.
+The 2026-07-09 flip is the reconciliation of the user's "default on" goal with
+the council's "prove-first": rather than wait on a benchmark that cannot be
+produced here, `on` ships because its downside is bounded and reversible, and
+realized telemetry is now free to accrue and drive demotion if it regresses.
 
 ## Reproducibility
 
@@ -69,7 +70,7 @@ is auditable rather than asserted.
 
 ## Related
 
-- ADR-118 (`docs/decisions/ADR-118-loop-engineering-boundaries.md`) — demotion stays manual human edit by decision; never automated (disposition #1).
+- ADR-118 (`docs/decisions/ADR-118-loop-engineering-boundaries.md`) — demotion stays a manual human edit by decision; never automated (disposition #1).
 - [`auto-orchestration-activation`](auto-orchestration-activation.md) — the `subagents.auto` key this gate sets the default for.
 - [`host-capability-manifest`](host-capability-manifest.md) — `subagent_spawn` gates the flip.
 - [`orchestration-telemetry`](orchestration-telemetry.md) — the per-dispatch metrics the benchmark aggregates.

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

@@ -56,6 +56,16 @@ v1 forward-compat rule on unknown fields).
 | `session_tier` | string \| null | **Cost-% extension.** The orchestrator's OWN tier — the baseline the downshift cost-% measures `tier_chosen` against (a `high`→`lite` downshift is a rate win the token count can't see). `null` = not recorded. |
 | `first_pass_success` | bool \| null | **QUALITY extension (council verdict: quality × cost paired).** `true` = the subagent return was adopted without parent rework; `false` = the parent had to rework the return before adopting. Precise rework definition: § Operationalization below. `null` = pre-extension line / not measured. Boolean only, no bodies. |
 | `escalated` | bool \| null | **QUALITY extension (council verdict: quality × cost paired).** `true` = the slice was retried on a higher tier after a verification failure; `false` = no escalation. Semantics: § Operationalization below. `null` = pre-extension line / not measured. Boolean only, no bodies. |
+| `init_tokens` | int \| null | **Lean-init extension (road-to-lean-agent-init Phase 3).** Spawn-payload tokens at worker init — the payload-truth measurement feeding the Phase-5 baseline gate (p95 < ~1,500 tokens/worker drops the L2/L3 bets). `null` = not measured. Counts only. |
+| `payload_hash` | string \| null | **Lean-init extension.** 8–64-char hex digest of the spawn payload — prefix-stability / cache measurement. A hash can never smuggle content (privacy by construction). `null` = not measured. |
+| `lookup_class` | enum \| null | **Lean-init extension.** Lookup class the L0 rung matched: `definition` · `references` · `string-existence` · `report-run`. `null` = not a lookup-shaped dispatch. |
+| `route_taken` | enum \| null | **Lean-init extension.** `primitive` (deterministic primitive answered — no spawn) · `subagent` (escalated). With `lookup_class`, measures the tool-not-agent rung's hit rate. A `primitive` line is the ONE recordable zero-spawn event (`spawn_count: 0`) — the routing decision itself is the datum the cost claim reads. |
+| `budget_hit` | bool \| null | **Lean-init extension.** Worker hit its `max_tokens_per_worker` stop-loss (L0b) and returned the structured partial result. Feeds budget-seed refinement. `null` = not measured. |
+| `correctness_match` | bool \| null | **Lean-init extension.** Golden/correctness comparison verdict for a primitive route (primitive answer ≡ agent answer). Populated only when a comparison arm actually ran (bench/golden mode); on real zero-spawn primitive routes there is no agent answer to compare against, so `null` is the NORMAL field value — never read `null` as "unchecked = suspicious". |
+| `cache_hit` | bool \| null | **Lean-init extension (Phase 4 prefix stability).** Provider-reported prompt-cache hit on the spawn payload. Measurement only — no savings claim without provider-response evidence. `null` = not measured. |
+| `origin` | string \| null | **Lean-init extension (council Q5 segregation).** Id-shaped sample tag (`lean-init-2026`) keeping lean-init efficiency lines cleanly separable from the `road-to-orchestration-scope-decision` sample. `null` = untagged line. Never free-form. |
+| `rules_carried` | int \| null | **Lean-init extension (L6 demand signal).** Rules in the worker's scoped projection — the carried set. With `rules_used`, yields the per-worker rule-usage quota the parked `later/road-to-deferred-rule-retriever` resume condition asks for ("are worker rules actually carried unused?"). `null` = not measured. Counts only. |
+| `rules_used` | int \| null | **Lean-init extension (L6 demand signal).** Rules the worker actually applied/cited. Validation: never exceeds `rules_carried`. `null` = not measured. Counts only. |
 
 These routing + cost fields are additive and optional — a line without them is
 still a valid orchestration line; readers ignore unknown fields per the v1
@@ -175,6 +185,30 @@ derivable from this data. A percentage would require an additive
 absolute-baseline field on this object (deferred follow-up). Reader:
 [`src/scripts/_lib/orchestration_savings.ts`](../../../../src/scripts/_lib/orchestration_savings.ts).
 
+## Payload-hash drift report (`payload_hash` × `cache_hit`)
+
+Join the two fields into a stable/unstable prefix-stability cohort split:
+
+```bash
+./scripts-run src/scripts/orchestration_payload_hash_drift [--dir <path>] [--format text|json]
+```
+
+Reader: [`src/scripts/_lib/payload_hash_drift.ts`](../../../../src/scripts/_lib/payload_hash_drift.ts).
+Zero recorded lines carrying both fields is the current expected state — both
+are lean-init extensions with no caller wiring a real value into them yet;
+the report says so rather than presenting empty input as a pass.
+
+**Refusal (report, never act).** `cache_hit` is a provider-reported proxy for
+HOST-controlled cache behaviour — this package causes the dispatch but does
+not control whether the host reports a hit. Per
+[`ADR-118`](../../../../docs/decisions/ADR-118-loop-engineering-boundaries.md)
+§1 (a measure→adjust loop is automated only when it is a *direct* measure of
+the failure mode, the false-positive rate is low, and human judgement adds no
+unique information), a host-controlled proxy fails the direct-measure
+condition outright. No consumer of `payload_hash` or `cache_hit` may wire a
+measure→adjust step off them — no default flip, no tier change, no dispatch
+throttle. They are read-only diagnostic fields.
+
 ## Related
 
 - [`audit-log-v1`](../../../../docs/contracts/audit-log-v1.md) — the frozen