@event4u/agent-config 7.5.0 → 8.0.0

package/dist/agent-src/commands/team-knowledge/consolidate.md

@@ -0,0 +1,105 @@
+---
+model_tier: medium
+name: team-knowledge-consolidate
+pack: meta
+tier: 2
+visibility: internal
+cluster: team-knowledge
+sub: consolidate
+description: Review pending typed knowledge-observation events and file them into agents/knowledge/ pages as a human-reviewed batch — never writes without approval.
+skills: [file-editor]
+suggestion:
+  eligible: true
+  trigger_description: "consolidate knowledge events, review pending observations, file captured knowledge, promote knowledge candidates"
+  trigger_context: "pending events have accumulated in agents/knowledge/intake/ and are ready for review"
+workspaces:
+  - agent-config-maintainer
+packs:
+  - meta
+---
+
+# /team-knowledge consolidate
+
+Turns the gitignored, in-flight typed-observation events
+(`convention_detected` / `mistake_made` / `api_shape_learned` /
+`context_stale` — see `src/scripts/_lib/knowledge_events.ts`) into
+committed `agents/knowledge/` pages. This is the ONLY path from intake
+to a tracked page — no skill or rule writes a tracked knowledge page
+mid-task (see [`knowledge-pages`](../../templates/contexts/knowledge-pages.md)
+§ Storage location).
+
+## Steps
+
+### 1. Generate the report
+
+```bash
+./scripts-run src/scripts/consolidate_knowledge_events
+```
+
+Aggregates pending events by topic and finds the nearest EXISTING
+knowledge page for each aggregate (mechanical similarity only — the
+script never decides the triage verdict).
+
+No pending topics → tell the user and stop. Nothing to do.
+
+### 2. Triage each topic
+
+For each aggregate in the report, apply the same taxonomy
+[`memory-consolidation`](../../skills/memory-consolidation/SKILL.md)
+uses for engineering-memory facts:
+
+| Triage | Condition | Action |
+|---|---|---|
+| `NEW` | No nearest page reported | Draft a new page under the appropriate typed dir |
+| `EXTEND` | Nearest page reported, covers the topic but misses this detail | Draft an addition to that page |
+| `CONFIRM` | Nearest page already states this exactly | Discard this aggregate — no page change |
+| `CONFLICT` | Nearest page states the opposite or a stale variant | Draft BOTH positions into that page with `contested: true`, never silently overwrite |
+
+A high similarity score alone does not distinguish `EXTEND` /
+`CONFIRM` / `CONFLICT` — read the matched page and the aggregate's
+events before deciding.
+
+### 3. Draft and present the batch
+
+For every `NEW` / `EXTEND` / `CONFLICT` aggregate, draft the page
+content (following [`knowledge-pages`](../../templates/contexts/knowledge-pages.md) —
+`date + what + why` for session entries, ≤ 200 lines per page) and
+present the full batch to the user:
+
+```
+> Knowledge consolidation — N topic(s) ready for review:
+>
+> 1. [NEW] <topic> → agents/knowledge/concepts/<slug>.md
+> 2. [EXTEND] <topic> → agents/knowledge/procedures/<existing>.md
+> 3. [CONFLICT] <topic> → agents/knowledge/concepts/<existing>.md (contested)
+>
+> 1. Write all — 2. Write selected — 3. Discard all — 4. Edit a draft first
+```
+
+**Never write before this confirmation.**
+
+### 4. Write, regenerate, clear
+
+On approval:
+
+1. Write each approved page (respecting the team-sharing gate —
+   never set `visibility: private` on a page landing here).
+2. Regenerate the index: `./scripts-run src/scripts/generate_knowledge_index`.
+3. Clear the consumed intake: `./scripts-run src/scripts/consolidate_knowledge_events --commit`
+   (all-or-nothing — re-run step 1 first if the user picked "write
+   selected" and some topics were discarded, so only genuinely
+   consumed events are cleared).
+
+## Rules
+
+- Never invents a page from an aggregate the user did not approve.
+- Never resolves a `CONFLICT` verdict automatically — both positions
+  land in the page, human resolves later.
+- Never writes a page with `visibility: private` (belongs in the
+  ADR-100 global store instead).
+- Do NOT commit the written pages — that is the user's call.
+
+## See also
+
+- [`memory-consolidation`](../../skills/memory-consolidation/SKILL.md) — the sibling loop for the 5 fixed engineering-memory types; this command is its knowledge-page counterpart.
+- [`learning-to-rule-or-skill`](../../skills/learning-to-rule-or-skill/SKILL.md) — where a page's recurring topic graduates into a skill/rule once it crosses the skill-candidate threshold.

package/dist/agent-src/commands/team-knowledge.md

@@ -0,0 +1,64 @@
+---
+model_tier: medium
+name: team-knowledge
+disable-model-invocation: true
+pack: meta
+intent: "Manage the repo-tracked team-knowledge layer — consolidate typed observation events into agents/knowledge/ pages, bootstrap a project baseline"
+routes_to: [team-knowledge-consolidate, team-knowledge-bootstrap]
+replaces: []
+tier: 2
+visibility: internal
+description: Team-knowledge orchestrator — routes to consolidate and bootstrap
+cluster: team-knowledge
+type: orchestrator
+suggestion:
+  eligible: true
+  trigger_description: "consolidate knowledge events, review pending knowledge observations, promote captured knowledge into pages"
+  trigger_context: "user wants to turn accumulated in-flight observations into committed agents/knowledge/ pages"
+workspaces:
+  - agent-config-maintainer
+packs:
+  - meta
+---
+
+# /team-knowledge
+
+Top-level orchestrator for the `/team-knowledge` family — the
+consolidation gate over the typed knowledge-observation events
+captured during normal task work (see
+[`knowledge-pages`](../templates/contexts/knowledge-pages.md) and the
+event schema in `src/scripts/_lib/knowledge_events.ts`).
+
+Not to be confused with the pre-existing `/knowledge` cluster (local
+file ingestion into `agents/memory/knowledge/`) — different concern
+(arbitrary local documents), unrelated to this repo-tracked,
+lifecycle-typed team-knowledge layer under `agents/knowledge/`.
+
+## Sub-commands
+
+| Sub-command | Routes to | Purpose |
+|---|---|---|
+| `/team-knowledge consolidate` | `commands/team-knowledge/consolidate.md` | Read pending intake events, propose tracked-page creates/updates as a reviewable batch, write only on approval |
+| `/team-knowledge bootstrap` | `commands/team-knowledge/bootstrap.md` | One-shot deterministic seed of a fresh project's knowledge pages from real config/directory detection — staged, never auto-committed |
+
+Sub-command names match the locked contract in
+[`docs/contracts/command-clusters.md`](../docs/contracts/command-clusters.md).
+
+## Dispatch
+
+1. Parse the user's argument: `/team-knowledge <sub-command> [args]`.
+2. Look up the sub-command in the table above.
+3. Load the body of the routed file and follow its `## Steps` section
+   verbatim with the remaining args.
+4. If the sub-command is unknown or missing, print the table above and ask:
+
+   > 1. consolidate — review pending knowledge events and file them as pages
+   > 2. bootstrap — seed a fresh project's knowledge pages from detection
+
+## Rules
+
+- **Never writes a tracked page without human approval.** Intake is
+  proposal-only; the consolidate flow always shows a batch and waits.
+- **Never fires automatically** — the user invokes this explicitly.
+- **Do NOT commit, push, or open a PR** unless the sub-command
+  explicitly authorizes it.

package/dist/agent-src/contexts/authority/commit-mechanics.md

@@ -71,6 +71,14 @@ The pre-scan ask is the **only** permitted commit-related question
 in autonomous mode. Once answered, the decision is cached for the
 rest of the roadmap execution.
 
+When the roadmap declares `execution.mode: autonomous |
+phase-checkpoints`, this pre-scan ask is subsumed by the run-start
+**execution contract** — one acceptance covers commits, the run's
+feature branch, push to that branch only, and PR-open; see
+[`roadmap-execution-contract`](../execution/roadmap-execution-contract.md)
+and [`scope-mechanics § Roadmap execution contract`](scope-mechanics.md).
+The Hard-Floor per-commit diff gate above is unaffected.
+
 ## Speech-act check on commit phrases
 
 The same speech-act check from

package/dist/agent-src/contexts/authority/destructive-mechanics.md

@@ -55,6 +55,17 @@ A roadmap or task authorizes the *edit*; only the user-this-turn
 authorizes the *commit* (row 6 of the rule's trigger table). Surface
 the diff (paths + counts), get confirmation, then commit.
 
+## Inspect before delete or overwrite
+
+Before running any delete or overwrite — even one already cleared by
+the checks above — look at the target first. If its actual contents
+contradict how it was described (a "generated" file that turns out to
+carry hand-edits, a "stale" branch with commits you don't recognize, an
+"empty" directory that isn't), surface the discrepancy and stop instead
+of proceeding on the original description. The same holds for anything
+you did not create yourself this session: verify before assuming it is
+safe to remove or replace.
+
 ## Failure modes
 
 - Treating a standing autonomy directive as cover for a Hard-Floor

package/dist/agent-src/contexts/authority/scope-mechanics.md

@@ -58,6 +58,31 @@ pinning inside it. If the user names a version in a planning
 request, ask whether the artifact tracks the work or the release;
 default to work.
 
+## Roadmap execution contract — run-scoped standing permission
+
+An **accepted run-start execution contract**
+([`roadmap-execution-contract`](../execution/roadmap-execution-contract.md),
+derived by `roadmap-process-loop § 3` when the roadmap declares
+`execution.mode: autonomous | phase-checkpoints`) IS "explicit
+permission … in a standing instruction not yet revoked" for
+`scope-control § git-ops` — **for that run, and for exactly four
+operations**:
+
+1. Create the run's feature branch (`feat/<roadmap-slug>`, or reuse
+   the current worktree branch).
+2. Chunked commits on that branch (Hard-Floor per-commit diff gate
+   stays; split per `commit-policy`).
+3. Push to **that branch only** — any other ref stays Hard Floor.
+4. Open ONE PR (description-only flow) — never merge / close /
+   retarget.
+
+Boundaries that survive every contract: the frontmatter field alone
+grants **nothing** (declaration of intent — no accepted contract, no
+grants); grants expire when the run ends or halts; prod-trunk
+operations, deploys, bulk deletions, infra commits, and merges are
+outside contract scope always; kernel-rule edits keep their own-PR +
+24h-soak guarantee.
+
 ## Brief-before-asking — separate branch / PR / worktree
 
 If a task seems to need a separate branch or PR (spike, hotfix,

package/dist/agent-src/contexts/communication/rules-auto/reply-close-mechanics.md

@@ -0,0 +1,43 @@
+# Reply close — work summary + PR link
+
+Lookup material for the reply-close carve-out in the
+[`direct-answers`](../../../rules/direct-answers.md) Brevity Iron Law. Rule body
+states the obligation in one line; this file is the detail.
+
+## The carve-out
+
+Brevity governs the reply **body**; the **close** is the exception.
+
+- Reply that landed **substantial work** — multi-step change, roadmap/branch
+  progress, or a created/updated PR — ends with **ONE** compact status summary at
+  the very end, never mid-reply: what's done, what remains.
+- **Simple one-answer replies still skip the summary** (Brevity Iron Law unchanged
+  for them). Summary is for work replies, not every turn.
+
+## PR link is the literal last line
+
+PR **created or updated this turn** → its raw GitHub URL is the **literal last
+line**, after the summary, nothing below it — so the user never hunts for it. One
+PR → one URL line.
+
+- Only when a PR was actually created/updated **this turn**. No PR → no link line.
+- Raw URL (not a masked markdown link) so it is unmistakable and clickable.
+
+## Why it does not collide with sibling rules
+
+- **`language-and-tone`** last-line rule: a raw URL is language-neutral → satisfies
+  the "every user-visible token mirrors the user's language" gate.
+- **`no-pr-progress-comments`** / **`no-attribution-footers`**: those govern
+  comments posted *on the PR*. Summary + URL here are the **chat reply body**, not
+  a PR comment — neither applies.
+- **`user-interaction`**: a numbered-options block, when present, still comes last
+  among interactive elements; the PR URL sits below it as the final line and is not
+  an "open question" → does not trip the no-trailing-open-question rule.
+
+## Failure modes
+
+- Burying the summary mid-reply, then continuing with more detail below it.
+- Emitting the summary for a trivial one-answer reply (brevity says skip).
+- Creating a PR but leaving its URL mid-reply, forcing the user to scroll/search.
+- Masking the URL behind link text so it is not obviously the PR.
+- Adding a PR-link line when no PR was created this turn.

package/dist/agent-src/contexts/contracts/agents-md-anatomy.md

@@ -104,7 +104,7 @@ package edit touches the same hot file.
    `agents/settings/contexts/`, `docs/contracts/`, an existing rule body, or
    an existing skill body. Replace in-file with a substantive
    pointer. Never invent a new top-level dir.
-5. **Verify.** Run `python3 scripts/lint_agents_md.py` until green;
+5. **Verify.** Run `./scripts-run src/scripts/lint_agents_md` until green;
    `wc -c AGENTS.md` ≤ target cap; emergency-triage block intact.
 
 ## Common gotchas

package/dist/agent-src/contexts/contracts/artifact-engagement-flow.md

@@ -213,7 +213,7 @@ rule listed above:
 
 ```bash
 # Validate every line against the schema + redaction floor
-python3 -c '
+node -e '
 import pathlib, sys
 sys.path.insert(0, ".agent-src.uncondensed/templates/scripts")
 from telemetry.engagement import EngagementSchemaError, parse_event
@@ -232,7 +232,7 @@ print(f"{ok} valid, {bad} rejected")
 '
 
 # A bad-line spot-check that does not depend on the validator
-python3 -c '
+node -e '
 import json, pathlib, re
 forbidden = re.compile(r"[/\\\\]|\.[a-z0-9]{1,10}$", re.IGNORECASE)
 for line in pathlib.Path(".agent-engagement.jsonl").read_text().splitlines():

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

@@ -18,6 +18,7 @@ Cite the source rule in writer artifacts; do **not** restate it here.
 | Numbered-options trade-off rule (real consequence, not sequencing) | [`user-interaction § Iron Law 1 — Single-Source Recommendation`](../../rules/user-interaction.md#iron-law-1--single-source-recommendation) |
 | Cheap-question pre-send check (skip the ask if context already answers) | [`no-cheap-questions § Pre-Send Self-Check`](../../rules/no-cheap-questions.md#pre-send-self-check--mandatory-before-every-question) |
 | Tool-call discipline, act-skip-narration, fresh output over memory | [`token-efficiency § The Iron Laws`](../../rules/token-efficiency.md#the-iron-laws) and its mechanics file |
+| Budget is an input to the decision, never the decision — surface the trade-off before auto-rejecting a net-positive change on cost grounds | [`token-budget-discipline § Value-over-budget escalation`](../../rules/token-budget-discipline.md#value-over-budget-escalation) |
 
 ## Confirmation taxonomy
 

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

@@ -21,10 +21,20 @@ A task is classified **delegable** when **any** of these holds:
    `parallelizable: steps | files | independent` in its frontmatter.
    - `steps` → ordered plan → `do-in-steps`.
    - `files` / `independent` → independent slices → `do-in-parallel`.
-2. **Ordered-plan structure** — the task is an explicit ordered plan (numbered
-   steps / a roadmap phase / a checklist) → `do-in-steps`.
-3. **Independent-slices structure** — N independent targets of the same shape
-   (e.g. "review these 5 files", "convert each adapter") → `do-in-parallel`.
+2. **Ordered-plan structure** — explicit ordered plan (numbered steps / a roadmap
+   phase / a checklist) → `do-in-steps`. Deterministic markers:
+   - `1. … 2. … 3.` numbered list in the user message.
+   - References a roadmap phase or checklist.
+   - "first … then … finally" with distinct deliverables.
+   - "in N steps" or "phase by phase".
+3. **Independent-slices structure** — N ≥ 3 independent targets of the same shape
+   → `do-in-parallel`. Deterministic markers (N ≥ 3 of the same form):
+   - N file paths, each a separate analysis/edit target.
+   - N named modules/components for the same action.
+   - N named test files, adapters, endpoints, or services to convert/review/audit.
+   - "for each X in [list]" where list ≥ 3 items, no cross-item dependency.
+   Do **not** fire on interdependent lists (e.g. "add these 3 sequential
+   migrations") — those are ordered plans (signal 2).
 
 AND the **task-size floor** is cleared: the task's estimated size exceeds a
 minimum (trivial one-line edits never delegate — the dispatch overhead

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

@@ -71,3 +71,14 @@ regardless of `personal.autonomy`:
 Push, merge, rebase, branch creation, PR operations, and tags
 remain permission-gated by
 [`scope-control § git-operations`](../../rules/scope-control.md#git-operations--permission-gated).
+
+## End-of-turn checkpoint
+
+Before ending a turn, check the last paragraph of the reply. If it is a
+plan, an open question the context already answers, or a promise of
+unexecuted work ("I'll…", "next I will…"), do that work now with tool
+calls instead of ending the turn — this is what "the turn isn't done
+until it's done" means in practice. This checkpoint operates inside the
+existing bounds: the N=3 validation-loop budget and the Hard Floor
+still apply unchanged; the checkpoint closes out work already in scope,
+it never licenses continuing past either limit.

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

@@ -15,9 +15,11 @@ v1 forward-compat rule on unknown fields).
   "spawn_count": 0,
   "tiers": [],
   "token_delta": 0,
+  "token_delta_provenance": "estimated",
   "wall_clock_ms": 0,
   "outcome": "DONE",
-  "verify_mode": "deterministic"
+  "verify_mode": "deterministic",
+  "verdict_changed_outcome": null
 }
 ```
 
@@ -25,13 +27,15 @@ v1 forward-compat rule on unknown fields).
 
 | Field | Type | Meaning |
 |---|---|---|
-| `task_size_estimate` | int | Pre-dispatch estimate of the task's size (the orchestrator's sizing heuristic). Counts only, no body. |
-| `spawn_count` | int | Number of subagents dispatched for this task. `0` → handled in-session. |
-| `tiers` | string[] | Model tiers dispatched to, one entry per spawn class (e.g. `["sonnet","opus"]`). Tier names only, no prompts. |
-| `token_delta` | int | Net token cost of the dispatch versus the in-session baseline. Counts only. |
-| `wall_clock_ms` | int | Wall-clock duration of the dispatch, milliseconds. |
+| `task_size_estimate` | int | Pre-dispatch estimate of the task's size (orchestrator's sizing heuristic). Counts only, no body. |
+| `spawn_count` | int | Subagents dispatched for this task. `0` → handled in-session. |
+| `tiers` | string[] | Model tiers dispatched to, one per spawn class (e.g. `["sonnet","opus"]`). Tier names only, no prompts. |
+| `token_delta` | int | Net token cost vs the in-session baseline. Positive = cost more; negative = saved. Counts only. |
+| `token_delta_provenance` | enum | `"measured"` from host-reported `usage` metadata (preferred); `"estimated"` when self-estimated from response length (mark always when host usage unavailable). |
+| `wall_clock_ms` | int | Dispatch wall-clock duration, milliseconds. |
 | `outcome` | enum | One of `DONE` · `DONE_WITH_CONCERNS` · `NEEDS_CONTEXT` · `BLOCKED` · `killed`. |
-| `verify_mode` | enum | How the dispatch's output was verified: `deterministic` · `judge` · `none`. |
+| `verify_mode` | enum | How output was verified: `deterministic` · `judge` · `none`. |
+| `verdict_changed_outcome` | bool \| null | **A3 extension (ADR-109 Track A).** For a review/verdict subagent (e.g. `production-validator`): did the verdict change the outcome vs the in-session baseline? `true` = caught a real issue the baseline missed / flipped a false `READY`→`NOT READY`; `false` = no lift; `null` = not a verdict dispatch / not measured. **Negative-control (clean single-file) tasks MUST record `false`** — a `true` on a control = spurious findings, fails Gate A. Additive field on THIS object, not a second schema. Boolean/counts only, no bodies. |
 
 ## Privacy floor
 
@@ -48,6 +52,27 @@ object is an additive extension on an otherwise standard audit-log-v1 line:
 {"schema_version":1,"id":"01HXY...","ts":"2026-06-23T12:34:56Z","work_id":"PROJ-7-2026-06-23T12-30-00Z","phase":"implement","outcome":"success","confidence_band":"high","risk_class":"low","memory":{"asks":2,"hits":1},"verify":{"claims":1,"first_try_passes":1},"rules_applied":["verify-before-complete"],"persona":"backend","input_kind":"orchestration","type":"phase","orchestration":{"task_size_estimate":3,"spawn_count":2,"tiers":["sonnet","opus"],"token_delta":4200,"wall_clock_ms":18500,"outcome":"DONE","verify_mode":"deterministic"}}
 ```
 
+## Emit procedure (how the orchestrating agent writes telemetry)
+
+After every auto-dispatched orchestration run, the orchestrating agent writes one
+telemetry line to `agents/runtime/state/audit/YYYY-MM.jsonl` (the existing
+audit-log-v1 path; `YYYY-MM` = current UTC month). The line is a standard
+audit-log-v1 object with `input_kind: "orchestration"` and an `orchestration`
+sub-object carrying this shape.
+
+**No hook or daemon required.** The agent writes directly via its file-write
+tool — same mechanism as any other agent-written artifact. No-runtime-compatible
+capture path (decided 2026-06-30, maintainer decision; see
+`road-to-subagent-value-realization.md § Council notes`).
+
+**`token_delta` sourcing priority:**
+1. Host-reported: read `usage.output_tokens` (and `usage.input_tokens` if
+   available) from each subagent call's response metadata. Use the sum minus the
+   estimated single-agent baseline. Set `token_delta_provenance: "measured"`.
+2. Self-estimate fallback: host usage metadata unavailable → estimate from
+   response length (chars / 4 ≈ tokens). Set `token_delta_provenance:
+   "estimated"`. Lossy; measured always preferred.
+
 ## Related
 
 - [`audit-log-v1`](../../../../docs/contracts/audit-log-v1.md) — the frozen
@@ -56,4 +81,3 @@ object is an additive extension on an otherwise standard audit-log-v1 line:
 - [`host-capability-manifest`](host-capability-manifest.md) — the manifest that
   decides whether a dispatch is even attempted; `spawn_count` and `tiers`
   reflect what it enabled.
-  Phase-0 instrumentation belongs to.

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

@@ -0,0 +1,107 @@
+# Roadmap Execution Contract
+
+Loaded by [`roadmap-process-loop § 3`](roadmap-process-loop.md) when
+resolved roadmap declares `execution.mode` in frontmatter
+(`autonomous` | `phase-checkpoints`; absent / `interactive` = legacy
+behavior, this context stays unloaded). Defines the run-start
+pre-scan, the contract summary user confirms ONCE, the grants that
+confirmation activates, and the per-mode gate table.
+
+## Principle — declaration vs. authorization
+
+`execution.mode` in frontmatter is a **declaration of intent** written
+at authoring time. Grants nothing. Authorization happens exactly once
+per run: user invokes `/roadmap:process-*` (a this-turn action), loop
+derives the contract below from roadmap's CURRENT content, and user's
+single confirmation converts declared mode into this-turn grants
+**cached for this run only** (same mechanism as commit pre-scan it
+extends). Stale frontmatter is harmless: no confirmation, no grants.
+
+## 1. Pre-scan — four detection classes
+
+Scan every open step (text + inline notes) for:
+
+1. **Commit-shaped steps** — `commit:` / `git commit` / `Commit phase`
+   (existing § 3 scan).
+2. **Git-shape needs** — steps requiring a branch / push / PR
+   (`branch`, `push`, `open a PR`, `create PR`, "in a worktree"), plus
+   run's own delivery needs when roadmap's definition of done includes
+   shipping (autonomous mode default, § 4).
+3. **Artifact-authoring steps** — steps that create or materially
+   rewrite a skill / rule / command / guideline (verbs `add`/`create`/
+   `write`/`rewrite` + artifact nouns, or paths under
+   `src/{skills,rules}/`, command/guideline trees). Feed the batched
+   [`artifact-drafting-protocol`](../../rules/artifact-drafting-protocol.md)
+   research pass (§ 3 below).
+4. **Open questions / ambiguity** — explicit `?` markers, "decide
+   whether", options left unresolved, or steps matching
+   [`ask-when-uncertain`](../../rules/ask-when-uncertain.md)
+   vague-trigger patterns.
+
+## 2. Contract summary — shown once, confirmed once
+
+```
+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)
+Artifacts: <N> planned (skills/rules/commands/guidelines) —
+     batched overlap check: <result — run NOW, against current state>
+Open questions: <N> → resolved via AI council (<members | "none
+     configured — will halt on ambiguity">)
+Quality: <cadence> · Dashboard: <cadence>
+
+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
+  • security-sensitive-stop on auth/billing/tenant/secret paths
+  • N=3 validation budget · context-hygiene read-loop abort
+  • Deferred-[~] archival gate
+
+1. Accept — run under this contract
+2. Adjust (name the change) · 3. Run interactive instead · 4. Abort
+```
+
+Accept = ONE authorization of the run. Cache all grants; never re-ask
+inside the run. Adjust → apply, re-show once. Contract re-derived on
+every invocation — always reflects roadmap's and repo's current state.
+
+## 3. Grants activated by acceptance
+
+| Grant | Boundary |
+|---|---|
+| 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 |
+| 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) |
+
+Grants satisfy [`scope-control`](../../rules/scope-control.md)'s
+"standing instruction" clause for the run — see
+[`scope-mechanics § Roadmap execution contract`](../authority/scope-mechanics.md).
+
+## 4. Definition of done, per mode
+
+| 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) |
+| `phase-checkpoints` | Same end state | Safety floors + a compact status + "continue?" prompt at each phase boundary |
+| `interactive` (absent field) | Legacy: work lands, no git delivery without per-op permission | All gates as authored by their owning rules |
+
+If roadmap contains **no** delivery need and no commit steps, git
+grants are omitted from the contract (nothing to authorize —
+[`commit-policy`](../../rules/commit-policy.md) default: never commit).
+
+## 5. What acceptance can NEVER cover
+
+- 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.
+- 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).
+- Kernel-rule edits' own-PR + 24h-soak guarantee
+  ([`kernel-rule-edits`](../authority/kernel-rule-edits.md)).