@event4u/agent-config 14.22.0 → 15.0.0

package/docs/contracts/settings-classes.md

@@ -247,8 +247,39 @@ dispatch runs, not WHETHER the layer exists, so they keep their own C rows.
 |---|---|
 | A — preference | 26 |
 | B — consent | 3 |
-| C — guarded | 110 |
-| **Total** | **139** |
+| C — guarded | 116 |
+| **Total** | **145** |
+
+It rose to 142 on 2026-09-08 from two independent additions that landed in the same
+day and are counted together here: `lean_projection.hosts` (one C, `policy`, from
+`road-to-delivery-for-every-host`) and the two continuity keys below. The merge that
+combined them re-derived the total from the class table rather than adding either
+side's figure to the other, which is the arithmetic `lint_settings_classes` checks.
+
+It rose on 2026-09-08 when `road-to-continuity-writer-activation`
+step 1.2 added `continuity.auto_record` — one C, `consent`: it arms an automatic
+producer on the normal session-end path, and the roadmap step required the
+default to stay `off` until parity was measured, which is a decision no agent may
+take by writing the key. **It ships `on` since 2026-09-10.** The class did not
+change and neither did the write protection — `settings:set` still refuses this
+key. What changed is the shipped default, edited by hand in the template and the
+schema on a recorded AI-council verdict (2026-09-10, 2 seats, convergent, under
+the owner's written delegation), which is the route a class-C default moves by
+and the reason the refusal in `settings:set` is not a contradiction: the guard
+stops an agent from deciding, not a recorded decision from being applied. Step 1.4 added
+`continuity.run_checkpoints` the same day — a second C, shipping `on` because
+that is the behavior the tree already had. It exists so the three session-end
+handlers are independently disableable, which is what the 2026-09-07 council's
+D2 asked for; it changes nothing that ships.
+
+Its disposition is `consent`, and `derivable` was considered first and rejected:
+`derivable` is the **deletion queue**, a claim that the key disappears once the
+mechanism it names exists. This one is an operator kill switch over a recovery
+artifact, so it is meant to survive — and nothing in the tree can derive whether
+an operator wants resumability traded for quiet. It sits in the same shape as the
+kill switches already classified `consent` (`knowledge.global_sharing.enabled`
+and its allowlist): the mechanism's own preconditions are computable, the
+operator's decision to suppress it is not.
 
 The total was 140 until 2026-08-12, when five of the six keys no code path read were
 deleted, minus the one held open (§ The six unread keys, below): one A
@@ -338,9 +369,9 @@ the template, which is the drift this contract exists to prevent.
 |---|---|
 | derivable | 83 |
 | un-inferrable | 9 |
-| consent | 41 |
-| policy | 6 |
-| **Total** | **139** |
+| consent | 44 |
+| policy | 9 |
+| **Total** | **145** |
 
 First measured 2026-08-12 at 140 leaves (derivable 88 · consent 38 ·
 un-inferrable 9 · policy 5), from the table below rather than predicted — the
@@ -355,8 +386,12 @@ mechanism it names actually exists, so 83 measures work outstanding, not keys
 about to disappear. The count is expected to fall while `un-inferrable` does not
 — those 9 plus whatever survives re-examination in `consent` are the floor this
 surface has, and stating it is the point. `policy` is the smallest class and the
-only one whose action is a *move* rather than a keep or a delete: five keys carry
-a project fact the tree could hold instead.
+only one whose action is a *move* rather than a keep or a delete: seven keys carry
+a project fact the tree could hold instead. (This sentence read "five" while the
+counts table beside it read 6, and 2026-09-08 added `lean_projection.hosts` as the
+seventh — corrected in both directions rather than only incremented, because a
+prose number that disagrees with a computed one beside it is the exact defect
+`lint_settings_classes` fails the two Total rows for.)
 
 ## The floor — the nine keys no mechanism can derive
 
@@ -440,6 +475,7 @@ Rows follow template order, so a diff against the template reads straight down.
 | `discipline_profile` | C | `__DISCIPLINE_PROFILE__` | master switch for the discipline rule tier | derivable — its own `auto` resolution against `src/config/host-capabilities.yml` |
 | `rule_loading_tier` | C | `__RULE_LOADING_TIER__` | legacy master switch for rule loading | derivable — `discipline_profile` supersedes it with a documented mapping (minimal→off, balanced→essential, full→full) |
 | `lean_projection.mode` | C | `eager-all` | `thin` removes rule bodies from the agent's context | derivable — `probe_host_compliance.ts` already computes the per-host thin/eager recommendation |
+| `lean_projection.hosts` | C | `[claude-code]` | decides WHICH hosts a thinning mode may thin, so an added id removes rule bodies from that host's context | policy — the value is a package-level decision the tree already holds: ADR-267 scopes the shipped `delivery` flip to `claude-code` alone. NOT `derivable`, and the distinction is the whole reason for this row: the mechanism that would compute an admissible host set, `admissibleUnderE3` in `src/scripts/_lib/injection_effect.ts`, admits **nothing** today — `src/config/host-injection-effect.json` carries 1 `observed-false` and 8 `unobserved` rows and no `observed-true` — so a derivation would yield `[]` rather than the shipped `[claude-code]`. Naming a mechanism that returns empty as the replacement would put a key in the deletion queue whose deletion would silently change the default. Move target: the ADR plus that census, once a host earns an `observed-true` row |
 | `telegraph.speak` | C | `false` | ships a rule body; a token-cost lever in both directions | derivable — the telegraph kill-criterion bench verdict is a package-level decision, not a per-install one |
 | `tokens.rich_skills` | C | `"on"` | token-spend lever | derivable — the skill's own `token_budget_class: rich` declaration plus the CI ceiling in `lint_token_budget_discipline.ts` |
 | `cost.budgets.daily` | C | `0` | rolling spend ceiling | consent |
@@ -501,6 +537,9 @@ Rows follow template order, so a diff against the template reads straight down.
 | `planning.completion_review` | C | `true` | disables the completion-review validator | derivable — `check_completion_review`'s own scope predicate, bound to the current diff hash |
 | `quality.local_auto_run` | C | `false` | governs whether local verification runs at all | consent |
 | `design.fidelity_mode` | C | `strict` | strict-mode selector, one of whose values is a Hard Floor | policy |
+| `design.approximation.enabled` | C | `false` | lets a value change without a per-value confirmation; enabling it is a consumer-facing default flip | consent |
+| `design.approximation.tolerance.color` | C | `null` | decides which colour deviations may be taken silently | policy |
+| `design.approximation.tolerance.length` | C | `null` | decides which length deviations may be taken silently | policy |
 | `consistency.cross_source` | C | `"on"` | disables the cross-source discrepancy gate | derivable — the rule's own trigger condition; a discrepancy exists only when two present sources contradict |
 | `screenshots.identity_allowlist` | C | `[]` | allowlist of identities that ship unredacted | consent |
 | `screenshots.forbid_terminal_capture` | C | `true` | kill-switch over the highest-leak capture path | consent |
@@ -537,6 +576,8 @@ Rows follow template order, so a diff against the template reads straight down.
 | `commands.create_pr.screenshots` | C | `false` | puts captured screenshots into a published PR body | consent |
 | `commands.create_pr.ui_paths` | C | `[]` | glob allowlist | derivable — the frontend-surface heuristic the PR-description flow already applies when the glob list is empty |
 | `commands.create_pr.api_paths` | C | `[]` | glob allowlist | derivable — the API-endpoint heuristic the same flow already applies as its documented empty-list fallback |
+| `continuity.auto_record` | C | `"on"` | arms an automatic producer on the normal session-end path | consent |
+| `continuity.run_checkpoints` | C | `"on"` | disabling it removes a recovery artifact a killed run resumes from | consent |
 | `memory.cadence` | C | `always` | suppressing the visibility line hides what the agent learned from the user | derivable — the hits/asks count the memory-visibility summary already computes; the line only exists when memory was consulted |
 | `memory.review_threshold` | A | `10` | when a review preview surfaces; governs no gate | derivable — the unreviewed-intake count `/memory load` already computes before rendering its preview |
 | `memory.redact_patterns` | C | `[]` | deny-list of secret and PII regexes | policy |

package/docs/guidelines/abstraction-thresholds.md

@@ -45,6 +45,41 @@ present in the diff** — never speculative abstraction for "this could grow
 later". See [`component-oriented-and-oop-development`](component-oriented-and-oop-development.md)
 § The load-bearing caveat.
 
+## The provided-artifact clause — repetition observable before the code exists
+
+ADR-213 authorises extraction on repetition **already present in the diff**. A
+handed-over **runnable** artifact makes repetition observable before any code
+exists at all: four `<Card>` instances are visible in the handover, so a port
+that writes them one at a time and extracts on the second is doing the
+threshold's own arithmetic in the wrong order.
+
+This is a **different mechanism** than the one the threshold tested, not a
+loophole in it. `adr_cite_check ADR-213` reports the record LIVE with an
+**indeterminate** review trigger and `reopen_policy: unclassified`, so
+investigation is permitted; the numbers themselves — 2 · 3+ · ~4+ — are
+**unchanged**, and this clause moves only *when* the count may be taken.
+
+**Two guards, both required. The first alone is insufficient.**
+
+1. **A runnable artifact, not a design comp.** A comp shows a picture of four
+   cards; a runnable artifact carries four instances of a thing. Counting
+   rectangles in an image is not counting repetition, and a comp therefore does
+   not qualify.
+2. **Repetition of the ELEMENT, not of its compositional context.** Four
+   `<Card>` instances show that Card is used four times. They do **not** show
+   that a `CardGrid` is needed — that needs multiple distinct contexts each
+   arranging several cards. Without this guard the clause would license
+   extracting a wrapper for every layout the artifact happens to contain once,
+   which is speculative abstraction with an artifact as its excuse.
+
+**Enforcement, stated honestly: guard (2) is model-carried and audit-enforced.**
+Nothing mechanical separates *"I saw four Cards"* from *"I saw a CardGrid
+pattern"* — the distinction is about what the repetition MEANS, and
+`lint_abstraction_thresholds.ts` checks numeric threshold drift, which is a
+different property. Guard (1) is checkable (is the handover runnable), guard (2)
+is not, and claiming otherwise would be the coverage inflation this tree forbids
+elsewhere. The discipline is the control.
+
 ## See also
 
 - [`architecture`](../../src/rules/architecture.md) — the rule that carries the code-level bar.

package/docs/guidelines/agent-infra/active-remediation-mechanics.md

@@ -67,16 +67,16 @@ Two failure shapes this table exists to name:
 
 ### Worked example — a red gate seen mid-task
 
-> `task check` fails; the lint step reports 7 errors, all pre-existing on `main`, in files this branch does not touch.
+> the `check` task fails; the lint step reports 7 errors, all pre-existing on `main`, in files this branch does not touch.
 
-Wrong, and the canonical shape of it: finish the task, and close with *"the only thing still open is the lint finding — 7 errors on main, which makes `task check` unusable as a chain"*. The sentence is accurate, the issue is named, and nothing about it is decided — the next session inherits it verbatim.
+Wrong, and the canonical shape of it: finish the task, and close with *"the only thing still open is the lint finding — 7 errors on main, which makes the `check` task unusable as a chain"*. The sentence is accurate, the issue is named, and nothing about it is decided — the next session inherits it verbatim.
 
 Right: the errors are pre-existing, outside the fix-now bar (unrelated files, more than ~10 lines), so they are **note + ask** — after the task is delivered, one block:
 
 1. Fix the 3 `no-unused-vars` in `src/a.ts`, `src/b.ts` — ~6 lines, mechanical, ships in this PR.
 2. Fix all 7 in a separate follow-up PR — keeps this diff single-purpose; needs a branch (permission-gated).
 3. Suppress the two in generated output with a scoped ignore, fix the rest — smallest green path, adds a suppression to review.
-4. Leave as is — `task check` stays unusable as a chain until someone else picks it up.
+4. Leave as is — the `check` task stays unusable as a chain until someone else picks it up.
 
 One recommendation line names the pick. Whatever the user answers, the item is closed. If they answer nothing, it is raised once at the next task boundary — not carried silently into a third session.
 

package/docs/guidelines/agent-infra/false-green.md

@@ -168,8 +168,8 @@ bash src/scripts/condense.sh --changed        # dist != rewrite(src) => the scan
 ./scripts-run src/scripts/check_condensation --summary   # byte-exactness dist vs rewrite(src)
 ```
 
-**Structural fix:** regenerate before judging (`task sync` then
-`task generate-tools`, in that order), and treat a baseline unchanged past
+**Structural fix:** regenerate before judging — this repository's `sync` task
+then its `generate-tools` task, in that order — and treat a baseline unchanged past
 `STALE_AFTER_DAYS` (56, `_lib/gate_baseline.ts:39`) as suppression rather than
 as headroom. A completion claim rests on a run made **after** the last edit, not
 on the freshest run you happen to remember.

package/docs/guidelines/agent-infra/notes-horizon-mechanics.md

@@ -0,0 +1,90 @@
+# Notes-first reasoning — horizon and reopening mechanics
+
+Migrated out of [`notes-first-reasoning`](../../../src/rules/notes-first-reasoning.md)
+on 2026-09-08. That rule is delivered on **every subagent spawn**, so its body is
+paid per spawn; this material is reference read on demand. Nothing was dropped —
+the four passages below are the rule's own text, verbatim, and the rule keeps
+both Iron Laws and points here.
+
+Same reason, and the same remedy, as the 2026-08-29 drain run recorded for
+`source-confidentiality`: the addition had no room under the per-spawn ceiling,
+and raising that ceiling is the config-weakening move this repository refuses.
+
+### Why reasoning stays out of the reply, and what grounds the notes file
+
+Reasoning dumped into the user-facing answer is both noise and a
+`reasoning_extraction` refusal risk (see `rdp-gate`). Keep it in the notes file.
+
+The notes file is grounded in the documented cross-run lessons memory
+(consolidated via [`memory-consolidation`](../../../src/skills/memory-consolidation/SKILL.md));
+the rule's in-task sections are a local derivation for within-task scope. The
+gate itself reads settings + task-signal + host self-assessment.
+
+### The two section fields, in full
+
+The rule lists the sections and no count. That is deliberate: the structure
+carries the enumeration, so there is no "write N hypotheses" instruction to
+follow — a run records what the work actually surfaced, and an empty section is
+a fact about the work rather than a gap in the notes.
+
+`## Predictions` carries **chosen form** · prediction · confidence · result ·
+lesson — the calibration loop: hypothesis → prediction → reality →
+calibration. The form is named first because a prediction with no subject
+cannot be contradicted: when the observation comes back, "the prediction
+missed" has to point at *what* it was a prediction about, or nothing reopens.
+
+`## Decisions` escalates to
+[`decision-record`](../../../src/skills/decision-record/SKILL.md)/ADR when the
+decision is cross-task or architectural — litmus: would a dev on a different
+component next month need this context? And `next-commitment` is the boundary
+this choice authorises work up to, not the plan for it: choosing a form is not
+permission to execute a twelve-step plan on it without re-reading the position.
+
+### The horizon — which boundaries count
+
+The boundary is the nearest of these that the plan actually reaches: a **test
+result** · a **type or schema inspection** · a **compile** · a **runtime probe**
+· a **call-site inventory** · a **dry run** · a **browser observation** · a
+**dependency-contract read**. The set is enumerable, which is the whole point —
+"the work up to the nearest of those" is decidable from the plan, and `next
+justified commitment` as prose degrades to *"implement solution"*, which is the
+starting point wearing a label.
+
+### Width scales with reversibility, never with task size
+
+| The action is… | The horizon runs to… |
+|---|---|
+| a reversible local edit | a whole implementation slice — stopping at the first boundary costs more than it saves |
+| stateful or cross-layer | the next boundary from the list above |
+| irreversible or a public contract | **before** the irreversible step, unless direct evidence already covers it |
+
+### The look-ahead ladder is a CEILING, never a quota
+
+Three to five moves is the *maximum*, and only for a forcing, irreversible or
+externally observable line. Stateful or cross-layer gets two to three. A quiet
+reversible line gets **one, deliberately** — and no artifact anywhere requires a
+minimum depth. Always-three-to-five across all variants is 1024 leaves at four
+branches and depth five, which buys nothing and costs the run its budget.
+
+### Reopening — the two consequences
+
+A reopen driven by ritual rather than by contradicting evidence is ceremony, and
+an uncapped reopen is a loop with better manners. Two consequences:
+
+- **A rejection whose premise is falsified is not a rejection.** A candidate
+  killed by an assumption that later turns out false is *un-evaluated*, not
+  dead — it returns to the set. That is what makes a stated `killed-if`
+  condition worth carrying: without it, "we ruled that out" is unfalsifiable.
+- **The first failure reads the candidate list before the retry**, where one
+  exists — see [`autonomy-mechanics`](../../../src/agent-src/contexts/execution/autonomy-mechanics.md)
+  § Retry-budget escalation ladder. Where none exists the ladder is unchanged.
+  This adds a branch; it does not move the N=3 budget.
+
+## See also
+
+- [`notes-first-reasoning`](../../../src/rules/notes-first-reasoning.md) — the
+  rule this material was paid for in, and which keeps both Iron Laws.
+- [`rdp-gate`](../../../src/agent-src/contexts/execution/rdp-gate.md) — the
+  engagement gate that decides whether the notes discipline runs at all.
+- [`decision-record`](../../../src/skills/decision-record/SKILL.md) — where a
+  cross-task or architectural decision escalates to.

package/docs/guidelines/agent-infra/roadmap-progress-mechanics.md

@@ -15,7 +15,7 @@ _Origin: migrated from `.agent-src.uncondensed/rules/roadmap-progress-sync.md` p
 > 2. `.git/hooks/pre-commit` (installed by `scripts/install-hooks.sh`) —
 >    blocks any commit whose staged set touches `agents/roadmaps/` or
 >    `agents/roadmaps-progress.md` while the dashboard is stale.
-> 3. `task ci` runs `roadmap-progress-check` so a PR cannot land with a
+> 3. The `ci` task runs `roadmap-progress-check` so a PR cannot land with a
 >    stale dashboard even if local hooks were bypassed.
 >
 > Hook is primary; the prose below is the specification the hook

package/docs/guidelines/agent-infra/skill-quality-checklist.md

@@ -53,7 +53,7 @@ A field that carries the schema `default` (e.g. `trust.level: core`,
 `validate_frontmatter.apply_schema_defaults` injects it transparently for
 every consumer (validator, discovery manifest, drift checksum). Writing it
 anyway is boilerplate that `scripts/lint_frontmatter_boilerplate.ts` rejects
-(wired into `task ci-fast`). To strip it across the tree, run
+(wired into this repository's `ci-fast` task). To strip it across the tree, run
 `./scripts-run src/scripts/migrate_frontmatter_defaults`. Background:
 `road-to-abstraction-reduction.md` +
 `agents/evidence/analysis/abstraction-reduction-preflight.md`.

package/docs/guidelines/design-fidelity-mechanics.md

@@ -230,6 +230,10 @@ unmarked finding is treated as actionable, so the default failure direction is
 
 Regression witness: `daf-slop-vs-provided`.
 
+**Why the default is what it is, and why the 2026-07-31 council lock over this
+loop cannot be discharged by measuring it:**
+[`design-reconciliation § The 2026-07-31 lock`](design-reconciliation.md).
+
 ## Value-level provenance — the finer grain beside the flag
 
 The block above is finding-level and stays the default: `artifact_covered` is a

package/docs/guidelines/design-fidelity-routing.md

@@ -0,0 +1,78 @@
+# Design-fidelity routing mechanics — how the trigger set is authored
+
+Split out of [`design-fidelity-mechanics`](design-fidelity-mechanics.md) on
+2026-09-09 under `check_depth_budget`'s 16,000-character per-file ceiling. It is
+also a genuinely different subject: that guideline is read while PORTING an
+artifact, and this one is read while EDITING the rule's own trigger set — which
+happens rarely, by a maintainer, and never during a port.
+
+## Routing mechanics
+
+Migrated out of `design-fidelity.md` on 2026-09-09 under the council verdict on
+`blocker: rule-body-cap` — a semantic migration that frees rule-body lines for
+the operative pointers the same verdict requires, not an arbitrary line cut. The
+rule keeps the obligations; this holds the reasoning behind them.
+
+### The withdrawn builder-URL trigger
+
+A page built in Lovable / v0 / bolt and handed over as a share link is a
+finished spec, and `design-fidelity` does not route it. The obvious trigger was
+tried and **withdrawn**: matching is plain lower-cased substring containment, so
+`https://v0.dev/` also fires on `https://v0.dev/docs`, on a pricing page, and on
+a changelog link — it would treat every mention of the tool's own site as a spec
+handover. That is exactly the `claude.ai` failure the capability-URL trigger
+exists to avoid, and by the rule's own standard it is worse than the gap it
+closes. The alternatives are a bare-host keyword (broader still) or guessing
+each vendor's share-path segment, and a trigger built on a guessed path is not
+evidence.
+
+**What closes it:** a verified share-path segment per vendor, or a
+handover-word co-occurrence the matcher cannot express today. Until then the
+class needs one word in the prompt, like any other unlisted filename.
+`near-bare-host-mention` in `ROUTING_MATRIX` pins the bare-host direction silent
+so a future attempt cannot reintroduce the broad form unnoticed.
+
+### The trigger set, class by class
+
+Phrase-heavy on the German side and on `artifact` deliberately: a bare
+`artifact` keyword fires on *"the CI build artifact is 40 MB"*, which is CI
+vocabulary and not a handover. `ROUTING_MATRIX` pins both halves — every class
+that must route, and every near-miss that must stay silent (fixture
+`daf-port-trigger-de`).
+
+Each shipped class carries its own near-miss row, and the pairing is the
+contract rather than a courtesy:
+
+| Class | Its near-miss row | The direction that row tests |
+|---|---|---|
+| `phrase: claude.site/artifacts` | `near-claude-ai-chat-link` | a bare `claude.ai` chat link is a conversation reference, not a spec |
+| `path_prefix: .claude/design-system/` | `near-generic-design-system-dir` | a bare `design-system/` is a normal source folder in a large fraction of frontend repos |
+| `file_pattern: *.dc.html` | `near-plain-html-open-file`, `near-dc-in-a-filename` | an ordinary `.html` file in the tree; a filename that merely contains the letters |
+| the withdrawn builder URL | `near-bare-host-mention` | left behind on purpose, so the broad form stays pinned silent |
+
+### Write the near-miss row first — and test the right direction
+
+Extending the trigger set without adding a near-miss row is how an over-broad
+trigger lands. The stronger half of the contract is *which* near-miss:
+
+**The row must test the direction the NEW trigger opens, not a direction that
+was already closed.** The withdrawn class is the worked example. Its first
+near-miss row tested a protocol-less mention — silent *before* the change, and
+therefore incapable of catching the over-broadness the change introduced. The
+row that would have caught it is `near-builder-host-non-handover-url`, a
+documentation URL on the same host, and it exists only because a review asked
+for it after the trigger had already shipped.
+
+Applied on the next trigger to land: `*.dc.html` (the Claude Design canvas
+artboard, which `*design.html` cannot match because it compiles to
+`^(?:.*design\.html)$`) shipped with `near-plain-html-open-file` and
+`near-dc-in-a-filename` written **before** it, both testing the direction it
+opens — an ordinary `.html` file in the tree, and a filename that merely
+contains the letters. Both were confirmed red-then-green against the real
+matcher rather than asserted.
+
+## See also
+
+- [`design-fidelity-mechanics`](design-fidelity-mechanics.md) — the porting half.
+- `tests/scripts/design_fidelity_routing.test.ts` — `ROUTING_MATRIX`, which is
+  the measurement this file describes rather than a second copy of it.

package/docs/guidelines/design-reconciliation.md

@@ -0,0 +1,172 @@
+# Design reconciliation — artifact values against a project's own tokens
+
+Split out of [`design-fidelity-mechanics`](design-fidelity-mechanics.md) on
+2026-09-09, and the reason is a real constraint rather than tidiness: that file
+crossed `check_depth_budget`'s 16,000-character per-file ceiling, which is a
+shrink-only growth ratchet. The subject splits cleanly — that guideline answers
+*how do I port an artifact faithfully*, and this one answers *what happens when
+the artifact's values meet a project that already has its own*. The two rules
+that arbitrate between an artifact and a brand both point here, and neither can
+hold the arbitration itself: a consumer receives `design-fidelity`
+(`engineering-base`) or `brand-source-of-truth` (`brand`), rarely both.
+
+## Tolerance — why the mechanism ships and the number does not
+
+`design-fidelity`'s `strict` mode says EVERY visible deviation needs explicit
+confirmation. The owner directive that motivated
+`road-to-design-intent-conformance` asks for an unprompted approximation within
+a tolerance. Read literally, those contradict — and the contradiction is real
+rather than a wording problem: `grep -cE 'reconcil|tolerance|approximat|nearest'`
+over the rule and this guideline returned 0 / 0 before this section existed.
+
+**The re-frame, and its condition.** A value inside a configured tolerance stops
+being an unconfirmed deviation and becomes a **reported reconciliation**: the
+project's token is written, and the distance from the artifact's own value is
+reported on the row. Everything outside the tolerance stays confirmation-bound,
+and structure — layout, control types, component set, ordering, breakpoints —
+is never in scope at any setting, because it is not a value question.
+
+**The condition is load-bearing, not a hedge.** `design.approximation` ships
+`enabled: false` with `tolerance.color` and `tolerance.length` both `null`, so
+in a default install the paragraph above describes nothing that happens: every
+deviation stays confirmation-bound exactly as before, and no consumer default
+moved. `hard-floor` disables the mechanism outright, so the strictest mode
+cannot be loosened by configuring a tolerance under it.
+
+**Why no threshold ships**, decided by the AI council on 2026-09-09 (anthropic +
+openai, 2/2), and worth re-reading before adding one: *a number in a config
+file, even flagged unmeasured, shapes behavior and creates path dependency.*
+Zero of seven design-to-code benchmarks in the evidence set score token
+conformance, so a shipped threshold would be a guess wearing a default's
+authority. Two proposals were examined and rejected on their merits rather than
+on caution — `±5 per RGB channel`, because RGB channel distance is not
+perceptually uniform and "likely imperceptible" does not follow from it; and
+`max(1px, 2%)`, because it grows steadily more permissive at large dimensions
+with no evidence that this is wanted. GitHub Primer's ±1px spacing widening is
+the one real measurement available and is recorded as an externally observed
+**candidate**, not adopted.
+
+**The metric IS fixed, and that is the half that could be settled.** Colour
+distance is OKLab ΔEOK, length distance is absolute CSS pixels
+(`src/scripts/_lib/design_tolerance.ts`). Fixing the method mattered before
+fixing any number: RGB Euclidean, ΔE LAB, CIEDE2000 and OKLab/ΔEOK give
+different numbers for the same pair, so a threshold quoted without its metric
+is not a threshold.
+
+**The distance is reported on every row regardless.** Preserved values carry it
+too. That is what makes the deferred half decidable: a window over rows that
+report distances yields a distribution, where a window over rows reporting only
+"kept" or "changed" yields nothing to read a threshold off.
+
+## Artifact versus brand
+
+Both `design-fidelity` and `brand-source-of-truth` point here rather than
+carrying this arbitration themselves, and the pointers are **operative**: apply
+this section before reconciling a value, not as a reference to consult if
+curious. Two standing rules cannot each hold half of an arbitration between
+them — a consumer receives one of them without the other, because
+`design-fidelity` ships in `engineering-base` and `brand-source-of-truth` in
+`brand` — so the split has to be somewhere both can reach.
+
+**Values reconcile onto the brand token, with the distance reported.** Colour,
+type and spacing are the axes where the field converges, unanimously and at
+error severity, across the design systems surveyed. Where a registered brand
+token exists, it wins, and the artifact's own value is not silently absorbed:
+the distance between the two is reported on the same row, so what changed is
+visible before it is cumulative.
+
+**Structure is the artifact's, and is never adjusted to suit a token.** Layout,
+control types, component set, ordering, breakpoints and behavior are not value
+questions at all, and no brand token is evidence about any of them. A structural
+deviation stays what `design-fidelity`'s Iron Law says it is: a proposal needing
+explicit confirmation.
+
+**A conflict is surfaced, never merged.** Where the artifact and the brand
+genuinely disagree on something that is not resolvable by the two rules above —
+an artifact whose type scale contradicts the brand's, say — the agent surfaces
+both readings as a numbered choice and builds neither until the human picks.
+Averaging them produces a third design nobody approved.
+
+**Where no brand exists**, there is nothing to reconcile onto: the artifact's
+values are the values, and `brand-source-of-truth`'s own "when NOT to fire"
+already says so. The reconciliation above is a rule about *two* sources, not a
+license to normalize one.
+
+**What this section does NOT decide** is whether an in-tolerance value may be
+reconciled *without asking*. That needs a tolerance to exist and a default to be
+chosen, and both are recorded as open decisions rather than answered here —
+`design.tolerance.*` ships empty and the approximation ships disabled.
+
+## Icons on a provided artifact
+
+`icon-consistency` owns the icon axis and, until 2026-09-09, carried **zero**
+occurrences of `artifact` / `artefact` / `provided` — so no surface in the
+package handled a handed-over artifact's icons at all. Its "ad-hoc inline SVGs
+alongside a chosen set" clause is exactly the shape a faithful port produces,
+which made a port read as a violation of the rule it was obeying.
+
+**The fix is a new rung, not a re-ordering.** Rung 1 of the iconography ladder
+is the project's brand token, and the artifact does **not** outrank it. What the
+carve-out changes is which findings are violations, not which source wins.
+
+**The obligation that survives is traceability, not conformity.** An
+artifact-sourced icon is legitimate when it traces to the artifact and that
+provenance is stated. An inline `<svg>` that traces to neither the adopted icon
+set nor a named artifact is untraceable, and still fires.
+
+**A swap is still a deviation.** Replacing the artifact's icon with the
+project's nearest equivalent is a substitution of a control the artifact
+specified, so it needs the same explicit confirmation as any other deviation
+under `design-fidelity`'s Iron Law. The carve-out permits keeping the
+artifact's icon; it never permits changing it silently.
+
+**What is deliberately NOT here:** an assertion that an artifact's icons are
+*reconcilable* onto the project's set by default. `tailwind-engineer` carried
+that claim in the opposite direction — icons "stay 1:1 with the artifact", with
+no citation — and it was deleted rather than inverted. The contrary evidence and
+the two conditions that would reverse the silence are recorded in
+`road-to-design-intent-conformance` § The icon evidence.
+
+## The 2026-07-31 lock, and why its own reopening condition cannot discharge it
+
+A council lock of 2026-07-31 names its reopening condition as *"a measured run
+showing the polish loop still edits away from a provided artifact"*. No such run
+exists, which makes running one look like the cheap way to close or reopen it.
+**It is not, and this paragraph exists so the next reader meets the argument
+instead of re-deriving it and spending the run.**
+
+The mechanism is **structural, not probabilistic**. Three facts, each checkable:
+`polish.ts:135-167` drops findings flagged `artifact_covered: true`;
+`src/skills/design-tokens/SKILL.md` wired `token_violation` findings into the
+same loop **without** setting that flag; and the paragraph above states that an
+unmarked finding is treated as actionable. Those compose into a path that edits
+away from the artifact whenever a token-violation finding fires on an
+artifact-derived value. Nothing about that path is stochastic.
+
+So a green measured run would establish *"this did not trigger in the sample"*
+— it could never establish *"this cannot trigger"*, which is the claim the lock
+would need to be discharged in the useful direction. A run whose only possible
+informative outcome is the one nobody wants is not a measurement, it is a
+lottery ticket, and it costs a real run to buy.
+
+**The structural fix is the discharge, and it is `blocker:
+findings-actionability-default`** on `road-to-design-intent-conformance`.
+Resolved by the AI council on 2026-09-09 to option (b): set `artifact_covered`
+on the `token_violation` path, changing no package-wide default. Option (a) —
+inverting the default so a finding is non-actionable unless escalated — was
+rejected on blast radius: it changes the meaning of every existing unmarked
+finding across the package to fix one known producer.
+
+**No measurement is scheduled against this lock.** If a later reader wants to
+reopen it, the thing to change is the falsifiability of its condition, not the
+sample size.
+
+## See also
+
+- [`design-fidelity-mechanics`](design-fidelity-mechanics.md) — the porting
+  half, including § Provided-artifact precedence and the `artifact_covered`
+  flag whose default the lock section above turns on.
+- [`design-fidelity-routing`](design-fidelity-routing.md) — how the rule's own
+  trigger set is authored, split out in the same change.
+- `src/scripts/_lib/design_tolerance.ts` — the metric and the shipped-null
+  thresholds this file argues for.

package/docs/guidelines/gtm-handoff.md

@@ -12,7 +12,7 @@ the typed artifact looks like**, and **who owns the failure mode
 when the chain breaks**.
 
 Cycle / dangling / tier-mismatch enforcement is not duplicated here —
-`task lint-handoffs` (per cross-wing-handoff § 4) is the mechanical
+The `lint-handoffs` task (per cross-wing-handoff § 4) is the mechanical
 gate.
 
 ## Chain 1 — brand → channel
@@ -101,7 +101,7 @@ the contract (O2 owns the interface; H10 only consumes it).
 ## See also
 
 - [`docs/contracts/cross-wing-handoff.md`](../contracts/cross-wing-handoff.md)
-  — typed-handoff mechanical contract; `task lint-handoffs` enforces
+  — typed-handoff mechanical contract; the `lint-handoffs` task enforces
   cycles, dangling references, and tier mismatches over the graph.
 - [`docs/guidelines/cross-role-handoff.md`](cross-role-handoff.md)
   — when to hand off at all, how to phrase the routing, L4 / C8

package/docs/guidelines/wing4-handoff.md

@@ -15,7 +15,7 @@ artifact looks like**, and **who owns the failure mode when the
 chain breaks**.
 
 Cycle / dangling / tier-mismatch enforcement is not duplicated here —
-`task lint-handoffs` (per cross-wing-handoff § 4) is the mechanical
+The `lint-handoffs` task (per cross-wing-handoff § 4) is the mechanical
 gate.
 
 ## Chain 1 — money → strategy
@@ -112,7 +112,7 @@ consumes it).
 ## See also
 
 - [`docs/contracts/cross-wing-handoff.md`](../contracts/cross-wing-handoff.md)
-  — typed-handoff mechanical contract; `task lint-handoffs` enforces
+  — typed-handoff mechanical contract; the `lint-handoffs` task enforces
   cycles, dangling references, and tier mismatches over the graph.
 - [`docs/guidelines/cross-role-handoff.md`](cross-role-handoff.md)
   — when to hand off at all, how to phrase the routing, L4 / C8

package/llms.txt

@@ -41,7 +41,7 @@ canvas-design: Creating static visual art — posters, marketing visuals, brand
 character-consistency: Use when a character must stay visually identical across AI video scenes — locks identity tokens (silhouette, palette, wardrobe, prop) in JSON. Triggers 'character lock', 'same character'.
 check-refs: Use when verifying cross-references between skills, rules, commands, guidelines, and context documents are not broken after edits, renames, or deletions.
 churn-prevention: Use when designing churn defence — health-score signals, churn-cause split (involuntary / value / relationship / fit), early-warning loop. Triggers on 'why are accounts leaving'.
-code-intelligence: Route codebase-structure questions (who calls X, where is this used, what imports, change-impact) to an existing code-graph first: cheaper, never more precise; grep stays routine. Also 'call graph'.
+code-intelligence: Route codebase-structure questions (who calls X, where used, change-impact) to an existing code-graph first: impact, tests-for, dead cheaper, never more precise; grep routine. Also 'call graph'.
 code-refactoring: When the user says 'refactor this', 'rename class', or 'move method'. Safely refactors code in any language — finds all callers, updates downstream dependencies, verifies via quality tools.
 code-review: Use when the user says \"review this\", \"check my code\", or wants feedback on changes. Reviews for correctness, quality, security, and coding standards.
 command-routing: Use when the user invokes a slash command like /create-pr, /commit, /fix-ci, or pastes command file content — routes to the right command with context inference and GitHub API patterns.