@event4u/agent-config 5.6.1 → 5.7.0

package/docs/decisions/ADR-037-cost-profile-untangle.md

@@ -0,0 +1,117 @@
+---
+adr: 037
+status: accepted
+date: 2026-06-01
+decision: cost-profile-untangle
+supersedes: —
+superseded_by: —
+phase: cost-profile-untangle
+type: structural
+review_date: 2026-09-01
+---
+
+# ADR-037 — Untangle `cost_profile` into single-purpose settings
+
+## Status
+
+**Accepted** · 2026-06-01. AI Council (anthropic/claude-sonnet-4-5 +
+openai/gpt-4o, analysis lens, 3 rounds, 2026-06-01) converged on the
+rename + keep-decoupled design below; findings were critically evaluated
+against the codebase before adoption.
+
+## Context
+
+The `cost_profile` setting had accreted multiple responsibilities plus a
+hard naming collision:
+
+1. **Canonical meaning** — rule-tier loading (`minimal | balanced | full |
+   custom`), a token-footprint lever resolved from `dist/router.json`.
+2. **Colliding second meaning** — a separate contract
+   (`memory-visibility-v1`) and the work-engine hook read the *same key*
+   `cost_profile` with an incompatible value set (`lean | standard |
+   verbose`) to gate the `🧠 Memory` visibility-line cadence. Because no
+   real install ever wrote `cost_profile: lean`, the suppress branch was
+   **unreachable dead code**.
+3. **Default drift** — the default was declared in four places with three
+   different answers (`balanced`, `minimal`, `standard`).
+4. **Migrated intent** — `cost_profile` was originally meant to gate
+   self-optimization; that capability had already moved to the independent
+   `pipelines.skill_improvement` setting + tier-2a rule loading.
+5. **Naming confusion** — four "cost"-sounding concepts (`cost_profile`,
+   the memory cadence, `/cost:report` + `cost.budgets`, and
+   `model_tier`/`model.auto_switch`) competed for one mental slot; only the
+   first two were literally named `cost_profile`, and the second was the
+   broken one.
+
+The root cause was the absence of a settings schema: nothing prevented one
+key from carrying two value vocabularies.
+
+## Decision
+
+1. **One key, one job.** Rename the canonical setting `cost_profile` →
+   `rule_loading_tier` (values unchanged: `minimal | balanced | full |
+   custom`). The name now describes the mechanism, not a side effect, which
+   makes the `/cost:report` mismatch obvious ("you can't lower your rule
+   loading tier to save money without losing guardrails").
+2. **Memory cadence owns its own key.** The visibility-line cadence moves
+   to `memory.cadence` (`auto | always | never`, default `always` —
+   behaviour-neutral; the previously-dead suppress path is now reachable as
+   `auto`). Named `memory.cadence`, not `memory_status`, to avoid a clash
+   with the existing `scripts/memory_status.py`.
+3. **Self-optimization stays decoupled.** `pipelines.skill_improvement`
+   remains the independent lever; `rule_loading_tier` is *not* re-coupled to
+   learning behaviour. The council was unanimous that coupling token
+   footprint to learning behaviour is the wrong axis.
+4. **Schema prevents recurrence.** A new
+   `scripts/schemas/agent-settings.schema.json` (+ CI validator) enum-
+   constrains the value-bearing keys so a value-vocabulary collision is a
+   hard CI failure, not silent dead code.
+5. **Migration, not break.** `install.py`'s `LEGACY_RENAME_MAP` rewrites
+   `cost_profile` → `rule_loading_tier`; loaders read the legacy key as a
+   fallback during a grace period. The default is consolidated to one
+   source of truth (`balanced`).
+
+### Deliberately *not* done (scope discipline)
+
+- **Command + file names kept** (`/set-cost-profile`,
+  `cost-profile-defaults.md`) — renaming them cascades through the
+  ownership-matrix, command-surface, discovery manifest, and marketplace
+  (all CI-enforced/generated); the cost/benefit did not clear the bar.
+  Their *content* now uses `rule_loading_tier`.
+- **`custom` left unchanged** — it is absent from `dist/router.json`
+  profiles (documented but not router-dispatched). Its implementation is a
+  pre-existing question, tracked as a follow-up, not part of this rename.
+- **`dist/router.json` `profiles` key kept** — it is the tier-list
+  structure, not the setting name; consumers may parse it.
+
+## Consequences
+
+- The silent dead-code bug is gone; the memory cadence is reachable and
+  tested.
+- A future settings-key collision fails CI immediately.
+- Existing installs migrate automatically; no manual action.
+- Internal naming is slightly inconsistent (command/file still say
+  "cost-profile" while the setting is `rule_loading_tier`) — an accepted
+  trade-off against a high-churn, low-value rename of generated surfaces.
+- Breaking change to a public settings key → next major (see
+  `BREAKING_CHANGES.md`).
+
+## Alternatives considered
+
+- **Re-couple `cost_profile` to self-optimization** (the original intent) —
+  rejected: couples two orthogonal axes (token footprint + learning
+  behaviour); the council and the existing decoupled architecture both
+  argue against it.
+- **Minimal fix — resolve only the collision, keep the `cost_profile`
+  name** — rejected: leaves the misleading "cost" name and so leaves part
+  of the four-concept confusion intact.
+- **Rename the command + doc files too** — deferred: disproportionate
+  cascade through CI-enforced manifests for marginal benefit.
+
+## References
+
+- `BREAKING_CHANGES.md` (next-major entry).
+- `docs/contracts/memory-visibility-v1.md` § Cadence interaction.
+- `docs/contracts/cost-profile-defaults.md` (rule-loading defaults).
+- `scripts/schemas/agent-settings.schema.json` + `scripts/validate_agent_settings.py`.
+- ADR-010 (profile / pack / preset boundary) — `cost_profile` axis renamed.

package/docs/decisions/ADR-rule-kernel-and-router.md

@@ -74,7 +74,7 @@ size budgets.
 | `balanced` *(default)* | kernel + tier-1 | Day-to-day engineering work; matches pre-roadmap behaviour superset |
 | `full` | kernel + tier-1 + tier-2 | Architectural / cross-wing / governance sessions |
 
-Consumer projects opt in via `personal.cost_profile` in
+Consumer projects opt in via `personal.rule_loading_tier` in
 `.agent-settings.yml`. The install script keeps user-set values; only
 the template default is `balanced`.
 

package/docs/decisions/INDEX.md

@@ -39,6 +39,8 @@ _Auto-generated by `scripts/adr/regenerate_index.py`. Do not edit._
 | [ADR-033](ADR-033-distribution-identity-npm-primary.md) | Distribution Identity Npm Primary | accepted | 2026-05-29 | — |
 | [ADR-034](ADR-034-per-skill-model-recommendation-transport.md) | Per Skill Model Recommendation Transport | superseded | 2026-05-30 | — |
 | [ADR-035](ADR-035-model-capability-tiers.md) | Model Capability Tiers | accepted | 2026-05-30 | 034 |
+| [ADR-036](ADR-036-global-install-browser-wizard-handoff.md) | Global Install Browser Wizard Handoff | accepted | 2026-06-01 | — |
+| [ADR-037](ADR-037-cost-profile-untangle.md) | Cost Profile Untangle | accepted | 2026-06-01 | — |
 
 ## Unnumbered (legacy)
 

package/docs/getting-started.md

@@ -146,7 +146,7 @@ The system supports four configuration profiles:
 Set your profile in `.agent-settings.yml`:
 
 ```yaml
-cost_profile: balanced
+rule_loading_tier: balanced
 ```
 
 `balanced` is the default — kernel + tier-1 auto-rules. Rationale:
@@ -169,7 +169,7 @@ Your agent now understands slash commands:
 | `/quality-fix` | Run and fix all quality checks |
 | `/chat-history` | Inspect the persistent chat-history log (read-only `show`) |
 
-→ [Browse all 145 active commands](../.agent-src/commands/)
+→ [Browse all 146 active commands](../.agent-src/commands/)
 
 ---
 

package/docs/guidelines/agent-infra/layered-settings.md

@@ -18,7 +18,7 @@ on user request.
 | File | Git | Scope | Owner | Example values |
 |---|---|---|---|---|
 | `.agent-project-settings.yml` | **committed** | team / repo | lead maintainer | `project.stack`, `quality.php.tools`, `memory.dogfood` |
-| `~/.event4u/agent-config/agent-settings.yml` | **n/a** (outside repo) | individual developer · cross-project | individual | `name`, `ide`, `cost_profile`, `personal.bot_icon`, `personal.autonomy`, `telegraph.speak_scope` (legacy `~/.config/agent-config/agent-settings.yml` read as fallback) |
+| `~/.event4u/agent-config/agent-settings.yml` | **n/a** (outside repo) | individual developer · cross-project | individual | `name`, `ide`, `rule_loading_tier`, `personal.bot_icon`, `personal.autonomy`, `telegraph.speak_scope` (legacy `~/.config/agent-config/agent-settings.yml` read as fallback) |
 | `.agent-settings.yml` | **gitignored** | individual developer · this project | individual | `personal.ide`, `personal.user_name`, `subagents.max_parallel`, `onboarding.onboarded` |
 
 All three are YAML. Schemas:
@@ -52,7 +52,7 @@ intentionally tiny — adding a key requires an ADR.
 ```
 name
 ide
-cost_profile
+rule_loading_tier
 personal.bot_icon
 personal.autonomy
 telegraph.speak_scope

package/docs/installation.md

@@ -303,7 +303,7 @@ explicitly by adding `agent_config_version: <semver>` to
 The orchestrator chains payload sync and bridge generation:
 
 ```bash
-bash scripts/install                  # defaults to cost_profile=balanced
+bash scripts/install                  # defaults to rule_loading_tier=balanced
 bash scripts/install --profile=minimal
 bash scripts/install --force          # overwrite existing bridges
 bash scripts/install --skip-bridges   # payload only
@@ -359,7 +359,7 @@ regardless of which AI tool they use.** No per-developer plugin installation nee
 After initial setup, commit these files:
 
 ```
-.agent-settings.yml                ← shared profile (e.g., cost_profile: balanced)
+.agent-settings.yml                ← shared profile (e.g., rule_loading_tier: balanced)
 agents/installed-tools.lock        ← AI bill of materials (ADR-008, Phase 3)
 .augment/                          ← rules, skills, commands (symlinks)
 .cursor/rules/                     ← Cursor rules (symlinks)
@@ -589,7 +589,7 @@ The system works immediately with sensible defaults. Optionally, create `.agent-
 to choose a profile:
 
 ```yaml
-cost_profile: balanced
+rule_loading_tier: balanced
 ```
 
 | Profile | What's active | For whom |

package/docs/setup/mcp-client-config.md

@@ -33,7 +33,7 @@ look for MCP server config inside `.agent-settings.yml`.
 | File | Where | Who reads it | Purpose |
 |---|---|---|---|
 | MCP client config (this page) | client-specific path per section above | the MCP client at startup | which MCP servers to talk to (name + URL / command) |
-| `.agent-settings.yml` | consumer project root (`<repo>/.agent-settings.yml`) | the agent at runtime (Claude / Cursor / …) | per-developer preferences: `name`, `ide`, `cost_profile`, `personal.autonomy`, `pipelines.skill_improvement`, `telegraph.speak_scope`, … |
+| `.agent-settings.yml` | consumer project root (`<repo>/.agent-settings.yml`) | the agent at runtime (Claude / Cursor / …) | per-developer preferences: `name`, `ide`, `rule_loading_tier`, `personal.autonomy`, `pipelines.skill_improvement`, `telegraph.speak_scope`, … |
 
 The Worker is **stateless** and **project-agnostic** — it serves the
 same skill / rule / command catalog to every client. Personalization

package/docs/value.md

@@ -23,15 +23,17 @@ Liest sich von oben nach unten. Positive Δ-Werte = das Paket *kostet* Tokens (R
 | Stufe | Was sie tut | Δ Tokens | Kumulativ | Quelle |
 |---|---|---:|---:|---|
 | **Ohne Paket / Without package** | Baseline — der nackte Request ohne Paket-Regeln. | +0 | +0.00% | `n/a` · ✅ gemessen |
-| Mit Paket (Regeln laden) / With package (rule load) | Die immer-aktiven Regeln landen im Kontext jedes Requests. ⚠️ erst teurer | +8 522 | +106.53% | `dist/router.json` · ✅ gemessen |
-| | _Fußnote:_ Kernel = 10 rules (30080 chars) + charter (4010 chars); tokens ≈ chars / 4. | | | |
-| + condense (Regeln eindampfen) / + condense (rule shrink) | Build-Schritt schrumpft Regel-Dateien vor dem Ausliefern. | -186 | +104.20% | `internal/bench/reports/telegraph-v2.json` · ✅ gemessen |
+| Mit Paket (Regeln laden) / With package (rule load) | Die immer-aktiven Regeln landen im Kontext jedes Requests. ⚠️ erst teurer | +59 359 | +741.99% | `internal/bench/reports/projection-cost.json` · ✅ gemessen |
+| | _Fußnote:_ Eager-Default: alle 79 Rule-Files always-on im `.claude`-Projektionspfad (0B.6-bestätigt fürs primäre Tool). Nicht nur der Kernel — das ist die ehrliche Up-Front-Last; tokens ≈ chars / 4. | | | |
+| + thin (Regeln als Pointer) / + thin (rules as pointers) | Nicht-Kernel-Regel-Bodies werden zu router-aufgelösten Pointern. | -45 857 | +741.99% | `internal/bench/reports/projection-cost.json` · 🔁 verfügbar (Default aus) |
+| | _Fußnote:_ Verfügbar hinter `lean_projection.mode=thin` (Default `eager-all` — deshalb NICHT im Default-NETTO). Mit Thin aktiv: Rule-Layer 59359 → 13502 GPT tok (−45857, −77.3%). MUST-LOAD-Floor `task trigger-coverage` 26/26 grün; Live-A/B-Validierung ausstehend (Harness abgelehnt). Rollback = ein Flip. | | | |
+| + condense (Regeln eindampfen) / + condense (rule shrink) | Build-Schritt schrumpft Regel-Dateien vor dem Ausliefern. | -186 | +739.66% | `internal/bench/reports/telegraph-v2.json` · ✅ gemessen |
 | | _Fußnote:_ Aggregate across non-Thin-Root categories; Thin-Root files (AGENTS.md variants) net negative (~−4%) and are excluded from the rung — surfaced separately. | | | |
-| + rtk (CLI-Output filtern) / + rtk (filter CLI output) | rtk schneidet verbose CLI-Ausgabe vor dem Modell-Input weg. | -593 | +96.79% | `internal/bench/reports/rtk/latest.json` · ✅ gemessen |
-| + terse (Antworten knapper) / + terse (shorter replies) | Telegraph-Stil zielt auf knappere Modell-Antworten. | +56 | +97.49% | `internal/bench/reports/telegraph-v1.json` · ✅ gemessen |
+| + rtk (CLI-Output filtern) / + rtk (filter CLI output) | rtk schneidet verbose CLI-Ausgabe vor dem Modell-Input weg. | -585 | +732.35% | `internal/bench/reports/rtk/latest.json` · ✅ gemessen |
+| + terse (Antworten knapper) / + terse (shorter replies) | Telegraph-Stil zielt auf knappere Modell-Antworten. | +56 | +733.05% | `internal/bench/reports/telegraph-v1.json` · ✅ gemessen |
 | | _Fußnote:_ Honest: gemessener Median = -9.27% gegen 'sei knapp' — Telegraph liefert hier mehr Tokens, nicht weniger. Wir messen, wir verstecken nicht. | | | |
 
-**NETTO: Mehrkosten** ⚠️ — **+7 799 Tokens / Request**, kumulativ **+97.49%** vs. Baseline.
+**NETTO: Mehrkosten** ⚠️ — **+58 644 Tokens / Request**, kumulativ **+733.05%** vs. Baseline.
 
 ## Panel B — Verhalten (mit vs. ohne)
 
@@ -81,4 +83,4 @@ Diese Seite ist eine **abgeleitete** Sicht — keine eigene Messung. Sie fasst d
 - Pending rungs contribute 0 to the cumulative until measured.
 - Reference scale: 1000 requests × 8000 input / 600 output tokens per request.
 
-_Last rendered: `2026-05-31T14:37:17+00:00`_
+_Last rendered: `2026-06-01T12:10:59+00:00`_

package/docs/wizard.md

@@ -33,7 +33,7 @@ selects which surface renders.
 |---|---|---|
 | 1 | Identity | `personal.user_name`, `personal.ide` |
 | 2 | Personality | `personal.minimal_output`, `personal.play_by_play`, `personal.open_edited_files` |
-| 3 | Cost profile | `cost_profile` (minimal · balanced · full) |
+| 3 | Cost profile | `rule_loading_tier` (minimal · balanced · full) |
 | 4 | Roadmap quality | `roadmap.quality_floor`, `roadmap.run_tests_inline` |
 | 5 | Memory | `memory.enabled`, MCP server presence |
 | 6 | `.agent-user.md` | Optional long-form persona / preferences |

package/package.json

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

package/scripts/_cli/cmd_explain.py

@@ -262,7 +262,7 @@ makes network calls. Output is the ExplainTrace v1 contract:
 
 why-slots answered (Markdown sections; JSON keys in parens):
 
-  inputs       — profile / preset / cost_profile with per-knob source
+  inputs       — profile / preset / rule_loading_tier with per-knob source
                  (pack | profile | preset | user | env | runtime |
                   default)
   route        — matched tier-1 rules · kernel rules · active persona

package/scripts/_cli/explain_last/inputs.py

@@ -16,7 +16,7 @@ from scripts._cli.explain_last.scrubber import scrub_string
 from scripts._lib.agent_settings import DEFAULT_PROJECT_FILE, load_agent_settings
 from scripts.config import presets, profiles
 
-_DEFAULT_COST_PROFILE = "balanced"
+_DEFAULT_RULE_LOADING_TIER = "balanced"
 _SILENCED_LOGGERS = ("scripts.config.profiles", "scripts.config.presets")
 
 
@@ -65,19 +65,22 @@ def build(project_root: Path) -> dict[str, Any] | None:
             )
     except (profiles.ProfileError, presets.PresetError, OSError):
         return None
-    cost_profile = settings.get("cost_profile") if isinstance(settings, dict) else None
-    cost_profile_source = "user" if cost_profile else "default"
-    if not cost_profile or cost_profile == "__COST_PROFILE__":
-        cost_profile = _DEFAULT_COST_PROFILE
-        cost_profile_source = "default"
+    rule_loading_tier = (
+        (settings.get("rule_loading_tier") or settings.get("cost_profile"))
+        if isinstance(settings, dict) else None
+    )
+    rule_loading_tier_source = "user" if rule_loading_tier else "default"
+    if not rule_loading_tier or rule_loading_tier == "__RULE_LOADING_TIER__":
+        rule_loading_tier = _DEFAULT_RULE_LOADING_TIER
+        rule_loading_tier_source = "default"
     return {
         "profile": scrub_string(resolved_profile.id),
         "preset": scrub_string(resolved_preset.id),
-        "cost_profile": scrub_string(str(cost_profile)),
+        "rule_loading_tier": scrub_string(str(rule_loading_tier)),
         "source_per_knob": {
             "profile": resolved_profile.source,
             "preset": resolved_preset.source,
-            "cost_profile": cost_profile_source,
+            "rule_loading_tier": rule_loading_tier_source,
         },
     }
 

package/scripts/_cli/explain_last/sections/inputs.py

@@ -15,7 +15,7 @@ def render(trace: dict[str, Any]) -> str:
     rows = [
         ("profile.id", inputs.get("profile"), sources.get("profile")),
         ("preset.id", inputs.get("preset"), sources.get("preset")),
-        ("cost_profile", inputs.get("cost_profile"), sources.get("cost_profile")),
+        ("rule_loading_tier", inputs.get("rule_loading_tier"), sources.get("rule_loading_tier")),
     ]
     out.append("| knob | value | source |")
     out.append("|---|---|---|")

package/scripts/_lib/agent_settings.py

@@ -100,7 +100,8 @@ def _resolve_user_global_file() -> Path:
 MERGEABLE_KEYS: tuple[str, ...] = (
     "name",
     "ide",
-    "cost_profile",
+    "rule_loading_tier",
+    "memory.cadence",
     "personal.bot_icon",
     "personal.autonomy",
     "telegraph.speak_scope",

package/scripts/_lib/value_ladder.py

@@ -35,6 +35,13 @@ DEFAULT_REFERENCE_SCALE = {
     "model_tier": "sonnet",
 }
 
+# Confidence levels that contribute to the cumulative / NETTO headline.
+# `pending` (not yet measured) and `available` (measured but behind a
+# default-off kill-switch, e.g. the thin projection) are shown with their
+# token_delta but excluded from the default cumulative — the headline must
+# reflect what actually ships by default.
+_COUNTING_CONFIDENCES = ("measured", "estimated", "vendor-claim")
+
 # ── Pricing ─────────────────────────────────────────────────────────────
 
 
@@ -228,6 +235,96 @@ def load_rung_from_frugality(
     }
 
 
+def load_rung_from_projection(
+    projection: Optional[Dict[str, Any]],
+    reference_scale: Dict[str, Any],
+    pricing_row: Dict[str, Any],
+    tool: str = ".claude",
+) -> Optional[Dict[str, Any]]:
+    """Build the load rung from the REAL eager always-on footprint.
+
+    Phase 3.1 honesty fix: the older `load_rung_from_router` counts only the
+    kernel + charter (~8.5k tok), modelling non-kernel rules as on-demand.
+    But 0B.6 confirmed the primary tool **eager-loads every rule body**
+    (~59k tok always-on). This rung reads that measured footprint from
+    `internal/bench/reports/projection-cost.json::rule_footprint[<tool>]`
+    so Panel A reflects what actually lands in context per request.
+
+    Returns None when the projection report lacks the footprint, so the
+    caller can fall back to the router/frugality rung.
+    """
+    rf = (projection or {}).get("rule_footprint", {})
+    entry = rf.get(tool) or next(iter(rf.values()), None)
+    if not entry or "tokens_gpt" not in entry:
+        return None
+    token_delta = int(entry["tokens_gpt"])
+    files = int(entry.get("files", 0))
+    return {
+        "id": "load",
+        "label": "Mit Paket (Regeln laden) / With package (rule load)",
+        "what_it_does": "Die immer-aktiven Regeln landen im Kontext jedes Requests.",
+        "token_delta": token_delta,
+        "eur_delta": price_input_delta_eur(token_delta, reference_scale, pricing_row),
+        "cumulative_pct": 0.0,
+        "confidence": "measured",
+        "source_report": "internal/bench/reports/projection-cost.json",
+        "footnote": (
+            f"Eager-Default: alle {files} Rule-Files always-on im "
+            f"`{tool}`-Projektionspfad (0B.6-bestätigt fürs primäre Tool). "
+            "Nicht nur der Kernel — das ist die ehrliche Up-Front-Last; "
+            "tokens ≈ chars / 4."
+        ),
+    }
+
+
+def thin_rung_from_projection(
+    projection: Optional[Dict[str, Any]],
+    reference_scale: Dict[str, Any],
+    pricing_row: Dict[str, Any],
+) -> Dict[str, Any]:
+    """Build the thin-projection rung (Phase 3.1 lever).
+
+    The thin projection keeps the kernel full-bodied and demotes every
+    non-kernel rule body to a router-resolved pointer, measured at
+    −`saved_gpt` tokens. It ships **behind a kill-switch**
+    (`lean_projection.mode`, default `eager-all`), so this rung is
+    `confidence: available` — its measured delta is shown but does NOT
+    enter the default cumulative (the default reality is eager). The
+    footnote states the would-be always-on total and the validation state.
+    """
+    tp = (projection or {}).get("thin_projection", {})
+    if not tp or "saved_gpt" not in tp:
+        return pending_rung(
+            "thin",
+            "+ thin (Regeln als Pointer) / + thin (rules as pointers)",
+            "Nicht-Kernel-Regel-Bodies werden zu router-aufgelösten Pointern.",
+            "internal/bench/reports/projection-cost.json",
+            footnote="Run scripts/project_thin_rules.py --measure to populate.",
+        )
+    saved = int(tp["saved_gpt"])
+    thin_total = int(tp.get("thin_gpt", 0))
+    eager_total = int(tp.get("eager_gpt", 0))
+    pct = tp.get("saved_pct", 0)
+    return {
+        "id": "thin",
+        "label": "+ thin (Regeln als Pointer) / + thin (rules as pointers)",
+        "what_it_does": "Nicht-Kernel-Regel-Bodies werden zu router-aufgelösten Pointern.",
+        "token_delta": -saved,
+        "eur_delta": price_input_delta_eur(-saved, reference_scale, pricing_row),
+        "cumulative_pct": 0.0,
+        "confidence": "available",
+        "source_report": "internal/bench/reports/projection-cost.json",
+        "footnote": (
+            f"Verfügbar hinter `lean_projection.mode=thin` (Default `eager-all` "
+            f"— deshalb NICHT im Default-NETTO). Mit Thin aktiv: Rule-Layer "
+            f"{eager_total} → {thin_total} GPT tok (−{saved}, −{pct}%). "
+            "MUST-LOAD-Floor `task trigger-coverage` 26/26 grün; "
+            "Live-A/B-Validierung ausstehend (Harness abgelehnt). "
+            "Rollback = ein Flip."
+        ),
+    }
+
+
 def condense_rung_from_telegraph_v2(
     telegraph_v2: Optional[Dict[str, Any]],
     baseline_input_tokens: int,
@@ -551,7 +648,7 @@ def assemble_ladder(
         rung_copy = dict(rung)
         delta = (
             int(rung_copy.get("token_delta", 0))
-            if rung_copy.get("confidence") != "pending"
+            if rung_copy.get("confidence") in _COUNTING_CONFIDENCES
             else 0
         )
         running += delta
@@ -575,7 +672,7 @@ def compute_totals(
     cumulative_token_delta = sum(
         int(r.get("token_delta", 0))
         for r in rungs
-        if r.get("confidence") != "pending"
+        if r.get("confidence") in _COUNTING_CONFIDENCES
     )
     cumulative_pct = 0.0
     if baseline_input_tokens > 0:

package/scripts/_lib/value_report.py

@@ -43,10 +43,12 @@ try:
         condense_rung_from_telegraph_v2,
         destructive_stops_metric,
         load_rung_from_frugality,
+        load_rung_from_projection,
         load_rung_from_router,
         rtk_rung_from_report,
         selection_metric_from_dev_reports,
         terse_rung_from_telegraph_v1,
+        thin_rung_from_projection,
     )
 except ImportError:
     from scripts._lib.value_ladder import (  # type: ignore[no-redef]
@@ -59,15 +61,18 @@ except ImportError:
         condense_rung_from_telegraph_v2,
         destructive_stops_metric,
         load_rung_from_frugality,
+        load_rung_from_projection,
         load_rung_from_router,
         rtk_rung_from_report,
         selection_metric_from_dev_reports,
         terse_rung_from_telegraph_v1,
+        thin_rung_from_projection,
     )
 
 
 REPO_ROOT = Path(__file__).resolve().parent.parent.parent
 ROUTER_JSON = REPO_ROOT / "dist" / "router.json"
+PROJECTION_COST = REPO_ROOT / "internal" / "bench" / "reports" / "projection-cost.json"
 RULES_DIR = REPO_ROOT / ".agent-src" / "rules"
 CHARTER_PATH = REPO_ROOT / ".agent-src" / "contexts" / "contracts" / "frugality-charter.md"
 FRUGALITY_BASELINE = REPO_ROOT / "agents" / "runtime" / "frugality" / "baseline.jsonl"
@@ -240,28 +245,37 @@ def assemble_value_v1(
     # Load rung — prefer the canonical kernel list from dist/router.json
     # (real always-loaded footprint), fall back to the frugality canon
     # baseline only when the router is missing on disk.
-    router = safe_load_json(ROUTER_JSON)
-    if router and "kernel" in router:
-        rule_chars = {
-            p.stem: len(p.read_text())
-            for p in RULES_DIR.glob("*.md")
-        } if RULES_DIR.exists() else {}
-        charter_chars = (
-            len(CHARTER_PATH.read_text()) if CHARTER_PATH.exists() else 0
-        )
-        load_rung = load_rung_from_router(
-            router, rule_chars, charter_chars, ref, pricing_row
-        )
-    else:
-        load_rung = load_rung_from_frugality(
-            latest_frugality_record(), ref, pricing_row
-        )
+    # Prefer the REAL eager footprint (projection-cost.json) — 0B.6 confirmed
+    # the primary tool eager-loads every rule body. Fall back to the
+    # kernel-only router rung, then the frugality canon, when the projection
+    # report is missing.
+    projection = safe_load_json(PROJECTION_COST)
+    load_rung = load_rung_from_projection(projection, ref, pricing_row)
+    if load_rung is None:
+        router = safe_load_json(ROUTER_JSON)
+        if router and "kernel" in router:
+            rule_chars = {
+                p.stem: len(p.read_text())
+                for p in RULES_DIR.glob("*.md")
+            } if RULES_DIR.exists() else {}
+            charter_chars = (
+                len(CHARTER_PATH.read_text()) if CHARTER_PATH.exists() else 0
+            )
+            load_rung = load_rung_from_router(
+                router, rule_chars, charter_chars, ref, pricing_row
+            )
+        else:
+            load_rung = load_rung_from_frugality(
+                latest_frugality_record(), ref, pricing_row
+            )
+    thin_rung = thin_rung_from_projection(projection, ref, pricing_row)
     t2 = safe_load_json(TELEGRAPH_V2)
     t1 = safe_load_json(TELEGRAPH_V1)
     rtk = safe_load_json(RTK_LATEST)
     ladder: List[Dict[str, Any]] = [
         baseline_rung(ref),
         load_rung,
+        thin_rung,
         condense_rung_from_telegraph_v2(t2, baseline_input_tokens, ref, pricing_row),
         rtk_rung_from_report(rtk, ref, pricing_row),
         terse_rung_from_telegraph_v1(t1, ref, pricing_row),

package/scripts/ai_council/modes.py

@@ -17,7 +17,7 @@ Resolution precedence — first non-empty wins:
     3. Global setting       ``ai_council.mode``
     4. Built-in default     ``manual``
 
-This mirrors how ``cost_profile`` resolves in
+This mirrors how ``rule_loading_tier`` resolves in
 ``.augment/guidelines/agent-infra/layered-settings.md``.
 
 The resolver is pure — it never touches the filesystem or environment.

package/scripts/audit_initial_context.py

@@ -132,11 +132,27 @@ def longest_rules(top: int = 10) -> list[dict]:
     return rows[:top]
 
 
+def thin_projection() -> dict:
+    """Eager-vs-thin rule-layer footprint (Phase 3.1 lever).
+
+    Reuses `scripts/project_thin_rules.py::measure` so the value dashboard can
+    cite a single persisted source for both the eager always-on cost and the
+    thin-projection saving. Returns an empty dict if the measurer is
+    unavailable, so the audit never hard-fails on it.
+    """
+    try:
+        from project_thin_rules import measure as _measure  # noqa: E402
+        return _measure()
+    except Exception:  # pragma: no cover — best-effort enrichment
+        return {}
+
+
 def build() -> dict:
     return {
         "generated": _dt.datetime.now(_dt.timezone.utc).isoformat(timespec="seconds"),
         "token_method": token_count.method_note(),
         "rule_footprint": rule_footprint(),
+        "thin_projection": thin_projection(),
         "description_catalog": description_catalog(),
         "longest_rules": longest_rules(),
     }