@event4u/agent-config 16.3.0 → 16.5.0

package/dist/agent-src/contexts/execution/roadmap-execution-contract.md

@@ -72,7 +72,7 @@ Roadmap: <path> · mode: <autonomous | phase-checkpoints>
 
 Git: branch <feat/<roadmap-slug>> · commits: chunked (N commit steps
      detected / delivery commits) · push: to feat/<roadmap-slug> ONLY
-     · PR: open against <default branch> (description only — no merge)
+     · PR: open against <default branch> (no merge, except § 5)
 Artifacts: <N> planned (skills/rules/commands/guidelines) —
      batched overlap check: <result — run NOW, against current state>
 Open questions: <N> → decision sheet below (<M> rows); the rest via AI
@@ -85,7 +85,7 @@ Deferred items: <wait | spawn-follow-up-draft | cancel-with-memo> (default wait)
 
 Always active regardless of this contract (never lifted):
   • Hard Floor per-commit diff gate (bulk deletions / infra)
-  • Push anywhere except feat/<roadmap-slug>; any merge
+  • Push anywhere except feat/<roadmap-slug>; merge (§ 5)
   • security-sensitive-stop on auth/billing/tenant/secret paths
   • N=3 validation budget · context-hygiene read-loop abort
   • Deferred-[~] archival gate
@@ -202,7 +202,7 @@ They are not optional reading: a slug grammar does not imply a namespace, and
 | Create feature branch `feat/<roadmap-slug>` (or reuse the current worktree branch) | Never a prod trunk; one branch per run |
 | Chunked commits on that branch | Per-commit Hard-Floor diff gate stays ([`commit-mechanics`](../authority/commit-mechanics.md)); agent picks the split per [`commit-policy`](../../rules/commit-policy.md) |
 | Push to that branch **only** | Push to any other ref = Hard Floor, ask |
-| Open ONE PR (description-only flow) | Never merge, never close/retarget; merge is always conversational |
+| Open ONE PR (description-only flow) | Acceptance never merges, closes or retargets; merging is § 5's one exception |
 | Batched artifact drafting | The drafting-protocol **Research/overlap pass runs NOW at contract time against current artifact state**; results cached; Understand/Draft phases run non-interactively during the run. Artifacts NOT in the batch still trigger the interactive protocol |
 | Council auto-enable | In-run open questions route to the AI council silently; `high_impact` / `user_required` classifications STILL escalate to the user per [`ask-when-uncertain`](../../rules/ask-when-uncertain.md). **No council configured** → the contract summary says so and in-run true ambiguity halts (never silent guessing) |
 
@@ -211,11 +211,11 @@ the PR has to be able to reach one:
 
 | Grant | Boundary |
 |---|---|
-| Update the PR after opening it — title, body, further pushes to the same branch | Still never merge, close or retarget |
+| Update the PR after opening it — title, body, further pushes to the same branch | Still never close or retarget; merge only per § 5 |
 | Reversible repository / branch settings the agent can change (branch protection included) | Only settings this run needs to reach a reviewable PR, and only reversible ones; a setting the agent changes it also restores if the run's need ends |
 | Start, re-run and fix CI; update the merge base; resolve conflicts | Standard git and CI operations on the run's own branch |
 | Install project-local dependencies | Inside the repo; never a global or system package manager without its own confirmation |
-| Any tool, CLI, API, model, council or external service the work needs | Cumulative **USD 25** per run of variable spend; over that, the owner is asked BEFORE crossing. Uncertainty is not a reason to ask. Marginal cost of an existing subscription is $0. Splitting spend across services, subagents or rounds to keep each item under the ceiling is a violation |
+| Any tool, CLI, API, model, council or external service the work needs | Bounded by the **configured `cost.budgets` windows** and by nothing when none is configured (ADR-279). Where the run's spend plus what it reasonably expects would cross a configured window, it **pauses and reports** before crossing rather than asking. Uncertainty is not a reason to ask. Marginal cost of an existing subscription is $0. Splitting spend across services, subagents or rounds to keep each item under a ceiling is a violation. Model-carried: nothing on a run compares a cumulative figure with anything |
 
 These grants satisfy [`scope-control`](../../rules/scope-control.md)'s
 "standing instruction" clause for the run — see
@@ -225,7 +225,7 @@ These grants satisfy [`scope-control`](../../rules/scope-control.md)'s
 
 | Mode | End state | Halts during run |
 |---|---|---|
-| `autonomous` | All steps `[x]` · quality green per cadence · work committed in chunks on `feat/<roadmap-slug>` · pushed · PR open · archival sweep run. **Merge out of scope, always.** | Safety floors only (+ quality-red, + step reveals out-of-roadmap work) |
+| `autonomous` | All steps `[x]` · quality green per cadence · work committed in chunks on `feat/<roadmap-slug>` · pushed · PR open · archival sweep run. **No merge without an owner auto-merge instruction (§ 5).** | Safety floors only (+ quality-red, + step reveals out-of-roadmap work) |
 | `phase-checkpoints` | Same end state | Safety floors + a compact status + "continue?" prompt at each phase boundary |
 | `interactive` (derived, never from an absent field) | Legacy: work lands, no git delivery without per-op permission | All gates as authored by their owning rules |
 
@@ -238,12 +238,13 @@ git grants are omitted from the contract (nothing to authorize —
 **ADR-237 widens § 3 and leaves this section untouched — deliberately.** An
 end-to-end delegation is tolerable precisely because a PR is reviewable before
 it merges, so the boundary that keeps merging out is the one that makes the rest
-safe. Nothing below is reachable by any invocation.
+safe. Nothing below is reachable by acceptance. A merge comes only from outside
+it: an owner auto-merge instruction (ADR-282, `/pr:merge` § 9a).
 
 - Any [`non-destructive-by-default`](../../rules/non-destructive-by-default.md)
   trigger beyond the two named grants (own-branch push, PR-open):
   prod-trunk anything, deploys, bulk deletions, infra commits.
-- Merging, closing, or retargeting a PR.
+- Merging a PR without an owner auto-merge instruction; closing or retargeting one.
 - Lifting [`security-sensitive-stop`](../../rules/security-sensitive-stop.md),
   the N=3 budget, context-hygiene aborts, or the deferred-`[~]` gate.
 - Work outside the roadmap's scope (halt: scope-out-of-roadmap).

package/dist/agent-src/contexts/execution/roadmap-process-loop.md

@@ -125,25 +125,24 @@ that is already done — the exact failure this clause prevents. This is the
 
 ## 2. Pre-run summary — gate or inline note
 
-Read `roadmap.skip_pre_run_gate` from `.agent-settings.yml` (default
-`true`). The command name already names the scope; asking "Go /
-Different roadmap / …" on every run is the noise the gate-skip removes.
-
-- `true` **and** the roadmap is unambiguous (user named it, or exactly
-  one active roadmap exists) → **skip the interactive gate.** Emit the
-  summary block below as a one-shot inline note (no numbered options,
-  no wait) so the user can still abort mid-stream if the wrong file was
-  picked, then continue straight into § 3.
-- `false`, **or** the roadmap is ambiguous (multiple active roadmaps and
-  none named), **or** an unresolvable cadence / scope conflict is
-  detected → show the gate with numbered options and wait for input.
-
-The gate is **always** shown — regardless of the flag — when the
-roadmap is ambiguous or a scope / cadence conflict has no sensible
-default. The flag suppresses the confirmation, never a genuine
-"which roadmap?" question.
-
-Summary block (shown in both modes; gate-mode appends the numbered
+The command name already names the scope; asking "Go / Different
+roadmap / …" on every run is noise, so there is no confirmation gate and
+no setting to bring one back (the `roadmap.skip_pre_run_gate` key was
+retired on 2026-10-09 with its default, `true`, as fixed behavior).
+
+- The roadmap is unambiguous (user named it, or exactly one active
+  roadmap exists) → **no interactive gate.** Emit the summary block
+  below as a one-shot inline note (no numbered options, no wait) so the
+  user can still abort mid-stream if the wrong file was picked, then
+  continue straight into § 3.
+- The roadmap is ambiguous (multiple active roadmaps and none named),
+  **or** an unresolvable cadence / scope conflict is detected → show the
+  gate with numbered options and wait for input.
+
+The gate is shown only for a genuine "which roadmap?" or an unresolvable
+conflict — never as a routine confirmation.
+
+Summary block (shown in both cases; the gate appends the numbered
 options + wait):
 
 > Roadmap: `<resolved-path>`
@@ -159,10 +158,6 @@ options + wait):
 > 1. Go — start processing autonomously
 > 2. Different roadmap · 3. Different scope · 4. Toggle council · 5. Abort
 
-The invocation-level skip still applies under `skip_pre_run_gate: false`:
-when scope, roadmap, and council are all unambiguous in the invocation
-(e.g. `/roadmap:process-phase road-to-X.md with council`), the gate
-does not fire.
 
 ## 3. Pre-scan — execution contract or commit-step ask
 
@@ -334,7 +329,8 @@ report.
    run: branches, chunked commits, pushing that branch, opening and updating the
    PR, reversible repository/branch settings, CI runs and re-runs, merge-base
    updates, conflict resolution, project-local dependencies, and paid calls
-   inside the cumulative USD 25 ceiling. If yes → **run it**.
+   inside whatever `cost.budgets` windows are configured — none configured,
+   none applies (ADR-279). If yes → **run it**.
 3. **Is it on the EXCLUDED list?** Merging to a production trunk, deploying,
    production data / secrets / IAM / DNS, bulk deletion outside the roadmap's
    scope, an irreversible external action beyond the PR itself. Those keep their
@@ -501,11 +497,15 @@ so the shape is settled before the runs rather than designed under pressure:
   a branch.
 - **Delivery:** one branch and one PR per lane.
 - **Immediate removal:** a single scope-lock collision with data loss.
+- **Refusal report:** every lane report carries the fixed field
+  `classifier_refusals` (an empty list when none) — a report without it is
+  malformed, never "clean". At drain end the orchestrator batches every lane's
+  field into ONE envelope (§ Host-classifier refusals).
 
 ## 4. Resolve cadences — read once, cache for the run
 
-Read both keys from `.agent-settings.yml` once and cache for the whole
-run. Do **not** re-read inside the step loop.
+Read `roadmap.quality_cadence` from `.agent-settings.yml` once and cache
+it for the whole run. Do **not** re-read inside the step loop.
 
 **`roadmap.quality_cadence`** — when to run the quality pipeline.
 Only relevant when `quality.local_auto_run` is `true`; when it is
@@ -524,17 +524,12 @@ Missing / unreadable / unknown → fall back to `end_of_roadmap`.
 The Iron Law [`verify-before-complete`](../../rules/verify-before-complete.md)
 still forbids claiming quality output that was not produced.
 
-**`roadmap.dashboard_regen_cadence`** — when to run the dashboard
-subprocess between steps:
+**Dashboard regen cadence** — fixed, not a setting (the
+`roadmap.dashboard_regen_cadence` key was retired on 2026-10-09 with its
+default as the behavior): `./agent-config roadmap:progress` runs every
+5th closed step, at every phase boundary and at reply end.
 
-| Value | `./agent-config roadmap:progress` runs |
-|---|---|
-| `per_step` | After every checkbox flip |
-| `every_5_steps` (default) | Every 5th closed step + at phase boundary + at reply end |
-| `phase_boundary` | Only at phase boundaries + run end |
-
-`process-step` ignores this — single-step runs always regen at step
-end. Any file-shape touch (rename / phase add / archive — Iron Law 1
+`process-step` always regens at step end. Any file-shape touch (rename / phase add / archive — Iron Law 1
 of [`roadmap-progress-sync`](../../rules/roadmap-progress-sync.md))
 forces an immediate regen regardless of cadence. The checkbox flip
 itself is **never** batchable — only the subprocess.
@@ -772,16 +767,13 @@ Per-class routing, why parking is not deferring, and the scope-growth pointer:
    above unchanged (agent-decidable exit/acceptance criteria remain the
    default; `verify:` is the opt-in machine-checkable tightening).
 
-6. **Dashboard regen — cadence-gated.** Run
-   `./agent-config roadmap:progress` when due per
-   `roadmap.dashboard_regen_cadence` (resolved in § 4; default
-   `every_5_steps`):
-   - `per_step` → always after the flip.
-   - `every_5_steps` → after the 5th, 10th, … closed step **of this
-     run**, or when the reply ends with closed steps pending regen.
-   - `phase_boundary` → skip; the boundary handler in § 5 wrapper /
-     § 6 runs the regen.
-   - Any file-shape touch (rename / phase add / archive — Iron Law 1)
+6. **Dashboard regen — fixed cadence** (§ 4). Run
+   `./agent-config roadmap:progress`:
+   - after the 5th, 10th, … closed step **of this run**, or when the
+     reply ends with closed steps pending regen;
+   - at a phase boundary — the boundary handler in § 5 wrapper / § 6
+     runs it;
+   - on any file-shape touch (rename / phase add / archive — Iron Law 1)
      → run immediately regardless of cadence.
 
    Skipped regens accumulate into the next due regen — the markdown
@@ -843,7 +835,7 @@ and none of them is a `blocked` outcome.
 
 | # | What the refresh found | Reaction |
 |---|---|---|
-| a | A PR touching my owned paths **merged** since the last refresh | Run `sync_pr_branch` now — already the documented resolution, only push-bound until this row existed. Re-read the current step's files, continue. |
+| a | A PR touching my owned paths **merged** since the last refresh | Run `agent-config git:convention sync --base origin/<this branch's PR base>` now — already the documented resolution, only push-bound until this row existed. Re-read the current step's files, continue. |
 | b | An **open** PR touches my owned paths | Continue. Name the collision in the PR description and in the final report. **Never rebase onto a foreign branch.** |
 | c | A peer session shows `PATH OVERLAP` | Take disjoint steps first if ordering allows; otherwise name it and continue. The register is advisory, never a lock. |
 | d | The roadmap itself was **archived on `origin/main`** | Stop. The same **selection error** as § 1, detected late — not a halt, and no checkbox is flipped to reach it. |
@@ -1004,9 +996,11 @@ a violation of the command and the user's will:
   opened" / "a GitHub setting must change" / "CI must be re-run" / "the merge
   base needs updating" / "there are conflicts" / "tests fail"** — every one is
   remediation work the invocation authorised (ADR-237 § 1). Do it.
-- **"a paid service is needed"** — authorised up to a cumulative USD 25 per run
-  (§ Spend in the wrapper). Uncertainty about the exact cost is explicitly NOT a
-  reason to ask.
+- **"a paid service is needed"** — authorised inside the configured
+  `cost.budgets` windows, and with none configured there is no ceiling to be
+  outside of (§ Spend in the wrapper). A crossing of a configured window pauses
+  and reports; it does not ask. Uncertainty about the exact cost is explicitly
+  NOT a reason to ask.
 - **"a maintainer should do this"** when the agent can perform the same action
   through git, `gh`, an API or a CLI. **Capability before role**: the role of the
   person who conventionally does a thing is not a property of the thing.
@@ -1045,10 +1039,31 @@ execution either way.
   [`roadmap-execution-contract § 4`](roadmap-execution-contract.md)):
   all steps `[x]` · quality green per cadence · work committed in
   chunks on the run's feature branch · pushed to that branch · ONE PR
-  open (description-only flow) · archival sweep run. **Merge is out of
-  scope in every mode — always conversational.** Without a contract
+  open (description-only flow) · archival sweep run. **No mode merges by
+  itself:** a merge needs the owner's explicit auto-merge instruction and
+  runs through `/pr:merge` § 9a's danger gate (ADR-282). Without a contract
   (interactive mode), the run ends after the archival check with no
   git delivery beyond explicitly authorized commit steps.
+
+### 6-refusals. Host-classifier refusals — hand off, never route around
+
+When the host's own classifier refuses a step of an owner-directed task, the
+run never reaches the same outcome by another tool, in smaller pieces or in
+another encoding, and never records a way around it. It finishes what does not
+depend on the refused step, then — owner present — asks once in-session for an
+explicit authorization of that exact step and, on a yes, re-runs the SAME step
+ONCE so the classifier decides again with the owner's word in front of it
+(ADR-282 § Part B). Refused again, or no owner present, it writes ONE
+continuation prompt for the owner and names its path in one line:
+
+```bash
+./scripts-run src/scripts/refusal_envelope --input <envelope.json>
+```
+
+The input is task · done · refusals · remaining · the owner-directive record
+when there is one; the envelope lands at `agents/tmp/round-<hex>/prompt.md`.
+Lane refusals arrive in each lane's `classifier_refusals` field and go into the
+same single envelope (ADR-282 § Part B).
 - **If the entire roadmap reached `count_open == 0`** → run the full
   project quality pipeline. On red → stop, surface failures, do **not**
   archive. On green → run the **deferred-resolution gate** below before

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

@@ -12,8 +12,10 @@ provider's model or billing rule.
   inherit`, per [`model-recommendations`](../model-recommendations.md)).
   `frontier` (ADR-232) is declarable and opt-in; it is never the resolution of
   `inherit` — see the top-band invariant below.
-- `subagents.downshift`, `subagents.quota_arbitrage`, `subagents.model_map`
+- `subagents.quota_arbitrage`, `subagents.model_map`
   (see [`auto-orchestration-activation`](auto-orchestration-activation.md)).
+  Downshift itself is always on — the `subagents.downshift` key was retired on
+  2026-10-09 with its default as the fixed behavior.
 - The host-capability manifest's `separate_quota_pool`
   ([`host-capability-manifest`](host-capability-manifest.md)).
 
@@ -26,21 +28,19 @@ QUOTA ARBITRAGE IS A BONUS, NEVER LOAD-BEARING — REMOVE IT AND ROUTING IS
 THE SAME MINUS THE QUOTA WIN.
 ```
 
-1. **Downshift off** (`downshift: false`) → every sub-task runs on the session
-   tier. No routing change.
-2. **Downshift on** → a sub-task runs on its declared tier; an `inherit` task
+1. **Downshift** (always on) → a sub-task runs on its declared tier; an `inherit` task
    runs on the session tier, **bounded by the top-band invariant below**. The
    tier resolves to a model alias via `model_map`; an empty entry means "use
    the tier's runtime default" — never a baked-in provider model name.
-3. **Quota arbitrage** → prefer the **separate** quota pool for the sub-task
+2. **Quota arbitrage** → prefer the **separate** quota pool for the sub-task
    **only when** `subagents.quota_arbitrage == true` **and**
    `manifest.separate_quota_pool == true`. Otherwise the shared pool is used and
    the tier/model choice is unchanged. This is the only place the
    "Sonnet-has-its-own-allowance" idea lives, and it lives as a runtime-detected
    flag, never as portable prose.
-4. **Budget routing — ARCHIVED 2026-08-16, there is no fourth step.** This
+3. **Budget routing — ARCHIVED 2026-08-16, there is no third step.** This
    position used to describe a budget relation applied after the tier resolves
-   per 1–3: cheapest classifier-adequate tier WITH available budget, an atomic
+   per 1–2: cheapest classifier-adequate tier WITH available budget, an atomic
    pre-dispatch reserve, a cool-down on quota errors. None of it exists any
    more. A converged AI-council verdict (anthropic + openai, 2 of 2) archived
    `pickTier` and the permit lifecycle, because the `routing_switch` they
@@ -196,7 +196,7 @@ rule, or context asserts "model X is free".
 Tier vocabulary + cool-down state:
 [`src/scripts/_lib/tier_budget_routing.ts`](../../../../src/scripts/_lib/tier_budget_routing.ts)
 (`TIER_ORDER`, `readCooldowns` — the budget decision layer that used to live
-there is archived, see step 4), covered by
+there is archived, see step 3), covered by
 [`tests/scripts/tier_budget_routing.test.ts`](../../../../tests/scripts/tier_budget_routing.test.ts);
 live state: `agent-config routing:doctor` (orchestration section).
 

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

@@ -23,9 +23,11 @@ dispatch → monitor → status → escalate / kill
 
 ## Budget + parallel cap
 
-- The N=3 autonomous budget (`autonomous-execution`) binds **per validation
-  target**: three consecutive failed attempts on the same target halts the run
-  and surfaces the three attempts. `budgetHalt()` is the deterministic counter.
+- `budgetHalt()`'s per-target cap (`MAX_ATTEMPTS_PER_TARGET = 3`) is the
+  orchestrator's own number, not `autonomous-execution`'s
+  `execution.fix_loop_max` budget (now a default-10 ladder): three
+  consecutive failed attempts on the same target halts the run and surfaces
+  the three attempts. `budgetHalt()` is the deterministic counter.
 - `subagents.max_parallel` caps concurrent dispatch. No speculative fan-out:
   a subagent is spawned only for a classified-delegable target, never on spec.
 
@@ -175,7 +177,7 @@ requires a non-empty `emergency.orchestration_halt_justification`.
 
 ## Related
 
-- [`autonomous-execution`](../../rules/autonomous-execution.md) — the N=3 budget.
+- [`autonomous-execution`](../../rules/autonomous-execution.md) — the `execution.fix_loop_max` budget and its ladder.
 - [`auto-orchestration-activation`](auto-orchestration-activation.md) — `enabled`/`auto` keys.
 - [`orchestration-telemetry`](orchestration-telemetry.md) — the audit signals the guardrails read.
 - [`subagent-response-contract`](subagent-response-contract.md) — the structured body returned inside this 4-status envelope + the orchestrator's synthesis duties.

package/dist/agent-src/contexts/execution/terminal-states.md

@@ -114,7 +114,7 @@ state is not `success` it names what would change it:
 - [`verify-before-complete`](../../rules/verify-before-complete.md) — no
   completion claim without fresh evidence; this names what to claim when the
   claim is not completion.
-- [`autonomous-execution`](../../rules/autonomous-execution.md) — the N=3
-  validation budget whose firing is `exhausted`.
+- [`autonomous-execution`](../../rules/autonomous-execution.md) — the
+  `execution.fix_loop_max` validation budget whose firing is `exhausted`.
 - [`autonomy-mechanics`](autonomy-mechanics.md) — the budget's mechanics and the
   adaptive-effort ordering this page's progress-primary section states.

package/dist/agent-src/contexts/execution/toolchain-resolver.md

@@ -14,15 +14,9 @@ tools and run the right one — instead of a per-stack command explosion.
 > commands stay PHP-locked."
 
 **Size budget: none of its own.** The enforced ceiling is
-`check_depth_budget`'s 16,000 chars, and that is the only one.
-
-This page carried a self-imposed sub-ceiling through three values — 6,000,
-then 7,500, then 8,500 — and each was set just above whatever the file
-measured that day, so the next edit of any size broke it while the same
-sentence forbade raising it. A ceiling fitted to its own artifact is not a
-constraint, it is a tripwire; and the third one was set with a sentence
-claiming "real headroom" over 66 characters, which is the trap diagnosing
-itself and walking in anyway.
+`check_depth_budget`'s 16,000 chars (`DEPTH_CEILING_CHARS`), and that is the
+only one. Do not add a page-local ceiling: one fitted to the file's current
+size breaks on the next edit and constrains nothing.
 
 What actually bounds this page is **what belongs in it**: the resolver's
 contract — the axes, the detection order, the confidence tiers, the refusal
@@ -54,7 +48,7 @@ its package count, so the cost is proportional and not negligible.
 The **cache probe is the expensive path**, with the magnitude stated, not
 implied as a SHAPE, because the arithmetic has already been published wrong
 once: `latest_manifest_mtime` stats both fixed-name lists in every scope,
-bounded at 200 scopes, each hit paying a second stat — and without
+bounded at 200 scopes (`_MAX_BEHAVIOR_SCOPES`), each hit paying a second stat — and without
 an explicit `scopes` it also expands the globs. The guard can cost more than
 the resolution it guards, so a caller holding the scope list passes it. The
 widening is still right: a root-only key cannot see a behavior runner

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

@@ -10,7 +10,7 @@ Loaded by the `subagent-orchestration` skill and the `/do-and-judge`,
 |---|---|---|
 | `subagents.implementer_model` | _(empty → session model)_ | Model alias used for implementer subagents |
 | `subagents.judge_model` | _(empty → one tier up)_ | Model alias used for judge subagents |
-| `subagents.max_parallel` | `3` | Hard cap on concurrent subagent invocations |
+| `subagents.max_parallel` | `3` | Limit on concurrent subagent invocations the model reads from settings — no code counts spawns against it |
 
 ## Model tier ladder
 

package/dist/agent-src/guidelines/agent-infra/active-remediation-mechanics.md

@@ -150,6 +150,45 @@ artifact exists because the issue is still owed, and "it failed one of six" is n
 something a later triage can act on. A deferral with no reason is the
 note-and-forget this rule already forbids, wearing an artifact's clothes.
 
+## fix-what-you-see — why a separate rule, and its activation gap
+
+Moved verbatim from [`fix-what-you-see`](../../rules/fix-what-you-see.md)
+on 2026-10-06 to pay for the standing-payload cost of `neighbour-precedence`;
+the rule keeps a pointer here.
+
+### Why separate from `active-remediation`
+
+That rule forbids ignoring a spotted issue and its ladder permits **note + ask**.
+Two properties made it insufficient, both measured 2026-08-20: it is `type: auto`
+on `refactor`/`legacy`/`cleanup` triggers — **none of which a failing CI job
+matches**, so it does not load when the obligation matters most — and its
+note-and-ask tier is what let a session name a red check's cause, name the
+file's author, and hand it back still red.
+
+Mechanics (fix-now size criteria, follow-up shape) stay there; this rule only
+deletes the two escapes.
+
+### Honest activation gap — this rule is `auto`, and it wanted to be `always`
+
+It shipped `auto` for a budget reason, not a design one, and the gap that leaves
+is exactly the one it was written to close: **a red check the agent sees in tool
+output triggers nothing.** Keyword triggers match the PROMPT. So the rule loads
+when a human says "CI is red" or "not my test", and does NOT load when a test
+run comes back red and nobody has said a word.
+
+`check_always_budget` is the reason: the extended always-budget sat at
+60,252 / 60,254 chars — **two characters of headroom** — and the cap is a
+ratchet that may only move down. The other nine always-rules are the kernel,
+which `block_kernel_rule_writes` denies agent writes to, so no room can be made
+from this side. A 2,332-char rule puts the total at 103.9 %.
+
+Closing the gap needs one of: the ext-cap ratchet opened deliberately (a
+maintainer decision, recorded), a kernel rule shortened to make room, or a
+`post_tool_use` carrier that notices a non-zero verification exit — the only
+option that would fire on tool output rather than on wording. Until then, `auto`
+plus this paragraph is the honest state: the obligation is real, its delivery is
+partial, and the partiality is named rather than implied away.
+
 ## See also
 
 - [`active-remediation`](../../rules/active-remediation.md) — the rule this file details (Iron Law + ladder + live-security carve-out).

package/dist/agent-src/guidelines/agent-infra/context-hygiene-mechanics.md

@@ -69,7 +69,7 @@ If you need an ignored skill: read its SKILL.md directly, apply guidance, then a
 GitHub Copilot has no `PostToolUse` hook surface, so
 `scripts/context_hygiene_hook.ts` cannot run structurally and
 `agents/state/context-hygiene.json` is not maintained automatically
-(tool-call count, loop signal, freshness milestones at 20/40/60).
+(tool-call count, freshness milestones at 20/40/60).
 
 The cooperative path: track turns and tool-loop signals from memory
 during the conversation and apply the suggest-a-new-chat / 3-failure

package/dist/agent-src/guidelines/agent-infra/cross-source-consistency-mechanics.md

@@ -37,19 +37,17 @@ from a ticket/spec that carries a second source:
 4. **Classify confidence.** High = the sources plainly disagree, or the missing
    behavior is clearly load-bearing. Low = the "conflict" is a plausible
    re-reading, or the missing behavior may be intentionally out of scope.
-5. **Decide per the setting** (below), then **batch** every surviving discrepancy
-   into ONE question folded into this turn's single `ask-when-uncertain` prompt.
+5. **Batch** every surviving discrepancy into ONE question folded into this
+   turn's single `ask-when-uncertain` prompt.
 
-## Confidence-tiered noise control (`consistency.cross_source`)
+## Noise control
 
 The rule fires only under a real trade-off (it must pass the
-`no-cheap-questions` Pre-Send Self-Check). The setting tunes how aggressively:
-
-| Value | High-confidence discrepancy | Low-confidence discrepancy |
-|---|---|---|
-| `on` (default) | Surface + ask before proceeding. | Surface + ask (batched into the same question). |
-| `auto` | Surface + ask. | State as an explicit assumption and proceed (no question). |
-| `off` | No cross-source checking — legacy behavior. | No cross-source checking. |
+`no-cheap-questions` Pre-Send Self-Check). Every real discrepancy, high- or
+low-confidence, is surfaced and asked — batched into the same question. That
+is the fixed behavior since the `consistency.cross_source` key (which offered
+`auto` and `off`) was retired on 2026-10-09 with this, its default, as the only
+mode.
 
 Batching is the anti-noise mechanism: N discrepancies for one artefact become
 one numbered-options block, never N prompts. Plain vagueness (a single unclear

package/dist/agent-src/guidelines/agent-infra/frontier-reasoning-operating-profile.md

@@ -141,8 +141,9 @@ is therefore **agent self-assessed**, never looked up (roadmap L10/L17):
 **One** constraint-light scaffold ships — no heavy/light content variants, since
 two variants would be a hidden model→band table. A standard host **expands it on
 request**. Two gates, both default-on: automatic (task signal + agent
-self-assessment) + the user `reasoning:` settings toggle (global + per-component
-+ hard off).
+self-assessment) + the user's `reasoning.enabled` hard off. The per-component
+toggles and `reasoning.auto_gate` were retired on 2026-10-09; the automatic gate
+decides per component.
 
 ## Notes template grounding
 

package/dist/agent-src/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`, `rule_loading_tier`, `personal.bot_icon`, `personal.autonomy`, `memory.cadence` (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.autonomy` — the full whitelist is `MERGEABLE_KEYS` in `scripts/_lib/agent_settings.ts` (legacy `~/.config/agent-config/agent-settings.yml` read as fallback) |
 | `agents/settings/.agent-settings.yml` | **gitignored** | individual developer · this project | individual | `personal.ide`, `personal.user_name`, `subagents.max_parallel`, `onboarding.onboarded` | <!-- ref-ignore -->
 
 > **Canonical location (ADR-038):** the developer file lives in the settings
@@ -27,6 +27,12 @@ on user request.
 > `.agent-settings.yml` is read as a **back-compat fallback** and is migrated
 > into the canonical location by `install` on the next run.
 
+The `git.*` keys (`commit_format`, `branch_pattern`, `update_strategy`) have a
+fourth home a team uses instead: `.git-convention.yml` at the repository root,
+committed, read over every file above (ADR-283). `update_strategy` is read from
+it at the commit a pull request is judged against, the other two at `HEAD`.
+The team file carries no `git.*` key.
+
 All three are YAML. Schemas:
 
 - Developer (project-local): [`agent-settings.md`](../../templates/agent-settings.md).
@@ -45,6 +51,12 @@ Lowest priority → highest priority:
 4. agents/settings/.agent-settings.yml                (developer file, gitignored; legacy repo-root .agent-settings.yml read as fallback — ADR-038) <!-- ref-ignore -->
 ```
 
+For the `git.*` keys, `.git-convention.yml` sits above all four layers when it
+sets a key, and either value there is a declaration; a key it does not set
+falls through to this order, read at the repository root rather than per
+directory. `agent-config git:convention show` prints the value in force and a
+differing checkout value as a candidate.
+
 Keys from higher layers win unless a lower layer marks them
 `locked` (team file only). The user-global file does **not** support
 `locked` — its purpose is cross-project comfort, never policy.

package/dist/agent-src/guidelines/agent-infra/roadmap-progress-mechanics.md

@@ -224,7 +224,7 @@ Keep aligned with the dashboard counter in `scripts/update_roadmap_progress.ts`
 
 See [`guarded-baseline`](guarded-baseline.md).
 
-**Dashboard regen cadence — opt-in batching.** The checkbox flip is non-batchable. The **subprocess regen** (`./agent-config roadmap:progress`) is batchable per `roadmap.dashboard_regen_cadence` in `.agent-settings.yml` (`every_5_steps` default · `per_step` · `phase_boundary`). Run end, phase boundary, and any file-shape touch (rename / phase add / archive — Iron Law 1) always force an immediate regen regardless of cadence.
+**Dashboard regen cadence — fixed batching.** The checkbox flip is non-batchable. The **subprocess regen** (`./agent-config roadmap:progress`) batches to every 5th closed step — a fixed cadence since the `roadmap.dashboard_regen_cadence` key was retired on 2026-10-09 with that default as the behavior. Run end, phase boundary, and any file-shape touch (rename / phase add / archive — Iron Law 1) always force an immediate regen.
 
 **Blockers follow the same cadence as checkboxes.** Clearing a `## Blockers` entry (per `templates/roadmaps.md` rule 20) flips its `Status: resolved` and regenerates the dashboard in the same reply — Iron Law 1's "same response" obligation applies to blocker resolution exactly as it applies to a checkbox flip.
 

package/dist/agent-src/guidelines/agent-infra/self-improvement-pipeline.md

@@ -1,8 +1,11 @@
 # Self-Improvement Pipeline
 
 Five-stage flow that turns real project experience into reviewed
-rule / skill / command / guideline changes. No autonomous self-edits;
-every upstream change ships via a human-reviewed PR.
+rule / skill / command / guideline changes. Self-modification is a goal
+(ADR-281): for a proposal scoped to the package the approval is the AI
+council's ratification record, and the user is its last rung; a change a
+user asked for keeps that user's approval as now. A passing record makes a
+change ready, not landed — every upstream change still ships via a PR.
 
 Referenced by `road-to-curated-self-improvement.md`. Consumed by the live
 artifacts — the `skill-improvement-trigger` rule and the existing skills
@@ -84,7 +87,11 @@ blocks — it does not hand a half-filled doc to the next stage.
 
 ### Stage 5 — Upstream
 
-- **Trigger:** gate passed AND a human approver signed off.
+- **Trigger:** gate passed AND, for a proposal scoped to the package, a
+  council ratification record whose `subject` matches the proposal's change
+  passed it (ADR-281); where the council cannot conclude, the user decides by
+  the route ADR-281 § 5 names. A proposal scoped to a consumer's own project
+  needs that user's approval, as before.
 - **Executor:** `upstream-contribute` skill. Refuses invocation if
   the proposal frontmatter is not `stage: gated`.
 - **Input:** gated proposal doc.

package/dist/agent-src/guidelines/agent-infra/size-and-scope.md

@@ -221,6 +221,42 @@ Before creating or modifying:
 5. Is this entrypoint → AGENTS.md
 6. Is this behavior hint → copilot-instructions.md
 
+## Rich-class size band — moved from `token-budget-discipline`
+
+Moved verbatim from the rule on 2026-10-06 to pay for the standing-payload cost
+of `neighbour-precedence`; the rule keeps the band and a pointer here.
+
+### Candidate rich skills (justified, not exhaustive)
+
+These skills are approved `rich` by this roadmap's council:
+
+| Skill | Justification summary |
+|---|---|
+| `design-intelligence` | 11 corpus CSVs + 16 design-language prose specs + a 10-category checklist; grounded selection needs the full reference to avoid random corpus subsets |
+| `typography-system` | Modular-scale math + 6 worked example type systems; condensing to "use 1.25 ratio" produces agents that invent arbitrary px values |
+| `accessibility-auditor` | WCAG criteria are non-negotiable detail; every criterion has a testable condition + failure mode; compression loses the test procedures |
+| `design-system-capture` (Phase 6) | Writes + maintains DESIGN.md + PRODUCT.md; needs full templates + worked examples to generate useful artifacts |
+
+### The size band is measured, and only its ceiling is gated
+
+The `rich` band is **2,000–3,500 tokens** (ADR-217, `docs/decisions/ADR-217-rich-class-band-measured-and-enforced.md`).
+It was 2,000–5,000 and enforced by nothing until that record: measured with the
+exact BPE tokenizer, the largest rich artifact in the tree is 3,331 tokens, so
+the old ceiling described no artifact that existed. An unused permission costs
+nothing until someone uses it.
+
+`lint_token_budget_discipline.ts` gates the **ceiling** and publishes every rich
+artifact's size on the green path. It does **not** gate the floor, and that is a
+finding rather than an omission: running the check once surfaced a 1,931-token
+skill legitimately holding the class, because `rich` buys exemption from
+condensation — a claim about what compression would *lose*, not about file size.
+The published study supplies a degradation threshold, which is a ceiling.
+Nothing measures a minimum.
+
+Measurement is exact where `js-tiktoken` resolves and the character proxy where
+it does not; the gate says which, and a proxy reading within its own error
+margin of the ceiling is reported **unresolved** rather than classified.
+
 ---
 
 # Final principle

package/dist/agent-src/guidelines/design-antipatterns.md

@@ -114,7 +114,7 @@ Within-project invariants + repetition caps. Override = declare the value in
 | V2 | Glassmorphism as decoration (`backdrop-blur` + `bg-white/10`) with no functional depth hierarchy | Model defaults to it for "premium feel"; result looks like 2021 Material You clip-art | Element genuinely sits above a complex, blurred background layer; use sparingly and only for top-level floating surfaces | craft-presumption | delete → reduce | static |
 | V3 | Ghost card: `border: 1px solid` + box-shadow ≥ 16px spread together | The combination creates visual noise — the ghost card signals no confident decision about depth | Choose either border OR shadow to indicate depth; never both on the same surface | invariant | delete → reduce | static |
 | V4 | Over-rounded small cards or badges: `border-radius` > 16px on elements < 200px wide | Excessive rounding on small surfaces looks toy-ish; standard cap is 12–16px | Pill shape (`border-radius: 9999px`) is intentional on single-line tags/chips only | craft-presumption | retune | static |
-| V5 | Hand-drawn or illustrated SVG icons mixed with crisp icon-system icons | Visual register collision; instantly reads as "generated asset" | Intentional illustrative section (hero illustration, empty-state art); isolate from the icon system | invariant | replace | render |
+| V5 | Hand-drawn or illustrated SVG icons mixed with crisp icon-system icons | Visual register collision; instantly reads as "generated asset" | Intentional illustrative section (hero illustration, empty-state art); isolate from the icon system. A genuinely missing glyph is authored under [`svg-authoring`](../skills/svg-authoring/SKILL.md) against the incumbent set's own grid | invariant | replace | render |
 | V6 | Repeating diagonal stripes as a background texture | A cliché background default; reads as generated CSS art | Brand explicitly uses pattern backgrounds (e.g., a textile brand); document the stripe definition | style-preference | delete | static |
 | V7 | Nested cards: a card inside a card inside a card | Depth hierarchy collapses; user cannot parse elevation intent | A truly three-level hierarchy (e.g., project → board → card); ensure each level has distinct visual weight | invariant | delete → reduce | render |
 | V9 | Noise or grain texture laid over a gradient as a "premium" surface default | The visual sibling of V6's diagonal stripes — a generated-CSS-art texture reached for to make a flat gradient look considered, applied because it is available rather than because the surface needed a texture | The texture is part of a documented brand surface treatment (a print-inspired or analog-photographic identity) with the grain opacity defined as a token, not chosen per surface | style-preference | delete | render |