@event4u/agent-config 16.0.0 → 16.1.0

package/CONTRIBUTING.md

@@ -101,6 +101,15 @@ task lint-skills      # ./scripts-run src/scripts/skill_linter --all
 - Keep commits focused. Split mechanical renames from logic changes.
 - Open the PR against `main` with a short description of the change,
   motivation, and any notes for reviewers.
+- **Fixed a diagnosed, non-deterministic CI flake with a reusable root cause?**
+  Add a `Flake-diagnosis:` trailer to the fixing commit's body naming the
+  class in a few words, e.g. `Flake-diagnosis: gitignored-dir-watch-scope |
+  parallel writes to an unrelated ignored dir trip a whole-worktree witness`.
+  Scope it narrowly — a diagnosed, non-deterministic failure whose root cause
+  could plausibly recur, never a deterministic bug or an unexplained one — so
+  the convention stays a one-line note, not a registry. Search prior
+  diagnoses with `git log --all --grep="Flake-diagnosis:"` before
+  re-investigating a failure shape from scratch.
 
 ### Branch names, PR text and commit messages are a gated surface
 

package/README.md

@@ -4,9 +4,9 @@
 
 [![Smoke](https://github.com/event4u-app/agent-config/actions/workflows/smoke.yml/badge.svg)](https://github.com/event4u-app/agent-config/actions/workflows/smoke.yml) [![Public install smoke (3 OS × 2 Node)](https://github.com/event4u-app/agent-config/actions/workflows/smoke-public-install.yml/badge.svg)](https://github.com/event4u-app/agent-config/actions/workflows/smoke-public-install.yml) [![npm](https://img.shields.io/npm/v/@event4u/agent-config?style=flat-square&label=npm&color=orange)](https://www.npmjs.com/package/@event4u/agent-config) [![agent-config MCP server](https://glama.ai/mcp/servers/event4u-app/agent-config/badges/score.svg)](https://glama.ai/mcp/servers/event4u-app/agent-config) [![MCP Toplist](https://mcptoplist.com/badge/glama%2Fevent4u-app%2Fagent-config.svg)](https://mcptoplist.com/server/glama%2Fevent4u-app%2Fagent-config)
 
-[![Skills](https://img.shields.io/badge/Skills-299-orange?style=flat-square)](dist/agent-src/skills/) [![Rules](https://img.shields.io/badge/Rules-120-orange?style=flat-square)](dist/agent-src/rules/) [![Commands](https://img.shields.io/badge/Commands-202-orange?style=flat-square)](dist/agent-src/commands/) [![Guidelines](https://img.shields.io/badge/Guidelines-121-orange?style=flat-square)](docs/guidelines/) [![Personas](https://img.shields.io/badge/Personas-29-orange?style=flat-square)](dist/agent-src/personas/) [![Advisors](https://img.shields.io/badge/Advisors-5-orange?style=flat-square)](dist/agent-src/personas/advisors/) <!-- claim:published-artifact-counts -->
+[![Skills](https://img.shields.io/badge/Skills-299-orange?style=flat-square)](dist/agent-src/skills/) [![Rules](https://img.shields.io/badge/Rules-121-orange?style=flat-square)](dist/agent-src/rules/) [![Commands](https://img.shields.io/badge/Commands-203-orange?style=flat-square)](dist/agent-src/commands/) [![Guidelines](https://img.shields.io/badge/Guidelines-121-orange?style=flat-square)](docs/guidelines/) [![Personas](https://img.shields.io/badge/Personas-29-orange?style=flat-square)](dist/agent-src/personas/) [![Advisors](https://img.shields.io/badge/Advisors-5-orange?style=flat-square)](dist/agent-src/personas/advisors/) <!-- claim:published-artifact-counts -->
 
-<sub>**How these are counted** — one canonical counter, `agent-config` → `update_counts --check`, re-derives all six from the tree and fails CI on a drift of one. Two bases are not what the linked directory shows, so they are stated here rather than left to be inferred: **Commands 202** counts every command file **recursively** (the linked directory holds 61 at its top level), and **Rules 120** counts the **source** rules while the linked projection holds 119 — one rule is dormant and is not projected. **Personas 29** excludes the directory README. Counts are of files and directories: none of them measures quality, activation, or adoption. <!-- claim:published-artifact-counts --></sub>
+<sub>**How these are counted** — one canonical counter, `agent-config` → `update_counts --check`, re-derives all six from the tree and fails CI on a drift of one. Two bases are not what the linked directory shows, so they are stated here rather than left to be inferred: **Commands 202** counts every command file **recursively** (the linked directory holds 61 at its top level), and **Rules 121** counts the **source** rules while the linked projection holds 120 — one rule is dormant and is not projected. **Personas 29** excludes the directory README. Counts are of files and directories: none of them measures quality, activation, or adoption. <!-- claim:published-artifact-counts --></sub>
 
 **Try it in 30 seconds** — drop one read-only subagent into any repo and watch it gate "done": `@production-validator check this branch is actually done`. No wizard, no lock-in, nothing else installed — the [30-second wedge ↓](#quickstart) is the whole first step. Start at the proof, not the catalog: **[event4u-app.github.io/agent-config/proof/](https://event4u-app.github.io/agent-config/proof/)**.
 

package/dist/agent-src/commands/analyze/inbox.md

@@ -1,6 +1,7 @@
 ---
 model_tier: high
 name: analyze-inbox
+produces_roadmap: true
 pack: analysis-workbench
 visibility: internal
 sub: inbox
@@ -1177,3 +1178,28 @@ prompted this section could not be given.
   orchestrator.
 - Collapse a multi-topic round into fewer artifacts than it had topics without
   saying, per topic, where its content went.
+## Closure — the last step, always
+
+```
+THIS COMMAND PRODUCES A ROADMAP, SO IT ENDS IN CLOSURE.
+NEVER HAND BACK A PLAN CARRYING A DECISION PLANNING COULD HAVE CLOSED.
+```
+
+Declared by `produces_roadmap: true` in the frontmatter and enforced by
+`lint_roadmap_producers`: a producer that does not end here reds CI.
+
+Read `planning.closure_pass` (missing = `true`). When active, run
+[`/challenge-me closure`](../../../meta/challenge-me/closure/command.md) on the
+roadmap this command just produced, before handing back:
+
+```bash
+./scripts-run src/scripts/closure_scan <roadmap-path>
+```
+
+Every detected decision is resolved at the lowest rung that owns it and written
+into the roadmap's `## Decisions` table. Owner-owned residue is asked **now**,
+one question per turn, and its answer recorded — never handed back as *"the
+open questions are in the file"*.
+
+An explicit *just write it* drops the pass and is recorded as a **bypass** on
+its own axis, never as an absent closure. A mission grant is not a bypass.

package/dist/agent-src/commands/analyze/roadmap-repos.md

@@ -1,6 +1,7 @@
 ---
 model_tier: medium
 name: analyze-roadmap-repos
+produces_roadmap: true
 pack: analysis-workbench
 visibility: internal
 sub: roadmap-repos
@@ -127,3 +128,29 @@ any other.
 - Script: `src/scripts/harvest_reference_tokens.ts` — discovery, the only one.
 - Rule: [`source-confidentiality`](../../../../rules/source-confidentiality.md)
   — why the identities stay in the gitignored area.
+
+## Closure — the last step, always
+
+```
+THIS COMMAND PRODUCES A ROADMAP, SO IT ENDS IN CLOSURE.
+NEVER HAND BACK A PLAN CARRYING A DECISION PLANNING COULD HAVE CLOSED.
+```
+
+Declared by `produces_roadmap: true` in the frontmatter and enforced by
+`lint_roadmap_producers`: a producer that does not end here reds CI.
+
+Read `planning.closure_pass` (missing = `true`). When active, run
+[`/challenge-me closure`](../../../meta/challenge-me/closure/command.md) on the
+roadmap this command just produced, before handing back:
+
+```bash
+./scripts-run src/scripts/closure_scan <roadmap-path>
+```
+
+Every detected decision is resolved at the lowest rung that owns it and written
+into the roadmap's `## Decisions` table. Owner-owned residue is asked **now**,
+one question per turn, and its answer recorded — never handed back as *"the
+open questions are in the file"*.
+
+An explicit *just write it* drops the pass and is recorded as a **bypass** on
+its own axis, never as an absent closure. A mission grant is not a bypass.

package/dist/agent-src/commands/challenge-me/closure.md

@@ -0,0 +1,178 @@
+---
+model_tier: medium
+name: challenge-me-closure
+pack: product-reasoning
+visibility: internal
+cluster: challenge-me
+sub: closure
+description: "Close every foreseeable decision in a roadmap before execution — detect the open ones, resolve each at the lowest rung that owns it, and write the answers into a `## Decisions` table."
+argument-hint: "<roadmap-path>"
+suggestion:
+  eligible: false
+  rationale: "Cluster sub-command — reached via its cluster head's routing or its explicit /cluster:sub name; not independently suggested (surface-consolidation)."
+workspaces:
+  - agent-config-maintainer
+packs:
+  - product-reasoning
+---
+
+# /challenge-me closure
+
+> Take a roadmap that is about to enter execution and make it an **execution
+> contract**: every foreseeable decision closed, the closing done council-first,
+> the owner reached only for product, business, taste or destructive residue.
+
+```
+A QUESTION PLANNING COULD HAVE CLOSED AND EXECUTION MEETS INSTEAD IS A DEFECT.
+RESOLVE AT THE LOWEST RUNG THAT OWNS THE DECISION. THE OWNER IS THE LAST RUNG,
+NEVER THE FIRST, AND NEVER REACHED FOR A TECHNICAL DECISION AT ALL.
+NEVER ASK ABOUT PR TOPOLOGY. NEVER RAISE MERGE UNLESS THE OWNER RAISED IT.
+EVERY ANSWER IS WRITTEN INTO `## Decisions` BEFORE THE RUN STARTS.
+```
+
+Input is a roadmap path. Output is the same file with a `## Decisions` table
+and, where residue was genuinely owner-owned, at most one host-native ask per
+turn whose answer is recorded immediately.
+
+## Step 1 — Detect
+
+Run the deterministic detector. It finds and classifies; it resolves nothing.
+
+```bash
+./scripts-run src/scripts/closure_scan <roadmap-path>
+```
+
+It reports one row per open decision: an id, a line, a detector kind, and the
+**ownership class** that kind maps to. The families are `tbd`,
+`unpicked-alternative`, `unchecked-assumption`, `missing-verify`,
+`ambiguous-acceptance`, `contradictory`, `product-semantics`, `typed-op` and
+`spend`.
+
+Then add what a scanner cannot see, reading the file yourself:
+
+- the prose checks `lint_roadmap_complexity` already runs — vague steps, human
+  gates in steps, headings or exit criteria, external-population gates;
+- an **unresolved typed-op need**: work that cannot finish without an operation
+  from the typed vocabulary for which no grant exists;
+- a **product semantics** fork the scanner's phrasing missed — two valid
+  user-visible outcomes with no source of truth to pick between them.
+
+`--rows` prints the `## Decisions` skeleton; `--json` is the machine form.
+
+## Step 2 — Resolve, in this order, stopping at the first rung that can
+
+For each detected decision, in order, and never skipping a rung upward:
+
+1. **Evidence** — the tree answers it. Read the file, run the probe, check the
+   schema. A decision the code already made is not a decision.
+2. **Convention, ADR or contract** — a recorded rule answers it. Cite the ADR
+   number or the contract path.
+3. **The agent** — reversible and inside the stated convention
+   (`deterministic`, `reversible-technical`). Pick, and say why.
+4. **An independent session** — a second instance with no stake in the first
+   answer. This is the first rung for `contested-technical`.
+5. **The council** — `agent-config council:status` decides availability, never
+   the project tree. `critical-technical` targets a **provider-diverse**
+   council; with one provider configured the class degrades to owner-confirm of
+   the agent's proposal rather than one model reviewing itself.
+6. **The team** — where a council is unavailable and `ai_team` is configured.
+7. **The owner** — **only** for `product-owned`, `business-owned` and
+   `destructive-owned`. A technical decision never reaches here, however hard
+   it is.
+
+`spend-exhaustion` leaves the ladder entirely: it **pauses and reports** — what
+needed the council, why the CLI rung was unavailable, the estimated spend, the
+mission state, and what can still proceed.
+
+## Step 3 — What is never asked
+
+- **PR topology.** Stacked, split, one branch or five is the agent's call.
+- **Merge intent**, unless the owner already discussed merge for this work. A
+  merge grant is a typed op the owner grants; it is not a question closure
+  invents.
+- **A count.** "Three attempts failed, continue?" is a strategy change, never a
+  question.
+- **A continuation.** "Shall I go on?" after a clean batch is not a decision.
+
+## Step 4 — Write the answers down
+
+Append or update a `## Decisions` section with one row per decision:
+
+```
+| ID | ownership | resolved by | decision | evidence | revisit if |
+```
+
+`ownership` is one of the eight ownership classes. `resolved by` is one of
+`evidence`, `agent`, `independent:<session or model>`, `council:<record>`,
+`team:<record>`, `owner`. `revisit if` names the condition that reopens it — a
+closed decision is re-asked only when that condition became true.
+
+`lint_decision_classes` enforces both vocabularies. Run it before handing back:
+
+```bash
+./scripts-run src/scripts/lint_decision_classes
+```
+
+## Step 5 — Residue is asked now, never filed
+
+```
+OWNER-OWNED RESIDUE IS ASKED THIS TURN. ONE QUESTION PER TURN.
+THE ANSWER IS WRITTEN INTO `## Decisions` BEFORE THE NEXT QUESTION IS PUT.
+NEVER HAND BACK "THE FOUR OPEN QUESTIONS ARE IN FILE X" — A FILED QUESTION IS
+AN UNCLOSED ONE WEARING A RECORD'S CLOTHES, AND THE FILE IS WHERE IT DIES.
+NEVER HAND BACK A COUNT — "3 QUESTIONS OUTSTANDING" IS A NUMBER RENDERED WHERE
+A DECISION BELONGS.
+```
+
+Ask using the host's own primitive where one exists — `agent-config
+hooks:status` prints the shape, and the numbered text block is the named
+fallback (see `user-interaction`). Each option carries what changes by
+answering it, and the recommendation has exactly one source.
+
+Two mechanical consequences, both already enforced:
+
+- `ask_block_census` classifies a question written into a section instead of
+  asked as `file-parked`, and a count rendered where a question belongs as
+  `count-only`. Both are their own axes; neither is an ask.
+- `lint_decision_classes` reds a `ready` roadmap carrying an unresolved marker
+  outside `## Decisions`. A question that exists only as prose in the plan is
+  exactly that marker, so the prose form cannot survive to `ready`.
+
+**Where the residue genuinely cannot be asked** — the run is non-interactive,
+or the answer needs something the owner has not got yet — the step is parked
+and independent phases continue (§ 4 of the process loop), and the plan records
+a structured `## Blockers` entry naming one of the three owner-owned classes.
+That is the one legal file-shaped home, and it is legal because a five-field
+blocker is decidable: recommendation, cost of the non-decision, what to do, and
+what resolves it. A bare sentence in `## Notes` is none of those.
+
+## Bypass
+
+An explicit *just write it* / *skip closure* / *einfach machen* drops this pass
+entirely. The bypass is **recorded** as a bypass — it is its own axis in the ask
+census, not an absent closure — and it is never inferred from a mission grant,
+an autonomy setting or momentum. Only the owner's words this turn are a bypass.
+
+## Fixtures
+
+Under `tests/fixtures/decision-closure/`:
+
+| Fixture | What it must produce |
+|---|---|
+| `F1-technical-ambiguities.md` | twelve findings, **zero** owner questions |
+| `F2-product-semantics.md` | **exactly one** owner question, `product-owned` |
+| `F0-closed-plan.md` | nothing — a plan already closed |
+| `R1-ready-unresolved.md` / `R2-ready-resolved.md` | red, then green on the same plan once the marker is recorded |
+| `F3a-conclusive-technical.md` / `F3b-non-convergent-product.md` | no options block, then a proposal |
+
+Each pair is required and neither half alone is evidence: a detector weakened
+until it finds nothing passes F0 and fails F1, and one that fires on ordinary
+prose does the reverse. F1 against F2 is the ownership discrimination — twelve
+technical ambiguities cost the owner nothing, one product fork costs exactly
+one question.
+
+## See also
+
+- [`/challenge-me`](../command.md) — the cluster head.
+- [`/challenge-me vision`](../vision/command.md) — the interview loop this reuses.
+- `docs/contracts/ai-council-config.md` § Decision resolution by ownership — the eight classes and their Iron Laws.

package/dist/agent-src/commands/challenge-me.md

@@ -3,8 +3,8 @@ model_tier: medium
 name: challenge-me
 pack: product-reasoning
 visibility: internal
-description: Challenge-me orchestrator — routes to vision, with-docs
-argument-hint: "[vision|with-docs] [flags] [seed]"
+description: Challenge-me orchestrator — routes to vision, with-docs, closure
+argument-hint: "[vision|with-docs|closure] [flags] [seed]"
 cluster: challenge-me
 type: orchestrator
 suggestion:
@@ -32,12 +32,17 @@ enough to emit a copyable Markdown pitch.
 |---|---|---|
 | `/challenge-me vision` | `commands/challenge-me/vision.md` | Standard variant — interrogate a fuzzy plan / idea / ticket draft to 95% confidence, emit a vision pitch |
 | `/challenge-me with-docs` | `commands/challenge-me/with-docs.md` | Doc-aware variant — same flow plus session glossary against `CONTEXT.md`, load-bearing claim-vs-code verification, optional `CONTEXT.md` patch + ADR candidates in the pitch |
+| `/challenge-me closure` | `commands/challenge-me/closure.md` | Plan-closure variant — take a roadmap about to enter execution, detect every open decision, resolve each at the lowest rung that owns it, and write the answers into a `## Decisions` table |
 
 ## When to pick which
 
 - **`vision`** — greenfield idea, fresh ticket draft, or a plan with no
   existing project glossary / domain docs. Default for "challenge me on
   this plan".
+- **`closure`** — the input is a **roadmap path**, not a fuzzy idea, and the
+  goal is an execution contract rather than a pitch. Pick it when a plan is
+  about to be executed: it closes the decisions a twelve-hour run would
+  otherwise meet mid-flight.
 - **`with-docs`** — the project has `CONTEXT.md`, an ADR directory
   (`docs/adr/`, `docs/decisions/`, `agents/decisions/`), or the user
   uses domain terms that may already be defined. The variant catches
@@ -54,6 +59,8 @@ enough to emit a copyable Markdown pitch.
    > 1. vision — standard 95%-confidence interview, emits a copyable pitch
    > 2. with-docs — same flow, but checks the seed against `CONTEXT.md` /
    >    ADRs and emits an optional doc patch in the pitch
+   > 3. closure — take a roadmap path and close every open decision in it
+   >    before execution, recording the answers in `## Decisions`
 
 ## In-interview triggers (both sub-commands)
 

package/dist/agent-src/commands/council/default.md

@@ -279,12 +279,32 @@ The host is the convener **and** the skeptic — never paraphrase
 council output as host reasoning, and never auto-promote convergence
 to correctness.
 
-### 5b. Translate verdicts into user options
+### 5b. Translate verdicts into user options — when the verdict is owed to the owner
 
-End with a numbered-options block carrying the host verdict per
-finding (e.g. `1. [accept] Apply finding 1 — <patch summary>`,
-`2. [reject] Skip finding 2 — <reason>` — user can override). Always
-include "discard council input" as an option.
+```
+THE OPTIONS BLOCK IS CONDITIONAL, AND THE CONDITION IS OWNERSHIP.
+A CONCLUSIVE **TECHNICAL** VERDICT EMITS NO OWNER-FACING OPTIONS BLOCK —
+IT IS A RESOLUTION, AND HANDING IT OVER AS OPTIONS ROUTES A TECHNICAL
+DECISION TO A PERSON BECAUSE IT WAS HARD (ADR-268 § 10).
+THE BLOCK IS OWED WHEN THE VERDICT IS OWNER-OWNED — `product-owned`,
+`business-owned`, `destructive-owned` — OR WHEN THE COUNCIL DID NOT
+CONVERGE. THEN IT CARRIES THE COUNCIL'S PROPOSAL FOR THE OWNER TO CONFIRM.
+CONVERGENCE IS READ FROM THE RECORD, NEVER INFERRED: A RECORD THAT DOES
+NOT SAY WHETHER ITS MEMBERS CONVERGED IS ITSELF THE FINDING.
+```
+
+A conclusive technical verdict still produces the full record — question,
+evidence, member positions, convergence, verdict, confidence, revisit
+condition — and the run continues on it. The resolution is written into the
+consuming artifact's `## Decisions` table with `resolved by: council:<record>`.
+
+`./scripts-run src/scripts/council_record_shape <record.md>` checks a record
+against this contract in both directions.
+
+When the block IS owed, it is a numbered-options block carrying the host
+verdict per finding (e.g. `1. [accept] Apply finding 1 — <patch summary>`,
+`2. [reject] Skip finding 2 — <reason>` — user can override), with "discard
+council input" always present as an option.
 
 ### 6. Hard floor — text only
 

package/dist/agent-src/commands/feature/plan.md

@@ -1,6 +1,7 @@
 ---
 model_tier: inherit
 name: feature-plan
+produces_roadmap: true
 pack: engineering-base
 visibility: internal
 cluster: feature
@@ -24,7 +25,7 @@ packs:
 
 Before gathering, run the plan-confidence gate per
 [`plan-confidence-gate`](../../contexts/execution/plan-confidence-gate.md):
-read `planning.challenge_on_create` (missing = `true`), do the codebase
+read `planning.closure_pass` (missing = `true`), do the codebase
 lookup, and assess the four 95%-conditions — **seed = the provided
 description** (when none was provided, step 1's ask supplies it first).
 Confident → single marker line, continue with step 1. Uncertain → route
@@ -389,3 +390,29 @@ What's next?
 - [`role-contracts`](../../guidelines/agent-infra/role-contracts.md#po) — PO mode output contract (Goal / Assumptions / Acceptance criteria / Impacted modules / Risks / Open questions for stakeholder)
 - [`refine-ticket`](refine-ticket.md) — optional upstream step: run first when the input is a Jira/Linear ticket rather than a fresh idea
 - [`estimate-ticket`](estimate-ticket.md) — sibling of `refine-ticket`; size + risk + split recommendation for an already-refined ticket
+
+## Closure — the last step, always
+
+```
+THIS COMMAND PRODUCES A ROADMAP, SO IT ENDS IN CLOSURE.
+NEVER HAND BACK A PLAN CARRYING A DECISION PLANNING COULD HAVE CLOSED.
+```
+
+Declared by `produces_roadmap: true` in the frontmatter and enforced by
+`lint_roadmap_producers`: a producer that does not end here reds CI.
+
+Read `planning.closure_pass` (missing = `true`). When active, run
+[`/challenge-me closure`](../../../meta/challenge-me/closure/command.md) on the
+roadmap this command just produced, before handing back:
+
+```bash
+./scripts-run src/scripts/closure_scan <roadmap-path>
+```
+
+Every detected decision is resolved at the lowest rung that owns it and written
+into the roadmap's `## Decisions` table. Owner-owned residue is asked **now**,
+one question per turn, and its answer recorded — never handed back as *"the
+open questions are in the file"*.
+
+An explicit *just write it* drops the pass and is recorded as a **bypass** on
+its own axis, never as an absent closure. A mission grant is not a bypass.

package/dist/agent-src/commands/feature/roadmap.md

@@ -1,6 +1,7 @@
 ---
 model_tier: inherit
 name: feature-roadmap
+produces_roadmap: true
 pack: engineering-base
 visibility: internal
 cluster: feature
@@ -56,7 +57,7 @@ Stop.
 
 **Confidence gate (Gate C)** — after reading the feature plan, run
 [`plan-confidence-gate`](../../contexts/execution/plan-confidence-gate.md)
-with the **feature document as seed** (`planning.challenge_on_create`,
+with the **feature document as seed** (`planning.closure_pass`,
 missing = `true`). All four 95%-conditions hold → single marker line,
 continue. A gap that would change the phases or acceptance criteria →
 `/challenge-me vision` interview (or inline degrade protocol) **before**
@@ -239,3 +240,29 @@ What's next?
 ## See also
 
 - [`role-contracts`](../../guidelines/agent-infra/role-contracts.md#planner) — Planner mode output contract (Goal / Constraints / Option set / Recommendation / Dependencies / Rollback)
+
+## Closure — the last step, always
+
+```
+THIS COMMAND PRODUCES A ROADMAP, SO IT ENDS IN CLOSURE.
+NEVER HAND BACK A PLAN CARRYING A DECISION PLANNING COULD HAVE CLOSED.
+```
+
+Declared by `produces_roadmap: true` in the frontmatter and enforced by
+`lint_roadmap_producers`: a producer that does not end here reds CI.
+
+Read `planning.closure_pass` (missing = `true`). When active, run
+[`/challenge-me closure`](../../../meta/challenge-me/closure/command.md) on the
+roadmap this command just produced, before handing back:
+
+```bash
+./scripts-run src/scripts/closure_scan <roadmap-path>
+```
+
+Every detected decision is resolved at the lowest rung that owns it and written
+into the roadmap's `## Decisions` table. Owner-owned residue is asked **now**,
+one question per turn, and its answer recorded — never handed back as *"the
+open questions are in the file"*.
+
+An explicit *just write it* drops the pass and is recorded as a **bypass** on
+its own axis, never as an absent closure. A mission grant is not a bypass.

package/dist/agent-src/commands/implement-ticket.md

@@ -1,6 +1,7 @@
 ---
 model_tier: inherit
 name: implement-ticket
+produces_roadmap: true
 pack: engineering-base
 intent: "Implement a tracker ticket end-to-end from its id"
 routes_to: [refine-ticket, feature-planning]
@@ -200,3 +201,29 @@ permission-gated.
 
 - [`refine-ticket`](refine-ticket.md), [`feature-plan`](feature-plan.md), [`tests-execute`](tests-execute.md), [`review-changes`](review-changes.md) — skills the directives delegate to
 - [`commit`](commit.md), [`create-pr`](create-pr.md) — post-delivery commands the user runs explicitly
+
+## Closure — the last step, always
+
+```
+THIS COMMAND PRODUCES A ROADMAP, SO IT ENDS IN CLOSURE.
+NEVER HAND BACK A PLAN CARRYING A DECISION PLANNING COULD HAVE CLOSED.
+```
+
+Declared by `produces_roadmap: true` in the frontmatter and enforced by
+`lint_roadmap_producers`: a producer that does not end here reds CI.
+
+Read `planning.closure_pass` (missing = `true`). When active, run
+[`/challenge-me closure`](../../meta/challenge-me/closure/command.md) on the
+roadmap this command just produced, before handing back:
+
+```bash
+./scripts-run src/scripts/closure_scan <roadmap-path>
+```
+
+Every detected decision is resolved at the lowest rung that owns it and written
+into the roadmap's `## Decisions` table. Owner-owned residue is asked **now**,
+one question per turn, and its answer recorded — never handed back as *"the
+open questions are in the file"*.
+
+An explicit *just write it* drops the pass and is recorded as a **bypass** on
+its own axis, never as an absent closure. A mission grant is not a bypass.

package/dist/agent-src/commands/jira-ticket.md

@@ -1,6 +1,7 @@
 ---
 model_tier: inherit
 name: jira-ticket
+produces_roadmap: true
 pack: product-basic
 intent: "Read a Jira ticket from the branch and implement the feature or fix the bug"
 routes_to: [jira-integration, feature-planning]
@@ -82,3 +83,29 @@ packs:
 ## See also
 
 - [`role-contracts`](../guidelines/agent-infra/role-contracts.md#developer) — Developer mode output contract (Goal / Plan / Changes / Tests / Open questions)
+
+## Closure — the last step, always
+
+```
+THIS COMMAND PRODUCES A ROADMAP, SO IT ENDS IN CLOSURE.
+NEVER HAND BACK A PLAN CARRYING A DECISION PLANNING COULD HAVE CLOSED.
+```
+
+Declared by `produces_roadmap: true` in the frontmatter and enforced by
+`lint_roadmap_producers`: a producer that does not end here reds CI.
+
+Read `planning.closure_pass` (missing = `true`). When active, run
+[`/challenge-me closure`](../../meta/challenge-me/closure/command.md) on the
+roadmap this command just produced, before handing back:
+
+```bash
+./scripts-run src/scripts/closure_scan <roadmap-path>
+```
+
+Every detected decision is resolved at the lowest rung that owns it and written
+into the roadmap's `## Decisions` table. Owner-owned residue is asked **now**,
+one question per turn, and its answer recorded — never handed back as *"the
+open questions are in the file"*.
+
+An explicit *just write it* drops the pass and is recorded as a **bypass** on
+its own axis, never as an absent closure. A mission grant is not a bypass.

package/dist/agent-src/commands/pr/create.md

@@ -276,6 +276,35 @@ fallback structure defined in `/create-pr:description-only`. NEVER invent a cust
   title and body as copyable blocks and ask for adjustments before
   proceeding. The user reviews and adjusts the content in that step.
 
+### 2a. Scope delta — what grew, and why it was the agent's
+
+```
+AGENT-OWNED SCOPE GROWTH IS RECORDED IN THE PR BODY. ONE LINE PER ITEM.
+GROWTH DONE AND NOT RECORDED IS INDISTINGUISHABLE FROM SCOPE CREEP.
+A FOLLOW-UP ARTIFACT IS NAMED HERE TOO — IT IS WHAT THE MISSION DID NOT ABSORB.
+```
+
+Where the run did work beyond the literal task, add a `## Scope delta` section
+to the body — one line per item, naming what grew and which row of the
+agent-owned list it matched (a necessary internal refactor · a missing test on
+a touched path · a regression on a touched path · a small dependency
+adjustment · a local API change inside defined semantics · a Boy-Scout cleanup
+that is small, local, low blast radius, testable and carries no new product
+decision). Full enumeration and the council / owner rows:
+[`scope-mechanics`](../../../../agent-src/contexts/authority/scope-mechanics.md)
+section Scope growth.
+
+`./scripts-run src/scripts/scope_growth "<one-line description>"` classifies a
+single item when the row is not obvious. `unknown` is a real verdict: growth
+nothing classifies is growth nobody decided, and it does not silently become
+agent work.
+
+A larger unrelated opportunity is **not** a scope delta. It is a follow-up
+artifact, named in the same section under *Not absorbed* with its roadmap path,
+because a mission delivering everything it met would deliver none of it.
+
+Omit the section entirely when the diff is the task and nothing grew.
+
 ### 2b. Council review — explicitly excluded
 
 `/create-pr` does **not** prompt for council review, even when