okstra 0.56.0 → 0.57.0

package/docs/kr/architecture.md

@@ -343,7 +343,7 @@ okstra phase 는 PRD / issue file 을 직접 쓰지 않습니다. 동등한 결
 |---|---|---|---|---|
 | `requirements-discovery` | 요청을 bugfix/feature/refactor/ops/improvement 중 하나로 분류하고 안전한 다음 phase로 라우팅 | work category, routing decision, missing-input list, clarification requests | `pending-routing-decision` (사용자 답변 후 결정) | 금지 |
 | `error-analysis` | 보고된 에러/사고의 증상·원인·재현 갭을 증거 기반으로 분석 | symptom/trigger 정리, root-cause 가설, reproduction gap, validation 경로 | `implementation-planning` | 금지 |
-| `implementation-planning` | 코딩 시작 전 안전한 구현 방향과 옵션을 평가 | 최소 2개 구현 옵션, 영향 파일 목록, trade-off, 단계별 실행 순서, validation/rollback, **User Approval Request** 블록, **§5.5.9 Plan Body Verification** (Phase 6 워커 사후 검증 라운드 — 합성된 plan 의 내적 일관성을 워커가 `AGREE` / `DISAGREE(a-e)` / `SUPPLEMENT` 로 cross-verify; gate 결과가 `passed` / `passed-with-dissent` 일 때만 Approval 마커 렌더, `blocked-by-disagreement` / `aborted-non-result` 일 때는 majority DISAGREE 항목이 `## 1. Clarification Items` 의 `Blocks=approval` row 로 변환됨). **산출 구조**: 항상 `## 5.5 Stage Map` + N 개의 `## 5.5.<i> Stage <i>` 섹션. 각 stage 의 effective step ≤ 6. `depends-on (none)` 인 stage 들은 별도 `implementation` run 으로 병렬 실행 가능 | `implementation` (사용자 승인 후) | 금지 |
+| `implementation-planning` | 코딩 시작 전 안전한 구현 방향과 옵션을 평가 | 최소 2개 구현 옵션, 영향 파일 목록, trade-off, validation/rollback, YAML frontmatter `approved: false` / `implementation-option:`, **§5.5.9 Plan Body Verification** (Phase 6 워커 사후 검증 라운드 — 합성된 plan 의 내적 일관성을 워커가 `AGREE` / `DISAGREE(a-e)` / `SUPPLEMENT` 로 cross-verify; gate 결과가 `passed` / `passed-with-dissent` 일 때만 사용자가 frontmatter 를 `approved: true` 로 뒤집을 수 있고, `blocked-by-disagreement` / `aborted-non-result` 일 때는 majority DISAGREE 항목이 `## 1. Clarification Items` 의 `Blocks=approval` row 로 변환됨). **산출 구조**: 항상 `## 5.5 Stage Map` + N 개의 `## 5.5.<i> Stage <i>` 섹션. 각 stage 의 effective step ≤ 6. `depends-on (none)` 인 stage 들은 별도 `implementation` run 으로 병렬 실행 가능 | `implementation` (사용자 승인 후) | 금지 |
 | `implementation` | 승인된 `implementation-planning` final report의 단계대로 소스 코드를 수정. **한 run 에 한 stage 만 실행** (`--stage <auto\|N>` 인수로 stage 선택) | commit list, diff summary, out-of-plan edits 블록, validation/TDD evidence, rollback 검증, verifier 결과(Gemini/Codex/Claude), `carry/stage-<N>.json` evidence sidecar | `final-verification` | 허용 (승인된 plan의 파일 목록 한정, `git push`/publish/deploy/실제 migration 금지) |
 | `final-verification` | 완료된 작업의 잔존 결함·회귀 위험을 점검하고 release 판단 | acceptance verdict, residual risk, follow-up 라우팅(`error-analysis`/`implementation-planning`/`release-handoff`) | `pending-release-handoff` (verdict 가 `accepted` 일 때만 `release-handoff` 로 진입; 그 외에는 `error-analysis` 또는 `implementation-planning` 으로 리라우팅) | 금지 (read-only 테스트만 허용) |
 | `release-handoff` | `accepted` 받은 변경을 사용자가 선택한 방식대로 커밋·푸시·PR 로 전달 | 사용자 메뉴 응답(H1 action / H2 PR base / H3 message handling) 기록, 실행한 git/gh 명령 로그, commit SHA 목록, PR URL | `done-or-follow-up` | 허용 — 단 **사용자가 메뉴로 선택한 mutating 명령만** 실행. `git push --force*`, base 브랜치 직접 push, `--no-verify`, `gh release`, publish/deploy 는 금지. source code 자체는 수정 금지(이전 `implementation` 의 diff 를 그대로 패키징). |
@@ -355,7 +355,7 @@ okstra phase 는 PRD / issue file 을 직접 쓰지 않습니다. 동등한 결
 - **implementation stage 격리 worktree (동시 병렬)**: 위 task-key 단위 worktree 는 `requirements-discovery`~`implementation-planning` 의 모델입니다. `implementation` task 는 **stage 격리** 로 동작합니다 (spec `docs/superpowers/specs/2026-06-06-stage-worktree-isolation-design.md`) — **한 run = 한 stage**, 각 run 이 `.../<task-id-segment>/stage-<N>/` (브랜치 `<prefix>-<task-id-segment>-s<N>`) 격리 worktree 를 발급받습니다. registry 가 task-key 와 **stage-key** (`<task-key>#stage-<N>`) 를 함께 flock 예약하고, `_resolve_effective_stages` 가 `consumers.jsonl` 의 `started` + registry 예약 stage 를 ready 집합에서 제외하므로(점유 SSOT = registry), 사용자가 두 `implementation` run 을 동시에 띄우면 서로 다른 독립 stage 를 충돌 없이 진행합니다. base 결정: 독립 = 공통 anchor(첫 stage 진입 HEAD 고정), 단일 의존 = 선행 done commit, 다중 의존 = 선행이 모두 ancestor 인 task worktree HEAD(`git merge-base --is-ancestor`; 미머지 시 `PrepareError`). cost-aware-design 의 ready-set batch 는 stage 마다 격리 branch 가 필요해 의미를 잃으므로(같은 branch 에 두 stage-key reserve 시 branch-uniqueness 충돌) 폐기되었고, 순차 진행은 stage done 후 다음 run, 동시 진행은 별도 run 으로 — cost 등가. `--stage <auto|N>` 또는 wizard `stage_pick` 으로 stage 를 선택합니다.
 - `implementation` 과 `release-handoff` 를 제외한 모든 phase 는 source code edit, build, migration, deployment, 그 밖의 state-mutating 명령을 금지합니다 (`final-verification` 은 read-only 테스트 명령만 허용). `implementation` 은 승인된 plan 의 파일 목록 안에서만 edit/commit 이 허용되며, `git push`·publish·deploy·실제 migration·third-party write API 는 여전히 금지됩니다. `release-handoff` 는 source code 자체는 수정하지 않고, 사용자가 메뉴로 선택한 commit / push / PR 명령만 실행합니다 (force push, base 브랜치 직접 push, hook bypass, release publish 는 여전히 금지).
 - 사용자가 "다음 단계 진행해" 같은 표현을 보내도, 그 발화만으로 다음 phase가 자동 시작되지 않습니다. 다음 phase는 새 `okstra.sh` 실행으로만 시작합니다.
-- **Authority & permissions assumption (모든 task-type 및 `okstra-schedule` 공통)**: 사용자(및 팀)는 예상되는 모든 작업에 대해 완전한 권한·승인 권한을 보유한다고 가정합니다. 외부 승인, 서드파티 액세스, 역할/IAM 권한, 조직적 sign-off, 법무·보안 검토, 벤더 협의, "권한 보유 여부 확인" 같은 항목을 routing 결정·missing inputs·clarification questions·risk·dependency·open questions·effort/day 추정에 포함하지 않습니다. okstra 내부 phase 핸드오프(`User Approval Request` 등)는 사용자 본인이 즉시 승인 가능한 내부 게이트이므로 영향 없으며, `implementation`의 forbidden actions(`git push`, prod deploy, shared-DB migration 등)도 권한 사유가 아닌 **안전 사유**로 계속 적용됩니다.
+- **Authority & permissions assumption (모든 task-type 및 `okstra-schedule` 공통)**: 사용자(및 팀)는 예상되는 모든 작업에 대해 완전한 권한·승인 권한을 보유한다고 가정합니다. 외부 승인, 서드파티 액세스, 역할/IAM 권한, 조직적 sign-off, 법무·보안 검토, 벤더 협의, "권한 보유 여부 확인" 같은 항목을 routing 결정·missing inputs·clarification questions·risk·dependency·open questions·effort/day 추정에 포함하지 않습니다. okstra 내부 phase 핸드오프(`implementation-planning`의 `approved:` frontmatter 등)는 사용자 본인이 즉시 승인 가능한 내부 게이트이므로 영향 없으며, `implementation`의 forbidden actions(`git push`, prod deploy, shared-DB migration 등)도 권한 사유가 아닌 **안전 사유**로 계속 적용됩니다.
 - Phase별 상세 규칙은 `prompts/profiles/<task-type>.md`에 정의되어 있고, 그 본문이 그대로 `instruction-set/analysis-profile.md`로 렌더링됩니다.
 
 ### Phase 간 정보 전달

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "okstra",
-  "version": "0.56.0",
+  "version": "0.57.0",
   "description": "Multi-agent cross-verification orchestrator runtime + Claude Code skills.",
   "license": "MIT",
   "author": "devonshin",

package/runtime/BUILD.json

@@ -1,5 +1,5 @@
 {
-  "package": "0.56.0",
-  "builtAt": "2026-06-07T06:39:30.395Z",
+  "package": "0.57.0",
+  "builtAt": "2026-06-08T17:08:29.657Z",
   "repoRoot": "/home/runner/work/okstra/okstra"
 }

package/runtime/prompts/profiles/_common-contract.md

@@ -25,7 +25,7 @@ profile document.
 - Authority & permissions assumption (applies to every okstra task-type):
   - **Assume the user (and their team) holds full authority and every permission required for the anticipated, in-flight, or follow-up work.** Treat external approvals, third-party access grants, role/IAM permissions, organisational sign-off, legal/compliance review, vendor coordination, and "verify access exists" steps as already satisfied unless the task brief explicitly states otherwise.
   - Do NOT add such items to routing decisions, missing-materials lists, clarification questions, option trade-offs, dependency/migration risk, validation checklists, rollout plans, acceptance blockers, residual risks, release recommendations, the `## 1. Clarification Items` table, or any day/effort estimate. They are not legitimate sources of schedule extension.
-  - Internal okstra phase handoffs (e.g. the `User Approval Request` block in `implementation-planning`) are unaffected — those are the user themselves approving and proceed without external coordination.
+  - Internal okstra phase handoffs (e.g. the `approved:` frontmatter gate in `implementation-planning`) are unaffected — those are the user themselves approving and proceed without external coordination.
   - This rule does NOT relax any phase-specific Forbidden actions list; safety rules in the per-profile document remain in force regardless of the user's authority.
 - Anti-escalation rule (shared):
   - treating "다음 단계 진행해" or equivalent user phrases as authorisation to start a *different* lifecycle phase is forbidden. The next phase begins only in a separate okstra run launched with the new `--task-type`. Per-profile documents may further restrict this within their own scope.
@@ -61,7 +61,7 @@ profile document.
   - **Reporter confirmation precondition (BLOCKING)**: the brief's frontmatter carries `reporter-confirmations: <complete | partial | pending | skipped>` set by `okstra-brief` Step 6.5. Every phase that consumes the brief MUST read this field before doing analysis. The handling matrix is:
     - `complete` → proceed normally.
     - `partial` → proceed; treat still-unmarked `intent-check:` / `conversion-block:` rows as the `skipped` branch.
-    - `skipped` → do NOT silently infer the missing answers. Promote each unmarked `intent-check:` / `conversion-block:` row into this run's `## 1. Clarification Items` as `Kind=decision`. Use `Blocks=approval` in `implementation-planning`, where the row gates the User Approval Request; otherwise use `Blocks=next-phase`. The recommended answer is drawn from the brief's matching content and clearly labelled `보고자 직접 확인 권장`.
+    - `skipped` → do NOT silently infer the missing answers. Promote each unmarked `intent-check:` / `conversion-block:` row into this run's `## 1. Clarification Items` as `Kind=decision`. Use `Blocks=approval` in `implementation-planning`, where the row gates the `approved:` frontmatter flip; otherwise use `Blocks=next-phase`. The recommended answer is drawn from the brief's matching content and clearly labelled `보고자 직접 확인 권장`.
     - `pending` (or field missing) → ABORT analysis; render the Verdict Card with `Verdict Token = blocked` + `Direction = hold` and write a single `## Reporter Confirmation Required` block (no leading number) summarising which rows are pending. The `## 1. Clarification Items` table carries one row per pending item with `Blocks=approval` in `implementation-planning`, otherwise `Blocks=next-phase`. The operator must rerun `okstra-brief` Step 6.5. Do NOT emit `## 0.` for this case — Section 0 is reserved for clarification-response carry-in only.
     `[CONFIRMED <YYYY-MM-DD> → RC-N]` markers on `Open Questions` rows are the per-row signal that the reporter has answered; their answers live verbatim under `## Reporter Confirmations` in the brief.
   - `Source Material` is reporter-verbatim. Do NOT paraphrase, summarize, reorder, or restructure it. Quote it directly when needed.
@@ -81,9 +81,9 @@ profile document.
   - **Canonical column schema (SSOT — must match `templates/reports/final-report.template.md` §1 exactly):** every `## 1. Clarification Items` table has exactly these 8 columns, in this order:
     `| ID | Ticket ID | Kind | Statement | Expected form | Blocks | Status | User input |`.
     Profile-specific addenda may tighten cell content but MUST NOT add, remove, rename, or reorder columns. The `ID` cell uses `C-NNN` (3-digit zero-padded), the `Status` cell ∈ `{open, answered, resolved, obsolete}`, and the `Kind` / `Blocks` legal values are listed below.
-  - section 1 is a **single unified table** per `final-report-template.md`. Every clarification item — whether the user must attach a file, choose between options, or supply a single number/path — is one row of that table. Do not split it into sub-sections (`1.1 추가 자료 요청` / `1.2 사용자 확인 질문` / `5.5.9 Open Questions` are removed and the validator fails reports that reintroduce them), do not create a parallel table elsewhere in the report, and do not duplicate the same item into the top-of-report `User Approval Request (사용자 승인 게이트)` block or any other section.
+  - section 1 is a **single unified table** per `final-report-template.md`. Every clarification item — whether the user must attach a file, choose between options, or supply a single number/path — is one row of that table. Do not split it into sub-sections (`1.1 추가 자료 요청` / `1.2 사용자 확인 질문` / `5.5.9 Open Questions` are removed and the validator fails reports that reintroduce them), do not create a parallel table elsewhere in the report, and do not duplicate the same item into an approval block or any other section.
   - each row's `Kind` column picks one of `{material, decision, data-point}`: `material` for files / snapshots / logs / screenshots the user must attach (the `User input` cell will hold a path or URL); `decision` for choices and yes/no confirmations only the user can make; `data-point` for a single number, ID, date, or short string the user can answer inline. Items that mix "yes/no + file path if yes" are one row of `Kind=material` with the combined expectation written into `Expected form`.
-  - each row's `Blocks` column picks one of `{approval, next-phase, none}`. `approval` is reserved for items that gate an approval action, especially the `implementation-planning` User Approval Request; outside `implementation-planning`, unresolved brief reporter-confirmation rows use `next-phase` instead. `next-phase` blocks the next run from starting cleanly. `none` is informational/audit-only.
+  - each row's `Blocks` column picks one of `{approval, next-phase, none}`. `approval` is reserved for items that gate an approval action, especially the `implementation-planning` `approved:` frontmatter flip; outside `implementation-planning`, unresolved brief reporter-confirmation rows use `next-phase` instead. `next-phase` blocks the next run from starting cleanly. `none` is informational/audit-only.
   - write every entry in full, descriptive sentences that a non-developer can act on without further context. Avoid abbreviations and internal jargon. The `Statement` cell must state *what* is needed, *why* the answer / attachment changes the next step, and (for `material`) *where* the user can find it and *where* to place it. The `Expected form` cell must state the answer shape (예/아니오, 보기 중 하나, 숫자/날짜, 파일 경로, 짧은 서술 등); supply concrete option choices when applicable.
   - if a phase requires a recommended answer, alternatives, or an evidence-check note, encode it inside the existing 8-column schema: put evidence notes in `Statement` as `Evidence checked: <path:line>` or `Evidence checked: none — <human-only reason>`, and put recommendations/options in `Expected form` as `Recommended: <answer> — <rationale>; Alternatives: <options>`. Do not add `Recommended`, `Evidence`, `Alternatives`, or `evidence-checked` columns.
   - the same `final-report.md` file is the canonical artifact carried into the next run; the user appends answers inline before rerunning. The preferred turn-around is `scripts/okstra.sh --resume-clarification --task-key <project-id>:<task-group>:<task-id>` (opens the latest report in `$EDITOR`, then auto-reruns the same phase with `--clarification-response` carry-in). The lower-level form `--clarification-response <path>` remains available for scripted runs.

package/runtime/prompts/profiles/_implementation-deliverable.md

@@ -48,7 +48,7 @@ are collected and convergence finished. Phase 1-5 do not need it.
 ## Lead post-stage persistence (BLOCKING — runs after the Executor emits `### Stage Carry Evidence`)
 
 - Parse the executor's `### Stage Carry Evidence` JSON block. If absent or unparsable, end with status `contract-violated` and route to a follow-up `error-analysis`.
-- For EACH stage in this run's batch: write its JSON verbatim to `runs/<impl-task-key>/carry/stage-<N>.json`. Refuse to overwrite an existing file (one stage = one sidecar; re-runs are out of scope for this version).
-- For EACH stage in this run's batch: append a `status:"done"` row to `runs/<plan-task-key>/consumers.jsonl` with `completed_at`, `carry_path`, `report_path` (this run's final-report path relative to the run root), and the SHA of HEAD. Use the okstra runtime's `consumers_mutex` helper (NOT a raw filesystem write) to honour the lock. `report_path` lets `final-verification` cite each stage's originating report when assembling its Source Implementation Report list.
-- The verifier round, Phase 5.5 convergence, and this Phase 6 report run **once per run** over the batch's combined diff — NOT per stage. The single final report covers every batched stage, with a per-stage subsection.
-- Quote every batched stage's new contents (each sidecar JSON in full, each new consumers row by itself) in the final report's `Stage sidecar evidence` deliverable section.
+- For this run's single stage: write its JSON verbatim to `runs/<impl-task-key>/carry/stage-<N>.json`. Refuse to overwrite an existing file (one stage = one sidecar; re-runs are out of scope for this version).
+- For this run's single stage: append a `status:"done"` row to `runs/<plan-task-key>/consumers.jsonl` with `completed_at`, `carry_path`, `report_path` (this run's final-report path relative to the run root), and the SHA of HEAD. Use the okstra runtime's `consumers_mutex` helper (NOT a raw filesystem write) to honour the lock. `report_path` lets `final-verification` cite each stage's originating report when assembling its Source Implementation Report list.
+- The verifier round, Phase 5.5 convergence, and this Phase 6 report run **once per run** over this stage's diff — NOT per step.
+- Quote this stage's new contents (the sidecar JSON in full and the new consumers row by itself) in the final report's `Stage sidecar evidence` deliverable section.

package/runtime/prompts/profiles/_implementation-executor.md

@@ -48,10 +48,7 @@ until Phase 5 ends, then drop from active context for Phase 6/7.
 
 - **Sidecar evidence writer (BLOCKING).** When this stage's Stage Validation `post` commands all succeed, the Executor MUST emit a JSON object matching the schema in `docs/superpowers/specs/2026-05-20-implementation-planning-multi-stage-design.md` §3.2 and the lead MUST persist it to `runs/<impl-task-key>/carry/stage-<N>.json`. The file MUST NOT exist before the run starts (overwrite is refused — see `--force-stage` non-goal).
 - **Reverse link (BLOCKING).** The runtime already appended a `status:"started"` row for this stage before the run began. On completion, append a `status:"done"` row with `carry_path` populated for this stage number.
-- **One-PR-per-run.** This run creates exactly one PR titled `Stage <N>: <title>`. The PR body MUST include:
-  - `## Stage <N>` — number, title (from Stage Map row), touched files, and validation result.
-  - `## Carry-In summary` — depends-on list + cited identifiers/SHAs from each loaded sidecar (omit when depends-on is empty).
-  - `## Previous run` / `## Next run` — links so a reviewer can navigate the run chain.
+- **No PR / push in this phase.** This run produces local commits, carry sidecar evidence, verifier results, and the implementation final report only. Push and PR creation belong exclusively to the later `release-handoff` phase after `final-verification` returns `accepted`.
 
 ## Allowed actions during the run
 

package/runtime/prompts/profiles/final-verification.md

@@ -41,7 +41,7 @@
 - Clarification request policy (phase-specific addendum — shared policy is in `_common-contract.md`):
   - populate `## 1. Clarification Items` only when a blocker hinges on information only the user can supply (deployment intent, intended target environment, business-rule interpretation); use `Blocks=next-phase` for items that gate continuing to release-handoff
 - Self-review pass before finalising the report (`Claude lead` runs this; do not delegate to a generic subagent):
-  1. **Verdict precision** — section 2 includes `Verdict Token` with one of the three allowed verdict tokens; `conditional-accept` lists every condition as an actionable item.
+  1. **Verdict precision** — section 7 (`Final Verdict`) includes `Verdict Token` with one of the three allowed verdict tokens; `conditional-accept` lists every condition as an actionable item.
   2. **Blocker traceability** — every blocker cites a concrete artifact (file:line, log excerpt, test exit code, MCP SELECT). Blockers without evidence are demoted to residual risk or removed.
   3. **Coverage check** — every requirement in the originating plan/task brief is either marked covered (with artifact) or listed as a blocker. No silent omissions.
   4. **Verifier dissent preserved** — if workers reach different verdicts, the disagreement is visible in section 1.2; synthesis hides nothing.

package/runtime/prompts/profiles/implementation-planning.md

@@ -9,7 +9,7 @@
   - gemini — when added to the roster it joins the analyser set; omitted by default
 {{INCLUDE:_common-contract.md}}
 - Brief consumption (phase-specific addendum — shared rules live in `_common-contract.md` under "Brief handoff contract"):
-  - Apply the shared reporter-confirmation precondition exactly as written. In this phase, unresolved `intent-check:` / `conversion-block:` rows use `Blocks=approval`; the operator cannot toggle `User Approval Request` until those rows are resolved.
+  - Apply the shared reporter-confirmation precondition exactly as written. In this phase, unresolved `intent-check:` / `conversion-block:` rows use `Blocks=approval`; the operator cannot flip the approval frontmatter to `approved: true` until those rows are resolved.
   - never plan around an unconfirmed `intent-inference` augmentation as if it were a settled requirement. After the precondition runs, a `[CONFIRMED …]` marker on the matching `intent-check:` row is the signal that the inference can be treated as settled; otherwise it remains a `Blocks=approval` clarification item per the precondition's `skipped` branch.
   - `conversion-block:` rows are handled by the precondition; planning around an untranslated reporter phrase is forbidden until it is resolved.
 - Pre-planning context exploration (mandatory before option drafting):
@@ -55,7 +55,7 @@
 - Section heading contract (BLOCKING — validator scans for these literal English substrings):
   - The final report MUST include section headings containing each of the following exact strings: `Option Candidates`, `Trade-off`, `Recommended Option`, `Stage Map`, `Stage Exit Contract`, `Stage Validation`, `Dependency`, `Validation Checklist`, `Rollback`, `Requirement Coverage`. (Approval is no longer a body section — it is the YAML frontmatter `approved` field.)
   - Korean translations are allowed in parentheses (e.g. `### Recommended Option (권장 옵션)`), but the English keyword must be present verbatim in the heading line.
-  - The shape and ordering follow `final-report-template.md` section 4.5 (`Implementation Plan Deliverables`). Do NOT translate the heading keywords — `validators/validate-run.py` does substring matching on the raw report text and 7-of-8 missing strings is a real, repeatedly observed failure mode (root cause: writer translated the headings to Korean).
+  - The shape and ordering follow `final-report-template.md` section 5.5 (`Implementation Plan Deliverables` + `Stage Map`). Do NOT translate the heading keywords — `validators/validate-run.py` does substring matching on the raw report text and missing English strings are a real, repeatedly observed failure mode (root cause: writer translated the headings to Korean).
   - Beyond substring matching, when the Plan Body Verification gate result is `passed` / `passed-with-dissent`, `validators/validate-run.py` runs the **structural** Stage Map validator (`validators/validate-implementation-plan-stages.py`) at the planning boundary — the exact `## 5.5 Stage Map` heading, each `## 5.5.<i> Stage <i>:` section with its four required subsections, the per-stage effective step count (≤6), the `depends-on` DAG, and the per-stage vertical-slice contract (S10) are all enforced here, not deferred to the `implementation` entry gate. S10 scans for the literal in-section strings `Slice value:`, `Acceptance:`, and the Stepwise `action`-cell prefixes `RED:` / `GREEN:` (or a `TDD exemption:` line) — keep these tokens verbatim for the same reason as the heading keywords above.
 - Required deliverable shape (final report, in addition to the standard sections):
   - at least two implementation options. **Each option must include**:
@@ -88,8 +88,8 @@
   - the YAML frontmatter MUST include the line `approved: false` (report-writer always emits the unflipped value). The user authorises the next `implementation` run by flipping it to `approved: true` (manual edit or `--approve` CLI). Do NOT recreate any `User Approval Request` body block — the validator fails reports that contain one (see `validators/validate-run.py` deprecated patterns).
   - the YAML frontmatter MUST include the line `implementation-option:` directly under `approved:` (report-writer always emits it with an **empty value**). The user selects which Option Candidate the next `implementation` run executes by filling this line with that option's name (manual edit or `--implementation-option <name>` CLI). When left empty, the `implementation` run falls back to the `Recommended Option`.
   - **the frontmatter `approved: false` line is rendered unconditionally; if the plan-body verification gate (§5.5.9) returns `blocked-by-disagreement` or `aborted-non-result`, the writer MUST keep `approved: false` and the validator refuses any report that ships with `approved: true` under such a gate result.**
-  - every ambiguity flagged during pre-planning that the user must resolve before approval registered as a `Blocks=approval` row in the `## 1. Clarification Items` table (do NOT create a separate `Open Questions` block under `4.5.x` — the unified table is the single home)
-  - **§5.5.9 Plan Body Verification (BLOCKING).** After report-writer finishes the draft, the lead MUST run a worker peer-review round on the consolidated plan body (sections 4.5.1 – 4.5.7) and populate `### 5.5.9 Plan Body Verification` in the final report. The round protocol, plan-item ID scheme (`P-Opt-*` / `P-Step-*` / `P-Dep-*` / `P-Val-*` / `P-Rb-*`), verdict semantics, gate-result classification, and dissent log format are defined in `skills/okstra-convergence/SKILL.md` "Plan-body verification mode". The four gate-result values are `passed`, `passed-with-dissent`, `blocked-by-disagreement`, `aborted-non-result`. When the gate would have been `blocked-by-disagreement` or `aborted-non-result`, the lead MUST NOT silently flip it to one of the passing values to "unblock" the run — that is a contract violation. When `convergence.adversarial=true` (the default for this phase), this round uses the adversarial posture — verifiers confirm cited paths/commands and the burden of proof is on the plan — but the gate threshold stays `majority-disagree` (see that skill's §"Adversarial plan-body posture").
+  - every ambiguity flagged during pre-planning that the user must resolve before approval registered as a `Blocks=approval` row in the `## 1. Clarification Items` table (do NOT create a separate `Open Questions` block under the implementation plan body — the unified table is the single home)
+  - **§5.5.9 Plan Body Verification (BLOCKING).** After report-writer finishes the draft, the lead MUST run a worker peer-review round on the consolidated plan body (Option Candidates / Trade-off Matrix / Recommended Option / Stage Map and per-stage sections / Dependency / Validation Checklist / Rollback / Requirement Coverage) and populate `### 5.5.9 Plan Body Verification` in the final report. The round protocol, plan-item ID scheme (`P-Opt-*` / `P-Step-*` / `P-Dep-*` / `P-Val-*` / `P-Rb-*`), verdict semantics, gate-result classification, and dissent log format are defined in `skills/okstra-convergence/SKILL.md` "Plan-body verification mode". The four gate-result values are `passed`, `passed-with-dissent`, `blocked-by-disagreement`, `aborted-non-result`. When the gate would have been `blocked-by-disagreement` or `aborted-non-result`, the lead MUST NOT silently flip it to one of the passing values to "unblock" the run — that is a contract violation. When `convergence.adversarial=true` (the default for this phase), this round uses the adversarial posture — verifiers confirm cited paths/commands and the burden of proof is on the plan — but the gate threshold stays `majority-disagree` (see that skill's §"Adversarial plan-body posture").
   - **Decision-record evaluation (sole owner)**: this phase is the **single owner** of decision-record evaluation in the okstra lifecycle. The brief never evaluates or drafts decision records — it only forwards `adr-candidate:*` signals. Every `adr-candidate:*` entry inherited from the brief's `Open Questions` is a mandatory evaluation target. In addition, evaluate every decision the recommended option introduces against the three criteria:
     1. **Hard to reverse** — would changing the decision later cost meaningfully more than deciding now?
     2. **Surprising without context** — would a future reader, seeing only the code, wonder "why was it built this way?"?
@@ -109,5 +109,5 @@
   4. **Ambiguity check** — any requirement that could be read two ways must be made explicit or moved to the `## 1. Clarification Items` table as a `Blocks=approval` row.
   5. **Scope check** — if the recommended plan now spans multiple independent subsystems, recommend splitting into separate planning runs rather than shipping an oversized plan.
   6. **Review-rule preflight check** — if a project review rule pack exists, map each relevant rule to the recommended option. Reject the draft if it knowingly creates a violation that the later PR reviewer would flag, unless the plan records a specific rationale and follow-up. In particular, scan for repeated helper stacks across planned files, tests that assert delegation to the same calculator/helper they exercise, public names that hide side effects, domain rules placed in repositories/adapters, and APIs made dead by this change.
-  7. **Plan-body verification reconciliation (BLOCKING for implementation-planning).** Inspect the `### 5.5.9 Plan Body Verification` verdict table. For every plan-item row classified as `majority-disagree → C-<N>`, the corresponding `C-<N>` row MUST exist in `## 1. Clarification Items` with `Kind` chosen per the standard policy and `Blocks=approval`. Do NOT create a parallel `### 5.5.x Open Questions` block — the unified table is the single home. Conversely, the `Classification` column's `C-<N>` reference and the `## 1. Clarification Items` `ID` column MUST match 1:1; an orphan on either side is a contract violation. For `partial-consensus` and `worker-unique` plan-items, the dissenting opinion lives in §5.5.9 `Dissent log` and is NOT promoted to §5.
+  7. **Plan-body verification reconciliation (BLOCKING for implementation-planning).** Inspect the `### 5.5.9 Plan Body Verification` verdict table. For every plan-item row classified as `majority-disagree → C-<N>`, the corresponding `C-<N>` row MUST exist in `## 1. Clarification Items` with `Kind` chosen per the standard policy and `Blocks=approval`. Do NOT create a parallel `Open Questions` block under the implementation plan body — the unified table is the single home. Conversely, the `Classification` column's `C-<N>` reference and the `## 1. Clarification Items` `ID` column MUST match 1:1; an orphan on either side is a contract violation. For `partial-consensus` and `worker-unique` plan-items, the dissenting opinion lives in §5.5.9 `Dissent log` and is NOT promoted to §5.
   8. **Stage Map self-check** — for every stage, count the effective rows of its `Stepwise Execution Order` table by hand; reject the draft if any stage exceeds 6. Confirm each stage declares a non-empty `Slice value:` and `Acceptance:` line, and that its first step `action` starts with `RED:` with a later `GREEN:` (or carries a `TDD exemption:` line) — this is what validator S10 enforces. Walk the `depends-on` graph and confirm it is a DAG (no cycle, no self-reference). For each `depends-on` link, confirm it encodes a real data/contract dependency — do NOT add links to serialise unrelated work, and do NOT split a stage merely to create more parallel stages. **Parallel-safety:** for every pair of `depends-on (none)` stages, confirm their `Stage Exit Contract` predicted file sets are disjoint; if they share a file, merge them or add a `depends-on` link (validator S9 rejects overlap).

package/runtime/prompts/profiles/implementation.md

@@ -1,7 +1,7 @@
 # Implementation Profile
 
 - Purpose: realise the approved `implementation-planning` deliverable as actual source changes, with cross-model verification, while keeping the run reversible
-- **Run-level fixed cost:** the verifier set, Phase 5.5 convergence, and the Phase 6 report-writer run exactly once per run, over the combined diff of all stages in this run's batch — never once per stage.
+- **Run-level fixed cost:** the verifier set, Phase 5.5 convergence, and the Phase 6 report-writer run exactly once per implementation run, over this run's single stage diff — never once per step.
 - Required workers:
   - claude
   - codex
@@ -20,14 +20,14 @@
   - that file's YAML frontmatter MUST carry `approved: true`. report-writer emits `approved: false` by default; the user flips it to `true` to authorise this run. Free-form approvals such as "lgtm" / "go ahead" / paraphrased confirmations are NOT accepted; re-edit the plan file's frontmatter to `approved: true` before invoking implementation, or pass `--approve` so the CLI flips it on the user's behalf (`okstra_ctl.run._apply_cli_approval`).
   - The `--approve` flag is meaningful ONLY with `--task-type implementation` and `--approved-plan <path>`; any other use raises `PrepareError`. Idempotent — re-running with `approved: true` already set appends an audit line but does NOT re-toggle.
   - the authoritative scope for this run is the Option Candidate named by the YAML frontmatter `implementation-option:` field. **If `implementation-option:` is empty, fall back to the plan's `Recommended Option`** (this is a soft fallback, not a hard block). The chosen option's bite-sized step list becomes the authoritative scope; deviations must be justified in the final report and routed back to a new `implementation-planning` run rather than silently expanded. If the chosen option name does not match any heading under `Option Candidates`, record it as a deviation.
-- Task worktree (provisioned by `okstra-ctl` at the first phase's run-prep time, reused for every subsequent phase of this task-key):
+- Stage worktree (provisioned by `okstra-ctl` at this implementation run's prep time):
   - Status: `{{EXECUTOR_WORKTREE_STATUS}}` (one of: `created` | `reused` | `skipped-in-worktree` | `skipped-not-git`)
-  - Working tree path: `{{EXECUTOR_WORKTREE_PATH}}` — when status is `created` or `reused`, this is the task's `git worktree` rooted at `~/.okstra/worktrees/<project>/<task-group>/<task-id>/`. When skipped, this is the caller's `project_root`.
-  - Branch: `{{EXECUTOR_WORKTREE_BRANCH}}` — empty when status is `skipped-*`. Branch name = `<work-category-prefix>-<task-id-segment>`, globally unique via `~/.okstra/worktrees/registry.json`.
-  - Base ref: `{{EXECUTOR_WORKTREE_BASE_REF}}` — canonical `<base>` for every `git diff` / `git log` in this run.
+  - Working tree path: `{{EXECUTOR_WORKTREE_PATH}}` — when status is `created` or `reused`, this is this run's isolated stage worktree rooted at `~/.okstra/worktrees/<project>/<task-group>/<task-id>/stage-<N>/`. When skipped, this is the caller's `project_root`.
+  - Branch: `{{EXECUTOR_WORKTREE_BRANCH}}` — empty when status is `skipped-*`. Branch name = `<work-category-prefix>-<task-id-segment>-s<N>`, globally unique via `~/.okstra/worktrees/registry.json`.
+  - Base ref: `{{EXECUTOR_WORKTREE_BASE_REF}}` — canonical `<base>` for every `git diff` / `git log` in this run. Independent stages start from the task anchor; dependent stages start from the predecessor done commit or the verified merged task worktree head.
   - Provisioning note: `{{EXECUTOR_WORKTREE_NOTE}}`
   - Treat the working-tree path as `project_root` for the duration of this run. Do NOT mutate the caller's original checkout. cwd-sensitive Bash commands MUST be prefixed `cd {{EXECUTOR_WORKTREE_PATH}} && ` in the same Bash invocation (never `bash -lc "..."` wrappers — see executor sidecar for full rules).
-  - Lifecycle: kept after the run completes; reused by every subsequent phase of the same task-key. Manual cleanup: `git worktree remove <path>` → `git branch -D <branch>` → drop registry entry.
+  - Lifecycle: kept after the run completes as this stage's evidence worktree. Later stages get their own stage worktrees. Manual cleanup: `git worktree remove <path>` → `git branch -D <branch>` → drop the stage-key registry entry (`<task-key>#stage-<N>`).
 - Approval gate (phase-specific addendum to shared authority rule):
   - the pre-implementation gate's recorded user approval marker is the only authorised approval gate at this phase — proceed once it is satisfied without further external coordination.
 - Forbidden actions — universal (any occurrence → terminal status `contract-violated`):

package/runtime/prompts/profiles/improvement-discovery.md

@@ -30,6 +30,7 @@
   - When candidates branch on a structural question (e.g. "is module X meant to own this responsibility?"), resolve via `Read` / `Grep` first. Only escalate to the user inside the Phase 1.5 budget.
 - Expected output emphasis:
   - the `## 5.9 Improvement Candidates` table populated with rows that obey the 10-column schema from `validators/validate-improvement-report.py` (Cand ID `I-NNN`, Lens from whitelist, Title, Scope ⊆ scan-scope, Severity, Effort, Consensus, Source workers `<worker>:<id>` from {claude, codex, gemini}, Recommended next-phase ∈ {requirements-discovery, implementation-planning, error-analysis}, Evidence as path:line list)
+  - `Consensus` cells in `## 5.9 Improvement Candidates` use the table enum exactly: `full`, `partial`, `contested`, `worker-unique`. Map convergence's `full-consensus` / `partial-consensus` labels to `full` / `partial` before writing the table.
   - `## 7. Final Verdict` Verdict Token ∈ {`candidates-ready`, `no-candidates`, `blocked`}; Direction `routing`; Next Step "사용자에게 후보 K개 선택 의뢰 (## 5.9 표 참조)"
   - `## 3. Recommended Next Steps` first entry summarises per-candidate routing and proposes new task-key names of the form `<task-group>/imp-<Cand-ID>`
   - this report is authored free-form (improvement-discovery is not in the data.json schema enum); after the markdown is written, the report-writer runs `scripts/okstra-inject-report-index.py <report.md> --report-language <en|ko>` to add the top-of-report Index + `I-NNN`/`C-NNN` scroll anchors. The run validator fails the report when the Index anchor is missing.

package/runtime/prompts/profiles/release-handoff.md

@@ -2,11 +2,11 @@
 
 - Purpose: take an `accepted` final-verification verdict for an already-committed implementation branch and turn it into a delivered push and/or pull request, with explicit user selection at every mutating step
 - **Execution model: single-lead, no worker dispatch.** This phase is a thin orchestrator over `git` / `gh`; it does NOT run team-mode, does NOT call `TeamCreate`, does NOT dispatch analysis or drafter sub-agents, and does NOT run convergence. The Claude lead performs every step inline (drafting PR text, asking the user, running git / gh, writing the final report) — see "Lead-only contract" below.
-- Required workers: *(none — this profile intentionally has no `- Required workers:` block; the run is executed entirely by the Claude lead)*
+- Worker roster: none — this profile intentionally has no `- Required workers:` block; the run is executed entirely by the Claude lead.
 - Lead-only contract (replaces the shared team contract for this phase):
   - The Claude lead is the sole agent for this run. No `Agent(...)` worker dispatch, no `TeamCreate`, no parallel sub-agents, no convergence loop.
   - The lead drafts the PR title and PR body **inline** by reading the run brief, the cited final-verification report, `git log --oneline <base>..HEAD`, and `git diff <base>..HEAD --stat`. No drafter worker is dispatched.
-  - The lead authors the final-report file directly (no `Report writer worker` dispatch). The report still conforms to the standard `okstra-final-report.template.md` structure, including the `## 5.6 Release Handoff Deliverables` section.
+  - The lead authors the final-report file directly (no `Report writer worker` dispatch). The report still conforms to the standard `templates/reports/final-report.template.md` structure, including the `## 5.6 Release Handoff Deliverables` section.
   - The shared anti-escalation rule from the common contract still applies: do not start any other lifecycle phase from inside this run.
   - The shared "authority & permissions assumption" rule from the common contract still applies: assume the user holds every permission needed; do not block on hypothetical approvals.
   - The shared "MCP read-only" rule still applies if the brief lists MCP servers, though most release-handoff runs do not use MCP.
@@ -22,7 +22,7 @@
      - `push + PR` — push the feature branch, then open or reuse a pull request.
      - `skip` — record the verified state and end the run without any git command.
      If the user picks `skip`, route directly to the final-report self-review pass.
-  2. **PR base branch** (only when the user picked `push + PR`) — present six options and capture exactly one:
+  2. **PR base branch** (only when the user picked `push + PR`) — present four options and capture exactly one:
      - `staging`
      - `preprod`
      - `main`
@@ -75,7 +75,7 @@
   - **User Selections**: a block recording each prompt and the user's verbatim answer.
     - Q1 action: `local only` | `push + PR` | `skip`.
     - Q2 PR base (if applicable): the chosen branch and how it was selected (menu pick vs free-form input).
-    - Q2b merge-conflict probe (if applicable): `clean` (no conflict, no prompt shown) | `proceed anyway` | `change base branch` | `cancel`. When a conflict was detected, list the conflicting paths.
+    - Q2b merge-conflict probe (if applicable): `not-run` | `clean` (no conflict, no prompt shown) | `proceed anyway` | `change base branch` | `cancel`. Record it in both the `User Selections` row `H2b` and the `Merge Conflict Probe` deliverable. When a conflict was detected, list the conflicting paths.
     - Q3 title/body: `use as-is` | `edit then proceed` (with a diff between the lead's draft and the final text) | `cancel`.
   - **Executed Commands**: every git / gh command the lead actually ran, with its exit code and a one-line stdout/stderr summary. Read-only inspection commands MAY be summarised; mutating commands MUST be listed verbatim.
   - **Commit List**: each existing implementation commit in `git log <base>..HEAD`, with short/full SHA, subject line, and touched files. Release-handoff MUST NOT create new commits.

package/runtime/prompts/wizard/prompts.ko.json

@@ -95,13 +95,16 @@
       }
     },
     "brief_path_pick": {
-      "label": "task brief markdown 의 경로를 선택해주세요",
+      "label": "task brief markdown 을 선택해주세요",
       "echo_template": "brief(pick): {value}",
       "options": {
         "__existing__": "기존 brief 사용: {existing}",
         "__standard__": "표준 경로 사용: {standard}",
         "__free_input__": "직접 입력"
       },
+      "labels": {
+        "brief_candidate": "같은 task-group brief: {path}"
+      },
       "errors": {
         "existing_missing": "기존 brief 가 없습니다. 다른 옵션을 선택하세요."
       }

package/runtime/python/okstra_ctl/wizard.py

@@ -99,6 +99,7 @@ PICK_USE_SUGGESTED = "__use_suggested__"
 PICK_TYPE_CUSTOM = "__free_input__"
 _RECENT_PREFIX = "__recent:"
 _REPORT_PREFIX = "__report:"
+_BRIEF_PREFIX = "__brief:"
 
 # Lines of `key: value` we pull from a brief markdown frontmatter. The
 # parser is intentionally lightweight (no yaml dep) and tolerant — a
@@ -176,6 +177,38 @@ def _brief_suggestions(path: Path) -> tuple[str, str]:
     return tg, tid
 
 
+def _project_relative_path(path: Path, project_root: Path) -> str:
+    try:
+        return str(path.relative_to(project_root))
+    except ValueError:
+        return str(path)
+
+
+def _accept_brief_path(state: WizardState, path: Path) -> None:
+    """Record a validated brief and derive safe identity suggestions.
+
+    New-task runs now ask for ``task_group`` before the brief so the wizard
+    can offer same-group brief candidates. If the selected brief carries a
+    conflicting frontmatter ``task-group``, fail fast; otherwise keep using
+    the brief's ``brief-id`` as the task-id suggestion.
+    """
+    tg_suggestion, tid_suggestion = _brief_suggestions(path)
+    if state.task_group and tg_suggestion:
+        suggested_group = _slug_or_die(tg_suggestion, "task_group")
+        if suggested_group != state.task_group:
+            raise WizardError(
+                "brief task-group does not match selected task-group: "
+                f"{tg_suggestion!r} != {state.task_group!r} ({path})"
+            )
+    state.brief_path = str(path)
+    state.brief_path_pending_text = False
+    if state.is_new_task:
+        if not state.task_group:
+            state.task_group_suggestion = tg_suggestion
+        if not state.task_id:
+            state.task_id_suggestion = tid_suggestion
+
+
 # ---- Step IDs ------------------------------------------------------------
 
 S_TASK_PICK = "task_pick"
@@ -771,6 +804,39 @@ def _suggest_recent_task_ids(state: WizardState, limit: int = 2) -> list[str]:
     return seen
 
 
+def _suggest_group_briefs(state: WizardState, limit: int = 6) -> list[str]:
+    """Return recent okstra-brief outputs for the selected task-group.
+
+    ``okstra-brief`` writes to ``.okstra/briefs/<task-group>/**/*.md``. The
+    wizard exposes those paths after task-group selection so users can pick a
+    generated brief instead of typing its path. Paths are project-relative.
+    """
+    if not state.project_root or not state.task_group:
+        return []
+    project_root = Path(state.project_root)
+    root = project_root / ".okstra" / "briefs" / state.task_group
+    if not root.is_dir():
+        return []
+    candidates: list[tuple[float, str]] = []
+    for path in root.rglob("*.md"):
+        if not path.is_file():
+            continue
+        tg_suggestion, _ = _brief_suggestions(path)
+        if tg_suggestion:
+            try:
+                if _slug_or_die(tg_suggestion, "task_group") != state.task_group:
+                    continue
+            except WizardError:
+                continue
+        try:
+            mtime = path.stat().st_mtime
+        except OSError:
+            mtime = 0.0
+        candidates.append((mtime, _project_relative_path(path, project_root)))
+    candidates.sort(key=lambda item: (-item[0], item[1]))
+    return [rel for _, rel in candidates[:limit]]
+
+
 def _build_task_group(state: WizardState) -> Prompt:
     sugg = state.task_group_suggestion
     if sugg:
@@ -1000,6 +1066,12 @@ def _build_brief_path_pick(state: WizardState) -> Prompt:
     if standard and standard != existing:
         options.append(_opt("__standard__",
                             t["options"]["__standard__"].format(standard=standard)))
+    brief_label = t["labels"].get("brief_candidate", "{path}")
+    for relpath in _suggest_group_briefs(state):
+        if relpath in (existing, standard):
+            continue
+        options.append(_opt(f"{_BRIEF_PREFIX}{relpath}",
+                            brief_label.format(path=relpath)))
     options.append(_opt(PICK_TYPE_CUSTOM, t["options"][PICK_TYPE_CUSTOM]))
     return Prompt(step=S_BRIEF_PATH_PICK, kind="pick",
                   label=t["label"], options=options,
@@ -1013,20 +1085,24 @@ def _submit_brief_path_pick(state: WizardState, value: str) -> Optional[str]:
             t = _p(state.workspace_root, "brief_path_pick")
             raise WizardError(t["errors"]["existing_missing"])
         p = _require_file(existing, Path(state.project_root), "task brief")
-        state.brief_path = str(p)
-        state.brief_path_pending_text = False
+        _accept_brief_path(state, p)
         return f"brief: {p}"
     if value == "__standard__":
         p = _require_file(standard, Path(state.project_root), "task brief")
-        state.brief_path = str(p)
-        state.brief_path_pending_text = False
+        _accept_brief_path(state, p)
+        return f"brief: {p}"
+    if value.startswith(_BRIEF_PREFIX):
+        relpath = value[len(_BRIEF_PREFIX):]
+        p = _require_file(relpath, Path(state.project_root), "task brief")
+        _accept_brief_path(state, p)
         return f"brief: {p}"
     if value == PICK_TYPE_CUSTOM:
         state.brief_path_pending_text = True
         state.brief_path = ""
         return None
     raise WizardError(
-        f"expected '__existing__', '__standard__', or {PICK_TYPE_CUSTOM!r}, "
+        f"expected '__existing__', '__standard__', '{_BRIEF_PREFIX}<path>', "
+        f"or {PICK_TYPE_CUSTOM!r}, "
         f"got: {value!r}"
     )
 
@@ -1042,16 +1118,7 @@ def _build_brief_path(state: WizardState) -> Prompt:
 
 def _submit_brief_path(state: WizardState, value: str) -> Optional[str]:
     p = _require_file(value, Path(state.project_root), "task brief")
-    state.brief_path = str(p)
-    state.brief_path_pending_text = False
-    # When the user is starting a brand-new task, pull task-group /
-    # task-id candidates from the brief frontmatter so the next two
-    # prompts can offer them as a one-click pick instead of forcing a
-    # free-text retype of what the brief already declares.
-    if state.is_new_task and not state.task_group and not state.task_id:
-        tg, tid = _brief_suggestions(p)
-        state.task_group_suggestion = tg
-        state.task_id_suggestion = tid
+    _accept_brief_path(state, p)
     return f"brief: {p}"
 
 
@@ -1907,13 +1974,25 @@ STEPS: list[Step] = [
                "profile_optional_workers",
                "task_group_suggestion", "task_id_suggestion",
                "task_group_pending_text", "task_id_pending_text")),
+    Step(S_TASK_GROUP,
+         applies=lambda s: (bool(s.is_new_task)
+                            and not s.task_group
+                            and not s.task_group_pending_text),
+         build=_build_task_group, submit=_submit_task_group,
+         owns=("task_group", "task_group_pending_text")),
+    Step(S_TASK_GROUP_TEXT,
+         applies=lambda s: (bool(s.is_new_task)
+                            and not s.task_group
+                            and s.task_group_pending_text),
+         build=_build_task_group_text, submit=_submit_task_group_text,
+         owns=("task_group", "task_group_pending_text")),
     Step(S_BRIEF_PATH_PICK,
          applies=lambda s: (
              not s.brief_path
              and not s.brief_path_pending_text
              and S_BRIEF_PATH_PICK not in s.answered
              and (
-                 (s.is_new_task is True)
+                 (s.is_new_task is True and bool(s.task_group))
                  or (s.is_new_task is False
                      and S_TASK_TYPE in s.answered
                      and (s.keep_existing_brief is False
@@ -1927,20 +2006,6 @@ STEPS: list[Step] = [
                             and S_BRIEF_PATH not in s.answered,
          build=_build_brief_path, submit=_submit_brief_path,
          owns=("brief_path", "task_group_suggestion", "task_id_suggestion")),
-    Step(S_TASK_GROUP,
-         applies=lambda s: (bool(s.is_new_task)
-                            and bool(s.brief_path)
-                            and not s.task_group
-                            and not s.task_group_pending_text),
-         build=_build_task_group, submit=_submit_task_group,
-         owns=("task_group", "task_group_pending_text")),
-    Step(S_TASK_GROUP_TEXT,
-         applies=lambda s: (bool(s.is_new_task)
-                            and bool(s.brief_path)
-                            and not s.task_group
-                            and s.task_group_pending_text),
-         build=_build_task_group_text, submit=_submit_task_group_text,
-         owns=("task_group", "task_group_pending_text")),
     Step(S_TASK_ID,
          applies=lambda s: (bool(s.is_new_task)
                             and bool(s.brief_path)

package/runtime/schemas/final-report-v1.0.schema.json

@@ -330,12 +330,13 @@
 
     "implementationPlanning": {
       "type": "object",
-      "description": "RENDER_IF taskType == implementation-planning. §4.5 deliverables.",
+      "description": "RENDER_IF taskType == implementation-planning. §5.5 deliverables.",
       "required": [
         "optionCandidates",
         "tradeoffMatrix",
         "recommendedOption",
-        "stepwiseExecution",
+        "stageMap",
+        "stages",
         "dependencyMigrationRisk",
         "validationChecklist",
         "rollbackStrategy",
@@ -355,7 +356,18 @@
           "items": { "$ref": "#/$defs/TradeoffRow" }
         },
         "recommendedOption": { "$ref": "#/$defs/RecommendedOption" },
+        "stageMap": {
+          "type": "array",
+          "minItems": 1,
+          "items": { "$ref": "#/$defs/StageMapRow" }
+        },
+        "stages": {
+          "type": "array",
+          "minItems": 1,
+          "items": { "$ref": "#/$defs/ImplementationPlanStage" }
+        },
         "stepwiseExecution": {
+          "description": "Legacy flat summary kept for compatibility only. New reports use stageMap/stages.",
           "type": "array",
           "minItems": 1,
           "items": { "$ref": "#/$defs/StepRow" }
@@ -385,7 +397,7 @@
 
     "releaseHandoff": {
       "type": "object",
-      "description": "RENDER_IF taskType == release-handoff. §4.6 deliverables.",
+      "description": "RENDER_IF taskType == release-handoff. §5.6 deliverables.",
       "required": [
         "sourceVerificationReport",
         "featureBranchState",
@@ -419,11 +431,14 @@
         },
         "userSelections": {
           "type": "object",
-          "required": ["h1", "h3"],
+          "required": ["h1", "h2b", "h3"],
           "additionalProperties": false,
           "properties": {
             "h1": { "enum": ["local only", "push + PR", "skip"] },
             "h2": { "type": "string" },
+            "h2b": {
+              "enum": ["not-run", "clean", "proceed anyway", "change base branch", "cancel"]
+            },
             "h3": { "enum": ["use as-is", "edit then proceed", "cancel"] }
           }
         },
@@ -482,12 +497,13 @@
 
     "implementation": {
       "type": "object",
-      "description": "RENDER_IF taskType == implementation. §4.7 deliverables.",
+      "description": "RENDER_IF taskType == implementation. §5.7 deliverables.",
       "required": [
         "approvedPlanReference",
         "commitList",
         "diffSummary",
         "outOfPlanEdits",
+        "stageSidecarEvidence",
         "validationEvidence",
         "verifierResults",
         "rollbackVerification",
@@ -526,6 +542,7 @@
           "type": "array",
           "items": { "$ref": "#/$defs/OutOfPlanEditRow" }
         },
+        "stageSidecarEvidence": { "$ref": "#/$defs/StageSidecarEvidence" },
         "validationEvidence": {
           "type": "array",
           "minItems": 1,
@@ -547,7 +564,7 @@
 
     "finalVerification": {
       "type": "object",
-      "description": "RENDER_IF taskType == final-verification. §4.8 deliverables.",
+      "description": "RENDER_IF taskType == final-verification. §5.8 deliverables.",
       "required": [
         "sourceImplementationReport",
         "acceptanceBlockers",
@@ -624,7 +641,7 @@
 
   "allOf": [
     {
-      "description": "implementation-planning task-type requires §4.5 block.",
+      "description": "implementation-planning task-type requires §5.5 block.",
       "if": {
         "properties": { "header": { "properties": { "taskType": { "const": "implementation-planning" } } } },
         "required": ["header"]
@@ -634,7 +651,7 @@
       }
     },
     {
-      "description": "release-handoff task-type requires §4.6 block.",
+      "description": "release-handoff task-type requires §5.6 block.",
       "if": {
         "properties": { "header": { "properties": { "taskType": { "const": "release-handoff" } } } },
         "required": ["header"]
@@ -644,7 +661,7 @@
       }
     },
     {
-      "description": "implementation task-type requires §4.7 block.",
+      "description": "implementation task-type requires §5.7 block.",
       "if": {
         "properties": { "header": { "properties": { "taskType": { "const": "implementation" } } } },
         "required": ["header"]
@@ -654,7 +671,7 @@
       }
     },
     {
-      "description": "final-verification task-type requires §4.8 block.",
+      "description": "final-verification task-type requires §5.8 block.",
       "if": {
         "properties": { "header": { "properties": { "taskType": { "const": "final-verification" } } } },
         "required": ["header"]
@@ -1066,6 +1083,90 @@
       }
     },
 
+    "StageMapRow": {
+      "type": "object",
+      "required": ["stage", "title", "dependsOn", "stepCount", "exitContractSummary"],
+      "additionalProperties": false,
+      "properties": {
+        "stage": { "type": "integer", "minimum": 1 },
+        "title": { "type": "string", "minLength": 1 },
+        "dependsOn": {
+          "type": "string",
+          "minLength": 1,
+          "description": "Literal Stage Map depends-on cell: `(none)` or a comma-separated stage number list."
+        },
+        "stepCount": { "type": "integer", "minimum": 0, "maximum": 6 },
+        "exitContractSummary": { "type": "string", "minLength": 1 }
+      }
+    },
+
+    "ImplementationPlanStage": {
+      "type": "object",
+      "required": [
+        "stage",
+        "title",
+        "sliceValue",
+        "acceptance",
+        "carryIn",
+        "stepwiseExecution",
+        "exitContract",
+        "stageValidation"
+      ],
+      "additionalProperties": false,
+      "oneOf": [
+        {
+          "required": ["conformanceTests"],
+          "not": { "required": ["conformanceExemption"] }
+        },
+        {
+          "required": ["conformanceExemption"],
+          "not": { "required": ["conformanceTests"] }
+        }
+      ],
+      "properties": {
+        "stage": { "type": "integer", "minimum": 1 },
+        "title": { "type": "string", "minLength": 1 },
+        "sliceValue": { "type": "string", "minLength": 1 },
+        "acceptance": { "type": "string", "minLength": 1 },
+        "conformanceTests": {
+          "type": "string",
+          "minLength": 1,
+          "description": "Text after the `Conformance tests: stage-N — ...` prefix."
+        },
+        "conformanceExemption": {
+          "type": "string",
+          "minLength": 1,
+          "description": "Text after the `Conformance exemption:` prefix."
+        },
+        "tddExemption": {
+          "type": "string",
+          "description": "Optional text after the `TDD exemption:` prefix."
+        },
+        "carryIn": { "type": "string", "minLength": 1 },
+        "stepwiseExecution": {
+          "type": "array",
+          "minItems": 1,
+          "maxItems": 6,
+          "items": { "$ref": "#/$defs/StageStepRow" }
+        },
+        "exitContract": { "type": "string", "minLength": 1 },
+        "stageValidation": { "type": "string", "minLength": 1 }
+      }
+    },
+
+    "StageStepRow": {
+      "type": "object",
+      "required": ["step", "action", "files", "command", "expected"],
+      "additionalProperties": false,
+      "properties": {
+        "step": { "type": "integer", "minimum": 1 },
+        "action": { "type": "string", "minLength": 1 },
+        "files": { "type": "string", "minLength": 1 },
+        "command": { "type": "string", "minLength": 1 },
+        "expected": { "type": "string", "minLength": 1 }
+      }
+    },
+
     "StepRow": {
       "type": "object",
       "required": ["step", "ticketId", "action", "files", "commandOrTest", "expectedOutcome"],
@@ -1080,6 +1181,22 @@
       }
     },
 
+    "StageSidecarEvidence": {
+      "type": "object",
+      "required": ["stageNumber", "stageTitle", "carryJson", "consumerRows"],
+      "additionalProperties": false,
+      "properties": {
+        "stageNumber": { "type": "integer", "minimum": 1 },
+        "stageTitle": { "type": "string", "minLength": 1 },
+        "carryJson": { "type": "string", "minLength": 1 },
+        "consumerRows": {
+          "type": "array",
+          "minItems": 1,
+          "items": { "type": "string", "minLength": 1 }
+        }
+      }
+    },
+
     "DependencyRow": {
       "type": "object",
       "required": ["id", "kind", "item", "impact", "mitigation"],

package/runtime/skills/okstra-coding-preflight/SKILL.md

@@ -62,6 +62,14 @@ If you suspect an overlay applies but the layout is non-standard, ask one questi
 - [ ] Existing code searched: `grep` for the symbol / file / identifier you are about to add. Do not duplicate.
 - [ ] Project conventions checked: `.editorconfig`, `CONTRIBUTING.md`, formatter config (`.prettierrc`, `rustfmt.toml`, `ktlint`, `google-java-format`, etc.). **Project rules override this skill on conflict.**
 
+## Completion sweep (before declaring a multi-file change done)
+
+Per-file checks miss cross-cutting issues; each commit can be individually clean while the sum violates DRY. Before saying "done":
+
+- [ ] **Domain-literal sweep:** `grep -rn` every domain enum value / predicate you added or touched in WHERE clauses, filters, or branches. The same literal at 2+ I/O sites is a *candidate* scattered decision — ask: would these sites change together when the business rule changes? Same decision → consolidate into one named constant or query builder in the domain layer and make every site reference it. Different decisions that merely share a value → leave them separate; coupling incidental duplication is worse than the repetition. (The identifier grep above does NOT catch this — sweep *values*, not just names.)
+- [ ] **Stand-alone name test for exports:** for each exported identifier, look at its siblings — can a caller pick the right one from the names alone? If a comment must explain which to use, the name fails; encode the distinguishing fact in it (e.g., the input shape: `parseRows` vs `parseRowsFromFlatItems`).
+- [ ] **No documented forks:** two deliberate variants of one capability must not survive as parallel implementations with a comment explaining the delta. Re-read both bodies and check the deltas are genuinely parametric: if they reduce to a few orthogonal options, collapse into one implementation taking explicit option parameters that encode them. If encoding the delta would take more than ~3 options, or add more branching than the duplication it removes, they are two capabilities — keep two implementations with distinct honest names and delete the "variant of" framing. Either way the comment-documented fork dies. "The divergence is documented" stays a refused rationalization, and a two-capabilities verdict must come from reading the bodies, not from reluctance to refactor.
+
 ## Boundaries
 
 - This skill does **not** auto-format. Run the project's formatter yourself.

package/runtime/skills/okstra-coding-preflight/clean-code.md

@@ -22,6 +22,11 @@ const sum = (arr) => arr.reduce((acc, x) => acc + x, 0);
 
 Caveat: do not extract until the duplication is real (rule of three). Premature abstraction is also a code smell.
 
+Two more forms of duplication that hide from symbol-level grep:
+
+- **Scattered domain literals** — the same enum value / predicate repeated across queries or filters *may* be one business decision duplicated. The test: would the sites change together when the rule changes? If yes, consolidate to a named constant or builder at a single reference point; if they merely share a value, leave them apart — coupling incidental duplication is worse than repetition.
+- **Documented forks** — two deliberate variants of one capability kept as parallel implementations "because the delta is commented". If the delta is genuinely parametric (a few orthogonal options), collapse into one implementation with explicit option parameters; if not, split into two distinctly named capabilities. The commented fork itself is never the end state.
+
 ## KISS — Keep It Simple
 
 The simplest solution that meets the requirement wins. Cleverness has a maintenance cost.
@@ -104,6 +109,7 @@ The test: if the name appeared in a stacktrace, an autocomplete list, or a grep
 - Generic verbs with no information: `handle`, `process`, `execute`, `doStuff`, `manage`. If the function deletes-then-inserts, name it `replace`, not `update`.
 - Constants that will collide with siblings later: `BUCKET` → `FONTS_BUCKET`, `TIMEOUT` → `HTTP_READ_TIMEOUT_MS`, `URL` → `AUTH_SERVICE_URL`.
 - Repository / port methods named after the rule they enforce, not the data they fetch: `findValid*` / `findActive*` / `findEligible*` — the adjective encodes a business rule the caller can't inspect from the name. Prefer `findDesktopLibrariesForUser(userId)` + a domain predicate applied by the caller.
+- Near-twin siblings a caller can't tell apart from the names alone (`parseRows` vs `parseRowsFromItems`): if a comment must explain which to pick, rename — encode the distinguishing fact (e.g., input shape: `parseRowsFromFlatItems`). Matching the existing sibling's style does not excuse the ambiguity.
 
 This rule applies most strongly to **names crossing module boundaries**: public methods, exported constants, port methods. Private helpers in a tight local scope get more slack.
 

package/runtime/skills/okstra-run/SKILL.md

@@ -120,7 +120,7 @@ That is the entire interactive flow. The wizard handles:
 
 - new-vs-existing task split, task-group / task-id slug validation,
 - task-type pick (with `nextRecommendedPhase` surfaced as recommended for existing tasks),
-- brief path (with `유지 / 변경` for existing tasks),
+- brief path after task-group selection (same-group `.okstra/briefs/<task-group>/**/*.md` candidates first, direct input last; `유지 / 변경` for existing tasks),
 - base-ref pick + git rev-parse validation (skipped when reusing an active worktree),
 - `implementation`-only sub-flow: approved-plan path (frontmatter `approved: true` check) + stage pick (`auto` = 의존성 충족된 가장 빠른 미완료 stage, 또는 특정 stage 번호) + executor pick,
 - `Use defaults / Customize` branch with profile-aware worker/model questions,

package/runtime/skills/okstra-run/templates/pr-body.template.md

@@ -17,25 +17,25 @@ okstra release-handoff 기본 PR 본문 템플릿.
   - `git log --oneline <base>..HEAD` 의 commit 범위
   - `git diff <base>..HEAD --stat` 의 변경 파일 통계
 
-빈 섹션은 그대로 두지 말고 통째로 삭제합니다. HTML 주석은 PR 생성 전에
-모두 제거됩니다.
 -->
 
-## Summary
+## **Please check if the PR fulfills these requirements**
+- [ ] Commits have a single intent
+- [ ] Tests for the changes have been added (for bug fixes / features)
+- [ ] I reviewed my own code
+- [ ] I tested the changes (if not, explain why in the "Other information" section)
+- [ ] Docs have been added / updated
 
-<!-- 1–3 bullets. 변경의 동기(WHY)와 결과(WHAT changed at a high level). -->
+## **What kind of change does this PR introduce?** (Bug fix, feature, docs update, ...)
 
-## Changes
 
-<!-- 영역별로 묶은 구체적 변경 목록. 파일/모듈 단위 그룹화 권장. -->
+## **What is the current behavior?** (You can also link to an open issue here)
 
-## Test plan
 
-<!-- 리뷰어가 따라 할 수 있는 검증 절차. 자동/수동 모두 가능. -->
+## **What is the new behavior (if this is a feature change)?**
 
-- [ ] <검증 항목>
-- [ ] <검증 항목>
 
-## Linked issues
+## **Does this PR introduce a breaking change?** (What changes might users need to make in their application due to this PR?)
 
-<!-- `Refs: TICKET-123`, `Closes #N`, 관련 PR 링크 등. 없으면 섹션 통째로 삭제. -->
+
+## **Other information**:

package/runtime/templates/reports/final-report.template.md

@@ -140,7 +140,7 @@ implementation-option: {{ frontmatter.implementationOption | yaml_scalar }}
 {% if header.taskType == 'implementation-planning' %}
 ## 5.5 Implementation Plan Deliverables
 
-### 5.5.1 Option Candidates{% if t("sectionAside.optionCandidates") != "Option Candidates" %} ({{ t("sectionAside.optionCandidates") }}){% endif %}
+### Option Candidates{% if t("sectionAside.optionCandidates") != "Option Candidates" %} ({{ t("sectionAside.optionCandidates") }}){% endif %}
 
 {% for opt in implementationPlanning.optionCandidates %}
 **{{ opt.name }}**
@@ -158,7 +158,7 @@ implementation-option: {{ frontmatter.implementationOption | yaml_scalar }}
 
 {% endfor %}
 
-### 5.5.2 Trade-off Matrix{% if t("sectionAside.tradeOffMatrix") != "Trade-off Matrix" %} ({{ t("sectionAside.tradeOffMatrix") }}){% endif %}
+### Trade-off Matrix{% if t("sectionAside.tradeOffMatrix") != "Trade-off Matrix" %} ({{ t("sectionAside.tradeOffMatrix") }}){% endif %}
 
 | Option | Complexity | Risk | Reversibility | Test Coverage Cost | Rollout Cost |
 |--------|-----------|------|---------------|--------------------|--------------|
@@ -166,7 +166,7 @@ implementation-option: {{ frontmatter.implementationOption | yaml_scalar }}
 | {{ row.option }} | {{ row.complexity }} | {{ row.risk }} | {{ row.reversibility }} | {{ row.testCoverageCost }} | {{ row.rolloutCost }} |
 {% endfor %}
 
-### 5.5.3 Recommended Option{% if t("sectionAside.recommendedOption") != "Recommended Option" %} ({{ t("sectionAside.recommendedOption") }}){% endif %}
+### Recommended Option{% if t("sectionAside.recommendedOption") != "Recommended Option" %} ({{ t("sectionAside.recommendedOption") }}){% endif %}
 
 | {{ t("implementationPlanning.recommendedTableHeaderLabel") }} | {{ t("implementationPlanning.recommendedTableHeaderValue") }} |
 |------|----|
@@ -175,15 +175,7 @@ implementation-option: {{ frontmatter.implementationOption | yaml_scalar }}
 | {{ t("implementationPlanning.rationaleLabel") }} | {{ implementationPlanning.recommendedOption.rationale }} |
 | {{ t("implementationPlanning.rejectedSummaryLabel") }} | {{ implementationPlanning.recommendedOption.rejectedSummary }} |
 
-### 5.5.4 Stepwise Execution Order{% if t("sectionAside.stepwiseExecutionOrder") != "Stepwise Execution Order" %} ({{ t("sectionAside.stepwiseExecutionOrder") }}){% endif %}
-
-| Step | Ticket ID | Action (≤ 5min) | Files | Command / Test | Expected outcome |
-|------|-----------|------------------|-------|----------------|-------------------|
-{% for row in implementationPlanning.stepwiseExecution -%}
-| {{ row.step }} | `{{ row.ticketId }}` | {{ row.action }} | `{{ row.files }}` | `{{ row.commandOrTest }}` | {{ row.expectedOutcome }} |
-{% endfor %}
-
-### 5.5.5 Dependency / Migration Risk{% if t("sectionAside.dependencyRisk") != "Dependency / Migration Risk" %} ({{ t("sectionAside.dependencyRisk") }}){% endif %}
+### Dependency / Migration Risk{% if t("sectionAside.dependencyRisk") != "Dependency / Migration Risk" %} ({{ t("sectionAside.dependencyRisk") }}){% endif %}
 
 {% if implementationPlanning.dependencyMigrationRisk | length == 0 -%}
 {{ t("emptyState.dependencyRisk") }}
@@ -195,7 +187,7 @@ implementation-option: {{ frontmatter.implementationOption | yaml_scalar }}
 {% endfor %}
 {%- endif %}
 
-### 5.5.6 Validation Checklist{% if t("sectionAside.validationChecklist") != "Validation Checklist" %} ({{ t("sectionAside.validationChecklist") }}){% endif %}
+### Validation Checklist{% if t("sectionAside.validationChecklist") != "Validation Checklist" %} ({{ t("sectionAside.validationChecklist") }}){% endif %}
 
 | Phase | Ticket ID | Check | Command / Observation | Expected outcome |
 |-------|-----------|-------|------------------------|-------------------|
@@ -203,7 +195,7 @@ implementation-option: {{ frontmatter.implementationOption | yaml_scalar }}
 | {{ row.phase }} | `{{ row.ticketId }}` | {{ row.check }} | `{{ row.commandOrObservation }}` | {{ row.expectedOutcome }} |
 {% endfor %}
 
-### 5.5.7 Rollback Strategy{% if t("sectionAside.rollbackStrategy") != "Rollback Strategy" %} ({{ t("sectionAside.rollbackStrategy") }}){% endif %}
+### Rollback Strategy{% if t("sectionAside.rollbackStrategy") != "Rollback Strategy" %} ({{ t("sectionAside.rollbackStrategy") }}){% endif %}
 
 | ID | Step | Action | Trigger signal | {{ t("columns.checkMethod") }} |
 |----|------|--------|----------------|-----------|
@@ -211,7 +203,7 @@ implementation-option: {{ frontmatter.implementationOption | yaml_scalar }}
 | {{ row.id }} | {{ row.step }} | `{{ row.action }}` | {{ row.triggerSignal }} | `{{ row.verificationMethod }}` |
 {% endfor %}
 
-### 5.5.8 Requirement Coverage
+### Requirement Coverage
 
 | ID | Source | Requirement | Covered by option / stage / step | Status |
 |----|--------|-------------|-----------------------------------|--------|
@@ -219,6 +211,45 @@ implementation-option: {{ frontmatter.implementationOption | yaml_scalar }}
 | {{ row.id }} | `{{ row.source }}` | {{ row.requirement }} | {{ row.coveredBy }} | `{{ row.status }}` |
 {% endfor %}
 
+## 5.5 Stage Map
+
+| stage | title | depends-on | step-count | exit-contract-summary |
+|-------|-------|------------|------------|-----------------------|
+{% for row in implementationPlanning.stageMap -%}
+| {{ row.stage }} | {{ row.title }} | {{ row.dependsOn }} | {{ row.stepCount }} | {{ row.exitContractSummary }} |
+{% endfor %}
+
+{% for stage in implementationPlanning.stages %}
+## 5.5.{{ stage.stage }} Stage {{ stage.stage }}: {{ stage.title }}
+
+Slice value: {{ stage.sliceValue }}
+Acceptance: {{ stage.acceptance }}
+{% if stage.conformanceTests %}Conformance tests: stage-{{ stage.stage }} — {{ stage.conformanceTests }}
+{% else %}Conformance exemption: {{ stage.conformanceExemption }}
+{% endif %}{% if stage.tddExemption %}TDD exemption: {{ stage.tddExemption }}
+{% endif %}
+### Carry-In
+
+{{ stage.carryIn }}
+
+### Stepwise Execution Order
+
+| step | action | files | command | expected |
+|------|--------|-------|---------|----------|
+{% for row in stage.stepwiseExecution -%}
+| {{ row.step }} | {{ row.action }} | `{{ row.files }}` | `{{ row.command }}` | {{ row.expected }} |
+{% endfor %}
+
+### Stage Exit Contract
+
+{{ stage.exitContract }}
+
+### Stage Validation
+
+{{ stage.stageValidation }}
+
+{% endfor %}
+
 ### 5.5.9 Plan Body Verification{% if t("sectionAside.planBodyVerification") != "Plan Body Verification" %} ({{ t("sectionAside.planBodyVerification") }}){% endif %}
 
 {{ t("sectionIntro.planBodyVerification") }}
@@ -271,6 +302,7 @@ implementation-option: {{ frontmatter.implementationOption | yaml_scalar }}
 |---------|-----------|--------------------|--------------------|
 | H1 | {{ t("releaseHandoff.h1Body") }} | `{{ releaseHandoff.userSelections.h1 }}` | `local only` / `push + PR` / `skip` |
 | H2 | {{ t("releaseHandoff.h2Body") }} | `{{ releaseHandoff.userSelections.h2 or t("releaseHandoff.h2DefaultLabel") }}` | {{ t("releaseHandoff.h2OptionsLabel") }} |
+| H2b | Merge conflict probe | `{{ releaseHandoff.userSelections.h2b or releaseHandoff.mergeConflictProbe.kind }}` | `not-run` / `clean` / `proceed anyway` / `change base branch` / `cancel` |
 | H3 | {{ t("releaseHandoff.h3Body") }} | `{{ releaseHandoff.userSelections.h3 }}` | `use as-is` / `edit then proceed` / `cancel` |
 
 ### 5.6.4 Executed Commands
@@ -371,7 +403,19 @@ implementation-option: {{ frontmatter.implementationOption | yaml_scalar }}
 {% endfor %}
 {%- endif %}
 
-### 5.7.5 Validation Evidence
+### 5.7.5 Stage Sidecar Evidence
+
+- Stage: `{{ implementation.stageSidecarEvidence.stageNumber }}` — {{ implementation.stageSidecarEvidence.stageTitle }}
+- Carry sidecar JSON:
+  ```json
+  {{ implementation.stageSidecarEvidence.carryJson }}
+  ```
+- Appended `consumers.jsonl` rows:
+{% for row in implementation.stageSidecarEvidence.consumerRows -%}
+  > {{ row }}
+{% endfor %}
+
+### 5.7.6 Validation Evidence
 
 | Phase | Command | Exit code | Output tail | TDD evidence |
 |-------|---------|-----------|-------------|--------------|
@@ -379,7 +423,7 @@ implementation-option: {{ frontmatter.implementationOption | yaml_scalar }}
 | {{ row.phase }} | `{{ row.command }}` | `{{ row.exitCode }}` | {{ row.outputTail }} | {{ row.tddEvidence or '--' }} |
 {% endfor %}
 
-### 5.7.6 Verifier Results
+### 5.7.7 Verifier Results
 
 {% for block in implementation.verifierResults %}
 - **{{ block.verifier }}** — Verdict: `{{ block.verdict }}`
@@ -390,7 +434,7 @@ implementation-option: {{ frontmatter.implementationOption | yaml_scalar }}
   - Discrepancy: {{ block.discrepancy or t("emptyState.discrepancy") }}
 {% endfor %}
 
-### 5.7.7 Rollback Verification
+### 5.7.8 Rollback Verification
 
 | Category | Rollback command | Verification | Result |
 |----------|-------------------|---------------|--------|
@@ -398,7 +442,7 @@ implementation-option: {{ frontmatter.implementationOption | yaml_scalar }}
 | {{ row.category }} | `{{ row.rollbackCommand }}` | {{ row.verification }} | `{{ row.result }}` |
 {% endfor %}
 
-### 5.7.8 Routing Recommendation
+### 5.7.9 Routing Recommendation
 
 {{ implementation.routingRecommendation }}
 

package/runtime/templates/reports/i18n/en.json

@@ -105,7 +105,7 @@
     "h2Body": "PR base branch (when H1 = `push + PR`)",
     "h3Body": "How should the PR title/body draft be handled?",
     "h2DefaultLabel": "(n/a)",
-    "h2OptionsLabel": "staging / preprod / prod / main / dev / user input",
+    "h2OptionsLabel": "staging / preprod / main / user input",
     "noMutationNote": "(no mutating command — H1=`skip` or H3=`cancel`)",
     "commandsTableHeader": {
       "outputSummary": "stdout/stderr summary"

package/runtime/templates/reports/i18n/ko.json

@@ -105,7 +105,7 @@
     "h2Body": "PR base 브랜치 (H1=`push + PR` 인 경우)",
     "h3Body": "PR title/body 초안 처리",
     "h2DefaultLabel": "(n/a)",
-    "h2OptionsLabel": "staging / preprod / prod / main / dev / 사용자 입력",
+    "h2OptionsLabel": "staging / preprod / main / 사용자 입력",
     "noMutationNote": "(mutating 명령 미실행 — H1=`skip` 또는 H3=`cancel`)",
     "commandsTableHeader": {
       "outputSummary": "stdout/stderr 요약"

package/runtime/templates/reports/implementation-input.template.md

@@ -27,7 +27,7 @@ taskType: "{{FM_TASK_TYPE}}"
 ## Approved Plan Reference (mandatory)
 
 - Approved plan path: `runs/implementation-planning/<run-id>/reports/final-report.md`
-- Approval evidence (quoted exactly from the plan's `User Approval Request` resolution):
+- Approval evidence (quoted exactly from the plan's YAML frontmatter, e.g. `approved: true`):
 - Recommended option name selected from the plan:
 - Plan's bite-sized step list (paste or reference by anchor):
 

package/runtime/templates/reports/implementation-planning-input.template.md

@@ -89,12 +89,12 @@ The final report of an `implementation-planning` run MUST contain every section
 1. **Option Candidates** — at least two viable options, each with the exact list of files to create or modify and the principal change per file.
 2. **Trade-off Matrix** — comparison of the candidates across complexity, risk, reversibility, performance impact, scope, and required test surface.
 3. **Recommended Option** — selected option with explicit rationale referencing the trade-off matrix.
-4. **Stepwise Execution Order** — ordered steps where each step is independently verifiable; each step lists the files it touches and the test/command that proves it works.
+4. **Stage Map** — `## 5.5 Stage Map` plus one `## 5.5.<i> Stage <i>:` section per stage. Each stage is a thin vertical slice with `Slice value:`, `Acceptance:`, `Conformance tests:` or `Conformance exemption:`, the four required subsections, and a RED/GREEN step order unless a `TDD exemption:` line applies.
 5. **Dependency and Migration Risk** — schema, data, ordering, feature-flag, and cross-service risks that the recommended option introduces.
 6. **Validation Checklist** — pre-execution, mid-execution, and post-execution checks (commands, expected outputs, observability points).
 7. **Rollback Strategy** — exact reverse procedure or compensating action for each significant step.
 8. **Scope Boundary** — an explicit list of adjacent areas, files, refactors, or quality improvements that this plan **does NOT** cover, each with a one-line reason (deferred, separate owner, separate decision, out of requirement). Any item the analysers were tempted to fold in but chose to exclude MUST appear here. An empty list is allowed only when the analysers explicitly state "no adjacent expansion was considered" — silence is not acceptable.
-9. **User Approval Request** — a labelled block stating that the plan is awaiting explicit user approval. The next `implementation` run MUST NOT begin until the user has replied with explicit approval to this block.
+9. **Approval frontmatter** — the final report's YAML frontmatter MUST emit `approved: false` and `implementation-option:`. Do NOT create a `User Approval Request` body block; the next `implementation` run reads only the frontmatter gate.
 
 ## Phase Boundary
 
@@ -108,7 +108,7 @@ The final report of an `implementation-planning` run MUST contain every section
 
 ## Stage Output Shape (reference)
 
-This run's final report MUST emit `## 5.5 Stage Map` and `## 5.5.<i> Stage <i>` sections per the implementation-planning profile §"Required deliverable shape". Two illustrative shapes:
+This run's final report MUST emit `## 5.5 Stage Map` and `## 5.5.<i> Stage <i>` sections per the implementation-planning profile §"Required deliverable shape". Two illustrative Stage Map tables:
 
 ### Shape A — single stage (small work)
 | stage | title | depends-on | step-count | exit-contract-summary |

package/runtime/validators/validate-run.py

@@ -991,6 +991,7 @@ PLANNING_REQUIRED_SECTIONS = (
     "Option Candidates",
     "Trade-off",
     "Recommended Option",
+    "Stage Map",
     "Stepwise Execution Order",
     "Dependency",
     "Validation Checklist",
@@ -1005,6 +1006,7 @@ IMPLEMENTATION_REQUIRED_SECTIONS = (
     "Commit List",
     "Diff Summary",
     "Out-of-plan Edits",
+    "Stage Sidecar Evidence",
     "Validation Evidence",
     "Verifier Results",
     "Rollback Verification",