@event4u/agent-config 16.2.0 → 16.4.0

package/dist/agent-src/contexts/contracts/command-suggestion-flow.md

@@ -36,7 +36,7 @@ match()    →  raw scored matches per eligible command
    │
    ▼
 rank()     →  apply floor, drop blocklisted, anti-noise heuristics,
-              cap at max_options, stable tie-break
+              cap at 4 options, stable tie-break
    │
    ▼
 apply_cooldown()  →  drop (command, evidence) pairs shown in window
@@ -123,11 +123,13 @@ track separately.
 
 | Scope | Key | Effect |
 |---|---|---|
-| Whole project | `commands.suggestion.enabled: false` | Layer fully silent; explicit slashes still work |
 | Specific command | `commands.suggestion.blocklist: [cmd1, cmd2]` | Those commands never appear; still callable |
 | Specific conversation | User types `/command-suggestion-off` | Disabled until user types `/command-suggestion-on` or chat ends |
 
-Per-command frontmatter overrides the global floor and cooldown:
+There is no project-wide off switch: `commands.suggestion.enabled` and the
+global floor / cooldown / option-cap keys were retired on 2026-10-09 with their
+defaults (on · `0.6` · 600 s · 4) as fixed behavior. Per-command frontmatter
+still overrides the floor and cooldown for that command:
 
 ```yaml
 suggestion:
@@ -195,8 +197,8 @@ Together they enforce:
 
 On Claude.ai Web / Skills API, the suggester package is **not** part
 of the standard bundle (T2 ZIPs ship rules + skills, not Python
-helpers). Treat `commands.suggestion.enabled` as `false` — degrade
-silently, never crash the turn. Local agents (Augment, Claude Code,
+helpers). Treat the layer as absent there — degrade silently, never crash
+the turn. Local agents (Augment, Claude Code,
 Cursor, Cline, Windsurf) get the engine via `scripts/`.
 
 ## See also
@@ -204,4 +206,4 @@ Cursor, Cline, Windsurf) get the engine via `scripts/`.
 - [`command-suggestion`](../../rules/command-suggestion-policy.md) — runtime rule
 - [`adr-command-suggestion.md`](adr-command-suggestion.md) — architectural decision
 - [`command-suggestion-eligibility.md`](command-suggestion-eligibility.md) — locked eligibility table
-- [`agent-settings`](../../templates/agent-settings.md) — `commands.suggestion.*` reference
+- [`agent-settings`](../../templates/agent-settings.md) — `commands.suggestion.blocklist` reference

package/dist/agent-src/contexts/contracts/frugality-charter.md

@@ -33,12 +33,15 @@ Live Phase 1 schema (see [`templates/agent-settings.md`](../../templates/agent-s
 
 | Key | One-line semantics |
 |---|---|
-| `verbosity.preview_artifacts` | When `false`, skip generated commit messages / PR titles / branch names preview before acting. |
-| `verbosity.routine_confirmations` | When `false`, skip "looks good?" gates on routine workflow steps. Iron-Law gates always ask. |
 | `verbosity.offer_council_in_delivery` | When `false`, delivery commands skip the optional "run Council on this?" offer. |
-| `verbosity.post_action_reports` | `off` / `minimal` / `full` — multi-line status blocks after a successful action. |
-| `verbosity.intent_announcements` | When `false`, writers must not generate "Let me…", "Now I will…", "Found it" openers. |
-| `telegraph.speak` | When `false` (the shipped default) the telegraph-speak rule does not ship at all; when `true` its own carve-out list states the grammar's scope — options blocks, Iron-Law literals, code, and paths stay byte-stable. |
+
+Five former hooks were retired on 2026-10-09 with their defaults as the fixed
+behavior, so writers state the behavior instead of citing a key: no preview of
+generated commit messages / PR titles / branch names before acting; no
+"looks good?" gate on a routine step with one obvious answer (Iron-Law gates
+always ask); after a successful action, a one-line confirmation, never a
+multi-line status block; no "Let me…", "Now I will…", "Found it" openers; and
+the telegraph-speak rule does not ship.
 
 Phase 10 adds `verbosity.script_output` (`silent` / `minimal` / `verbose`) and `verbosity.taskfile_command_echo` (`true` / `false`); writer artifacts cite this row when those land.
 

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

@@ -224,7 +224,7 @@ NEVER A SILENTLY DEGRADED ANSWER. NO LLM CLASSIFIER FALLBACK (CUT C3).
 
 | Task pattern | Lookup class | Primitive |
 |---|---|---|
-| "where is X defined" / "confirm X's definition location" | `definition` | capped `rg` (definition-shaped patterns, `--max-count`); `code_graph query` only as an opportunistic accelerant when an index is present + fresh + `hooks.code_graph.enabled: true` |
+| "where is X defined" / "confirm X's definition location" | `definition` | capped `rg` (definition-shaped patterns, `--max-count`); `code_graph query` only as an opportunistic accelerant when an index is present + fresh (`hooks.code_graph.enabled` gates nothing — it is inert) |
 | "who calls / imports X" / "confirm call sites" | `references` | capped `rg` (reference-shaped patterns); same optional `code_graph affected` accelerant clause |
 | "does string Y exist" / "probe candidate strings" | `string-existence` | FTS one-shot (`memory_lookup` for the knowledge corpus) or capped `rg -n --max-count` for the codebase |
 | "run report Z" / "run check_*" | `report-run` | direct script run, wrapped per the **measured** rtk allowlist (`internal/bench/rtk-savings/RESULTS.md` — wrap only the ~55%-savings class) |
@@ -232,11 +232,11 @@ NEVER A SILENTLY DEGRADED ANSWER. NO LLM CLASSIFIER FALLBACK (CUT C3).
 **Why rg-first** (council 2026-07-28, 2 rounds): the pre-registered benchmark
 behind the `code-graph-retrieval-null` claim (`docs/CLAIMS.md`) measured
 native-graph recall 0.365 vs grep 0.797 on graph-shaped questions — an
-indexing gap that kept `code_graph.enabled` false BY DEFAULT until that flag
-was retired (2026-09-07) — not permanently: the 2026-08-15 withdrawal retracted
-that, and the figures predate the 2026-08-22 extractor repair. The accelerant
-clause above is that bound's escape hatch, reached only when a caller passes a
-usable graph, which no production caller yet does.
+indexing gap that kept `code_graph.enabled` false BY DEFAULT until the hook it
+gated was replaced (2026-09-07), leaving the key inert and still registered —
+not permanently: the figures predate the 2026-08-22 extractor repair. The
+accelerant clause above is that bound's escape hatch, reached only when a
+caller passes a usable graph, which no production caller yet does.
 
 **Escalation, not degradation:** a primitive that returns nothing (index miss,
 pattern too ambiguous, report script absent) — **or an unusable result**
@@ -276,5 +276,5 @@ rung-3 degrade path, the recursive-dispatch guard and every ∅ case.
 
 - [`auto-orchestration-activation`](auto-orchestration-activation.md) — the enable/auto/manifest gate that runs before classification.
 - [`subagent-orchestration`](../../skills/subagent-orchestration/SKILL.md) — the modes this selects.
-- [`autonomous-execution`](../../rules/autonomous-execution.md) — the N=3 budget any LLM-classification v2 must respect.
+- [`autonomous-execution`](../../rules/autonomous-execution.md) — the fix-loop budget v2 must respect.
 - [`orchestration-telemetry`](orchestration-telemetry.md) § Registered always-on metrics — the judgment-ladder precision metric this ladder feeds.

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

@@ -17,7 +17,6 @@ set, and what the host can physically do.
 
 | Key | Default | Purpose |
 |---|---|---|
-| `subagents.downshift` | `true` | Route delegable sub-tasks to the lowest-capable tier (Phase 2). |
 | `subagents.quota_arbitrage` | `true` | Prefer a separate-quota-pool model where the host manifest allows it (Phase 2 bonus). |
 | `subagents.model_map` | `{}` | Optional per-tier model override for downshift routing. |
 | `emergency.orchestration_halt` | `false` | The ONE audited incident switch — see [`settings-classes.md`](../../docs/contracts/settings-classes.md) § "The one exception". NOT an activation gate: on-by-default, ceremony-free to arm, requires a non-empty `orchestration_halt_justification` to disarm. |

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

@@ -164,8 +164,8 @@ explicitly and the default flips back only on a positive reuse signal).
 - **Redaction on write.** Promotion runs the `low-impact-corpus-privacy-floor`
   + `source-confidentiality` pattern set and **halts** on any hit — never
   silent-shares, never auto-rewrites.
-- **Promotion is hybrid.** A `public`/`vendor` card seen in ≥`auto_promote_threshold`
-  distinct repos triggers a one-tap **suggestion**; never a silent write.
+- **Promotion is hybrid.** A `public`/`vendor` card seen in ≥2 distinct repos
+  triggers a one-tap **suggestion**; never a silent write.
 
 ## Evidence v2 rollback target (Phase 0)
 

package/dist/agent-src/contexts/execution/non-interactive-contract.md

@@ -104,25 +104,22 @@ black box):
 
 ## 7. Kill-switch — disable auto-detection without a rollback
 
-Three override layers, narrowest wins:
+Two override layers, narrowest wins:
 
 1. **Per-invocation:** `--no-auto-detect` → fall back to the menu
    (interactive) or `missing_sub_command` (CI).
 2. **Per-orchestrator:** `auto_detect: false` in the command's
    front-matter → that orchestrator always shows the menu.
-3. **Global:** `commands.auto_detect: disabled | warn | enabled` in
-   `.agent-settings.yml` (default `enabled`; `warn` = detect but always
-   confirm).
 
-A misbehaving heuristic is disabled by config, not by reverting 6.1.0.
+There is no global switch: the `commands.auto_detect` settings key was retired
+on 2026-10-09 with its default (`enabled`) as the fixed behavior, so a
+misbehaving heuristic is disabled per orchestrator, not by reverting 6.1.0.
 
 ## 8. Rollback procedure (every orchestrator references this)
 
 1. Re-run with the explicit sub-command (`/judge solo`) — detection is
    skipped.
-2. Disable globally: `commands.auto_detect: disabled` in
-   `.agent-settings.yml`.
-3. Disable one orchestrator: set `auto_detect: false` in its
+2. Disable one orchestrator: set `auto_detect: false` in its
    front-matter — the change takes effect on the next projection/sync.
 
 ## See also

package/dist/agent-src/contexts/execution/rdp-gate.md

@@ -23,11 +23,11 @@ maintain a model list, and never ship heavy/light content variants (two variants
 
 ## Three signals (all table-free)
 
-1. **User settings** — read the `reasoning:` block in `.agent-settings.yml`:
+1. **User settings** — read `reasoning.enabled` in `.agent-settings.yml`:
    - `enabled: false` → the whole layer is inert. Stop here.
-   - per-component switch off (e.g. `components.verifier_default: false`) → that
-     component never fires.
-   - `auto_gate: false` → skip signal 3 (self-assessment); gate on signal 2 only.
+   - There is no per-component switch and no switch for signal 3: both were
+     retired on 2026-10-09 with their default (`true`) as the fixed behavior,
+     so every component follows signals 2 and 3 below.
 2. **Task signal** (knowable per turn, no model lookup):
    - **Skip** RDP when the task is trivial / short / fully-specified (rename,
      typo, format, one-line edit, list files, bump a version).

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
@@ -1056,8 +1071,38 @@ execution either way.
 
 ### 6a. Deferred-resolution gate — Iron Law 3
 
-Before any `git mv` to `archive/`, count `[~]` items in the closing
-roadmap. If `count_deferred > 0`, archival is **blocked** per
+**Default: the sweep resolves it.** `archive_completed_roadmaps --all` carries
+every bare `[~]` step, plus every open blocker such a step names, into a
+`<slug>-carried` follow-up created in the same change (`deferral_carry.ts`),
+annotates the parent `carried-to=<slug>`, and archives — the "carry item +
+blocker" council row below, executed deterministically, so a finished
+`/roadmap:process-full` run ends archived instead of parked at 100 %. The
+manual flow below applies only to what the sweep refuses: an open blocker no
+deferred step names, a hand-written annotation that fails validation, or a run
+with `--no-carry`.
+
+**Owner-dependent blockers stop the carry.** When a carried step names a blocker
+whose `Owner:` is the human (`maintainer` / `user` / `owner`, or any value that is
+not `implementer` / `council` / `agent` / `ai`), the sweep writes nothing and
+prints a `❓` block plus one `OWNER-DECISION {json}` line. Put that decision to
+the owner as ONE numbered-options question, never resolve it yourself:
+
+1. **Archive it** — run the printed `archive_command` (`… --owner-decision later --only <roadmap>`):
+   the parent archives, the steps and their blockers park in
+   `later/<slug>-carried.md`.
+2. **Step by step** — show the FIRST step (`first_step`, verbatim) with its
+   blocker's question, in the same message, so the owner can answer it or push
+   it to later in one reply. An answer → do the step, flip it, show the next
+   one. "Later" → leave that step `[~]` and show the next one. When no step is
+   left to show, run that `archive_command`: what is still
+   deferred parks, the parent archives.
+
+A **subagent** never answers this and never passes `--owner-decision` itself: it
+stops and returns the `OWNER-DECISION` line verbatim, and the orchestrator puts
+it to the owner. A non-interactive run ends on the question, not on a report.
+
+Before any `git mv` to `archive/` the sweep refused, count `[~]` items in the
+closing roadmap. If `count_deferred > 0`, archival is **blocked** per
 [`roadmap-progress-sync § Iron Law 3`](../../rules/roadmap-progress-sync.md).
 The loop MUST:
 

package/dist/agent-src/contexts/execution/session-canary-enforcement-history.md

@@ -0,0 +1,67 @@
+# Session Canary — Enforcement History
+
+Loaded by [`session-canary`](../../rules/session-canary.md). Four dated
+conformance audits of the canary carrier, moved here verbatim so the rule
+states its obligation and this file holds the record behind it. Nothing was
+rewritten; the measurements and their stated limits are as they were written.
+
+**What that fixed, stated because it was measured.** Conformance audit, 30
+sessions, 2026-08-06, under session-scope-only injection: opening canary dropped
+on ~13 of 15 task starts, often present only in the closing summary, twice
+carrying a name the settings chain did not resolve; the honesty clause fired
+zero times. The frequency join in `check_enforcement_coverage.ts` now reports the
+carrier as covering the obligation — which is a claim about firing, not about
+compliance.
+
+**What the second audit found: the carrier fires and compliance did not
+follow.** Conformance round 5, 2026-08-07, reading the five highest-turn
+sessions with the carrier bound per turn: opening canary dropped on **24 of 29**
+task starts, the honesty clause fired **0** times, and the wrong name was
+emitted **twice** — "Mathias", which resolves from no layer of the chain
+(`identity.name` is `Matze`, `git config user.name` is `matze4u`), i.e. inferred
+from the ambient environment rather than read from settings. 24/29 against the
+earlier 13/15 is not a fall, and the two windows are not identical, so they are
+stated side by side rather than as a trend — but nothing here supports the claim
+that the miss rate moved. A reminder in context is therefore not a mechanism for
+this obligation: at higher frequency it is the same request, more often.
+
+**What the next mechanism has to be.** Not another injection. It has to be able
+to **refuse** — a check at delivery (`stop` is block-capable on this host, so a
+refused turn-end continues in the same turn) that rejects a task-start reply
+carrying no greeting. Proposed, not shipped; until it is, this obligation is
+model-carried in practice, whatever the frequency join reports.
+
+**Round 7 downgrade: that proposed mechanism is UNDECIDABLE as written, and the
+obligation splits into a measured half and an unmeasurable one.** A *task* start
+is recorded nowhere in a transcript — there is no task event on any host, and
+`user-interrupt-priority`'s continuation/clarification/interrupt distinction is a
+judgement, not a field. So a delivery check "that rejects a task-start reply" has
+no way to know a task started. The proposal is not merely unbuilt; as specified it
+cannot be built, and saying "proposed, not shipped" implied otherwise.
+
+What IS decidable is the per-**session** instance, and it was measured rather than
+asserted — reproducibly, which took a correction: the probe resolves the name
+through the same settings layers this rule names and REFUSES when no layer carries
+one, so the figure below is reproduced with the name passed explicitly
+(`./scripts-run src/scripts/probe_session_canary --limit 30 --name <your name>`;
+the first version hardcoded a maintainer's nickname as its default, which made the
+number irreproducible for anyone else and silently read 0 %). Over 30 sessions on
+2026-08-12: the opening greeting is present in **25 of 28** sessions carrying
+assistant prose (89.3 %), and in **24 of 25** post-carrier (96.0 %). Of the three
+misses, two predate the carrier (2026-07-21, 2026-07-29) and one is a session whose
+first thirty turns were tool calls.
+
+Both halves of that are load-bearing. The carrier works exactly where it has a
+slot — `session_start` — which is why the session-scope figure is high; and the
+24-of-29 task-start figure above is not contradicted by it, because the two count
+different events. The honest statement is therefore: **session-scope compliance is
+measured and good; task-scope compliance is unmeasured and unmeasurable with
+today's transcript, and no gate can change that until a task boundary is recorded
+somewhere.** Do not read the 96 % as covering the obligation as a whole.
+
+**The wrong-name half needs nothing, and that is worth stating.** The beat
+already carries the resolved value — `build_canary_reminder` emits
+`Canary active for "<name>"`, and the hook no-ops when no layer resolves a name —
+and both wrong-name occurrences predate it: 2026-08-04, where the per-turn beat
+landed 2026-08-06. The inference path they measure is already closed, so a third
+audit should not re-open it.

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.