okstra 0.58.0 → 0.60.0

package/docs/kr/architecture.md

@@ -239,7 +239,7 @@ per-process 환경 변수에 task 정체성·경로·workflow 상태를 보관
 - standard workflow의 기본 worker role은 `Claude worker`, `Codex worker`, `Report writer worker`이며, `Gemini worker`는 `--workers` 또는 프로필에서 명시할 때만 포함되는 옵션입니다.
 - worker 역할 분담과 최종 판단은 Claude가 task bundle을 읽고 수행합니다.
 - 사용자 홈에 설치된 okstra Claude assets(`~/.claude/skills`, `~/.claude/agents`) 는 Agent Teams 를 우선 시도하고, 팀 구성이 불가능할 때만 sequential/background fallback 을 사용하도록 Claude 를 유도합니다.
-- **팀 lifecycle**: lead 는 Phase 3 에서 `TeamCreate(team_name: "okstra-<task-key>")` 로 팀을 만들고 워커를 그 멤버로 dispatch 합니다. run 종료 시(Phase 7 토큰 집계 **이후**, 자동·무프롬프트) lead 는 팀 config 의 멤버에게 `SendMessage({type: "shutdown_request"})` 로 graceful 종료를 보낸 뒤 `TeamDelete` 로 팀을 해제합니다 — `TeamDelete` 는 active member 가 남아 있으면 실패하므로 종료 확인 후 호출하며, `~/.claude/teams/<team>/`·`~/.claude/tasks/<team>/` 만 지우고 토큰 집계 소스인 `~/.claude/projects/` jsonl 은 보존합니다. teardown 이 없으면 worker teammate 가 FleetView roster 에 계속 누적됩니다 (`prompts/profiles/_common-contract.md` 의 *Run-end team teardown*). no-`team_name` fallback 에서는 팀이 없으므로 silent-skip.
+- **팀 lifecycle**: lead 는 Phase 3 에서 `TeamCreate(team_name: "okstra-<task-key>")` 로 팀을 만들고 워커를 그 멤버로 dispatch 합니다. run 종료 시 Phase 7 토큰 집계 이후 먼저 잔여 tmux pane 을 사용자에게 보여 주고 닫을지 확인한 뒤, Teams mode 에서만 worker teammate 팀 `okstra-<task-key>` 을 해제할지 다시 확인합니다. 사용자가 승인하면 `okstra-team-reconcile.sh` 로 dead-pane stale-active 멤버를 정리하고 `TeamDelete` 로 팀을 해제합니다. `TeamDelete` 는 `~/.claude/teams/<team>/`·`~/.claude/tasks/<team>/` 만 지우고 토큰 집계 소스인 `~/.claude/projects/` jsonl 은 보존합니다. 사용자가 유지하거나 teardown 이 실패하면 worker teammate 가 FleetView roster 에 남으며, lead 는 Teams/FleetView 에서 해당 team 을 삭제하라고 안내합니다 (`prompts/profiles/_common-contract.md` 의 *Run-end teammate teardown*). no-`team_name` fallback 에서는 팀이 없으므로 silent-skip.
 
 ## Claude prompt contract
 
@@ -913,7 +913,7 @@ Phase 7 step 1.5 가 final-report MD 한 본을 입력으로 두 view 를 결정
 - tmux 가 reachable 한 lead 환경이면 wrapper 가 sibling pane 을 자동 분할해 `tail -F <log-path>` 를 띄웁니다. trace pane title 은 caller (worker) pane title 에 `-tail` 을 붙인 `<cli>-<role>-<pid>-tail` (e.g. `codex-worker-93421-tail`); 동일 시점에 caller (worker) pane title 은 `<cli>-<role>-<pid>` 로 셋팅됩니다. `<pid>` 는 wrapper 자기 자신의 PID 라서 동일 role 의 worker 가 둘 이상 동시에 spawn 돼도 서로 구분되고, 운영자는 `<caller> ↔ <caller>-tail` 로 시각적으로 매핑할 수 있습니다. **caller pane 해석** — Claude Code Bash tool 은 이제 `$TMUX` 와 `$TMUX_PANE` 를 둘 다 환경에서 제거하므로 env 변수에 의존하지 않습니다. wrapper 는 (1) prompt path 로부터 `<RUN_DIR>` (= `dirname(dirname(prompt_path))`, paths.py SSOT) 를 도출하고, (2) lead 가 자기 foreground pane 에서 1회 기록한 `<RUN_DIR>/state/lead-pane.id` 를 읽어 split anchor 로 씁니다 (background dispatch 에서도 신뢰 가능 — active-pane 추정과 달리 사용자가 pane 을 옮겨도 안전). 기록 파일이 없거나 pane 이 stale 이면 `tmux display-message -p '#{pane_id}'` (active pane) 으로 fallback. trace pane split 은 그 caller pane 을 `-t` 로 명시 anchor 합니다. role 은 wrapper 의 5번째 optional positional 인자이며, 누락 시 기본값 `worker`. caller pane title 은 capture 해두고 EXIT trap 에서 복원하므로 dispatch 사이의 stale title 이 남지 않습니다. focus 는 caller pane 으로 복귀하고, CLI 종료 후 pane 은 유지돼 스크롤백 가능. tmux 미reachable, split 실패, 구버전 tmux 등 모든 경로는 silent degrade.
 - **run-scoped 태깅으로 정리**: trace pane 의 `tail -F` 는 tmux 셸의 자식이라 Claude 가 종료돼도 살아남습니다. wrapper 는 spawn 한 pane 을 `tmux set-option -p @okstra_trace_run=<RUN_DIR>` 로 태깅하고, `okstra-trace-cleanup.sh` 는 `tmux list-panes -a` 에서 그 태그로 pane 을 server-wide 발견해 `tmux kill-pane` 합니다. tmux env 변수·pane-id registry 없이 동작하며, run-scoped 태그라 동시에 도는 다른 okstra run 의 trace pane 을 죽이지 않습니다. cleanup 은 두 진입 형태를 가집니다 — lead 가 `--run-dir <RUN_DIR>` 로 호출(해당 run 의 trace + worker-agent pane 정리)하거나, `templates/reports/settings.template.json` 의 `hooks.SessionEnd` 가 `--reap` 로 호출(`$CLAUDE_PROJECT_DIR/.okstra/` 하위 태그를 가진 trace pane 일괄 정리; 단일 run-dir 이 없는 종료 시점용). tmux 가 없거나 stale pane id 인 경우 silent degrade.
 - **phase 전환 시 자동 정리 + worker-agent pane 포함**: `okstra-trace-cleanup.sh --run-dir <RUN_DIR>` 는 태깅된 trace pane 뿐 아니라 dispatch 된 서브에이전트가 점유하는 worker-agent pane(title `claude-worker` / `codex-worker` / `gemini-worker` / `report-writer-worker`)도 lead 세션(`tmux list-panes -s -t <lead-pane>`) 범위에서 title allowlist 로 식별해 닫습니다(worker-agent pane 은 harness 소유라 태깅 불가). 세션 scope 와 lead 자기 pane 제외는 `<RUN_DIR>/state/lead-pane.id` 로 결정되며, lead 자신의 pane 은 title 이 걸려도 절대 죽이지 않습니다. lead 는 새 phase 의 worker 를 dispatch 하기 직전(`PROGRESS: phase-5.5-convergence` / `phase-6-synthesis` 마커 직전) 이 스크립트를 `--run-dir` 로 호출해 이전 phase 의 pane 을 prompt 없이 정리합니다.
-- **Phase 종료 시 사용자 확인**: run 최종 종료 시점(마지막 단계)에 lead 가 `okstra-trace-cleanup.sh --list --run-dir <RUN_DIR>` 로 잔여 okstra pane(worker-agent + trace) 목록을 출력한 뒤 사용자에게 "모두 닫기 / 그대로 두기" 양자택일을 묻고 응답대로 처리합니다 (`prompts/profiles/_common-contract.md` 의 *Phase wrap-up* 항목). `<RUN_DIR>/state/lead-pane.id` 가 비어 있는(=tmux 밖) 환경에서는 단계 자체가 silent-skip. `--list` 모드는 pane 을 죽이지 않고 `<pane_id>\t<pane_title>` 만 출력하므로 사용자가 무엇이 닫힐지 시각적으로 확인할 수 있습니다.
+- **Phase 종료 시 사용자 확인**: run 최종 종료 시점(마지막 단계)에 lead 가 `okstra-trace-cleanup.sh --list --run-dir <RUN_DIR>` 로 잔여 okstra pane(worker-agent + trace) 목록을 출력한 뒤 사용자에게 "모두 닫기 / 그대로 두기" 양자택일을 묻고 응답대로 처리합니다 (`prompts/profiles/_common-contract.md` 의 *Phase wrap-up* 항목). 그 다음 Teams mode 인 경우 worker teammate 팀을 해제할지 별도로 묻고, 승인 시 `okstra-team-reconcile.sh` + `TeamDelete` 를 실행합니다. `<RUN_DIR>/state/lead-pane.id` 가 비어 있는(=tmux 밖) 환경에서는 pane 단계만 silent-skip 하며, teammate 단계는 team-state 의 `teamCreate.status` 로 판단합니다. `--list` 모드는 pane 을 죽이지 않고 `<pane_id>\t<pane_title>` 만 출력하므로 사용자가 무엇이 닫힐지 시각적으로 확인할 수 있습니다.
 - 디스크 누적은 `okstra-inspect logs` 흐름이 read-only 로 인벤토리 + cleanup 명령을 제안합니다 (실행은 사용자 copy-paste).
 
 ### Linked-worktree `.git/` write 권한 (codex / gemini)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "okstra",
-  "version": "0.58.0",
+  "version": "0.60.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.58.0",
-  "builtAt": "2026-06-08T17:51:22.479Z",
+  "package": "0.60.0",
+  "builtAt": "2026-06-09T03:55:13.411Z",
   "repoRoot": "/home/runner/work/okstra/okstra"
 }

package/runtime/agents/SKILL.md

@@ -44,7 +44,7 @@ This SKILL.md is the operating contract and phase index. Detailed procedures liv
 | 5.5 Convergence | Cross-verify findings across workers | `okstra-convergence` |
 | 5.6 Critic pass | (opt-in) reused-worker critic pass: coverage gaps (discovery/error-analysis/impl-planning) or acceptance devil's-advocate (final-verification), each verified one round | `okstra-convergence` "Coverage critic pass" / "Acceptance critic pass" |
 | 6. Synthesis | Dispatch Report writer worker, review draft. **For `implementation-planning`: then run the Phase 6 plan-body verification sub-step (see Phase 6 section below).** | `okstra-report-writer` + `okstra-convergence` (sub-step) |
-| 7. Persist | Run token-usage collector, update manifests, then disband the worker team (reconcile stale members + `TeamDelete`, after collection) | `okstra-report-writer` + `_common-contract.md` "Run-end team teardown" |
+| 7. Persist | Run token-usage collector, update manifests, ask about residual tmux panes, then ask whether to disband the worker team (reconcile stale members + `TeamDelete` only on approval) | `okstra-report-writer` + `_common-contract.md` "Phase wrap-up" / "Run-end teammate teardown" |
 
 ## Core operating contract
 
@@ -96,7 +96,7 @@ Required checkpoints:
 - `PROGRESS: phase-5.6-critic provider=<provider> gaps=<n>` — when the coverage critic pass runs (Phase 5.6, opt-in). Omitted when `convergence.critic.enabled == false`.
 - `PROGRESS: phase-6-synthesis dispatching report-writer-worker` — at the start of Phase 6.
 - `PROGRESS: phase-7-persist updating manifests` — at the start of Phase 7.
-- `PROGRESS: phase-7-teardown disbanding team` — after token-usage collection, immediately before reconciling stale members + `TeamDelete` (Teams mode only; see `_common-contract.md` "Run-end team teardown"). Skipped in the no-`team_name` fallback.
+- `PROGRESS: phase-7-teardown disbanding team` — after token-usage collection and after the pane-disposition prompt, only when the user approved worker teammate cleanup, immediately before reconciling stale members + `TeamDelete` (Teams mode only; see `_common-contract.md` "Run-end teammate teardown"). Skipped in the no-`team_name` fallback or when the user keeps the team.
 - `PROGRESS: complete final-report=<relative-path>` — final summary line, after all persistence.
 
 These lines are the only structured signal the user has during a long run. Do NOT replace them with prose ("Now I'm starting Phase 2..."), do NOT skip a checkpoint because "the previous message already said that", and do NOT batch multiple checkpoints into one. Each line stands alone so the user (or any operator scraping stdout) can timestamp it externally.

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

@@ -36,15 +36,7 @@ profile document.
   - okstra creates two kinds of tmux pane per run: (a) **worker-agent panes** the harness gives to dispatched subagents (titled `claude-worker` / `codex-worker` / `gemini-worker` / `report-writer-worker`), and (b) **trace panes** the codex/gemini wrappers spawn (`<cli>-<role>-<pid>-tail`). Both accumulate across internal phases because each new phase dispatches a fresh worker batch and the prior panes are never reclaimed.
   - When `<RUN_DIR>/state/lead-pane.id` is non-empty (the lead is in tmux), the lead MUST run `$HOME/.okstra/bin/okstra-trace-cleanup.sh --run-dir "<RUN_DIR>"` **immediately before** dispatching the next phase's workers — i.e. just before emitting each `PROGRESS: phase-5.5-convergence round=<N>` marker and just before `PROGRESS: phase-6-synthesis dispatching report-writer-worker`. This closes every prior-phase okstra pane (worker-agent + trace) for this run, while NEVER killing the lead's own pane.
   - This is **automatic and silent** — NO user prompt. Report it in one short line (e.g. `이전 phase okstra pane 3개 정리`) and proceed. It is silent-skipped when the lead is not in tmux; the lead MUST NOT fabricate a synthetic pane list in that case.
-- Run-end team teardown (shared — runs AFTER Phase 7 persistence/token collection, BEFORE the pane disposition step below):
-  - The lead created the worker team in Phase 3 (`TeamCreate(team_name: "okstra-<task-key>")`). Worker teammates are NOT reclaimed on their own — without an explicit teardown they linger in the FleetView roster across this and later runs in the session. The lead MUST release them once the run's work is done.
-  - This step is **automatic and silent** — NO user prompt (workers are idle sessions that have already delivered their results; there is nothing for the user to preserve). It runs only when team-state's `teamCreate.status == "ok"` (Teams mode was actually used); in the no-`team_name` fallback there is no team to delete, so silent-skip.
-  - Why a reconcile step exists: each worker clears its own `isActive` flag in `~/.claude/teams/<team>/config.json` when its `Agent()` dispatch returns, so by Phase 7 every worker is normally already inactive and `TeamDelete()` succeeds immediately. The one failure mode is a worker whose tmux pane died WITHOUT clearing the flag (e.g. killed mid-turn): it stays `isActive: true`, and `TeamDelete` then refuses the entire team with an "active members" error that no amount of re-sending `shutdown_request` can clear — the addressee is already gone. `okstra-team-reconcile.sh` deterministically flips exactly those dead-pane stale-active members to inactive (never a live-pane member, never the lead).
-  - Sequence (token-usage collection MUST already be complete — `TeamDelete` removes `~/.claude/teams/<team>/` + `~/.claude/tasks/<team>/` but NOT the `~/.claude/projects/` jsonls Phase 7 reads, yet the read MUST precede teardown):
-    1. Run `$HOME/.okstra/bin/okstra-team-reconcile.sh "okstra-<task-key>"` exactly once. It flips dead-pane stale-active members to inactive, and no-ops when tmux is unavailable or nothing is stale. Do NOT loop it.
-    2. Call `TeamDelete()` — the single synchronization point for teardown. If it STILL errors with an active-members message, one worker pane is genuinely still live (rare at Phase 7, since every `Agent()` dispatch has already returned): send that one member a structured `SendMessage(to: <name>, message: { type: "shutdown_request" })` — the `message` MUST be the object literal shown, NEVER a JSON string stuffed into a text field (a stringified payload is delivered as a plain message and the shutdown protocol never fires) — wait briefly, then retry `TeamDelete()` once and proceed regardless of the result. NEVER loop, never use `TaskStop` (teammates are not background tasks — `TaskStop` 404s on a member address), and never let teardown block run completion once the work and final report already exist.
-  - Report it in one short line (e.g. `stale 멤버 1명 정리 + 팀 해제`, or just `worker 팀 해제` when nothing was stale) and proceed. Emit `PROGRESS: phase-7-teardown disbanding team` immediately before step 1.
-- Phase wrap-up — okstra pane disposition (shared, MUST be the *last* step before returning control to the user):
+- Phase wrap-up — okstra pane disposition (shared, runs AFTER Phase 7 persistence/token collection and BEFORE teammate teardown):
   - At run end the only residual okstra panes are the LAST phase's (e.g. the `report-writer-worker` agent pane and any codex/gemini trace pane). `okstra-trace-cleanup.sh --list --run-dir "<RUN_DIR>"` returns one tab-separated `<pane_id>\t<pane_title>` line per residual okstra pane (worker-agent + trace) for this run.
   - When `<RUN_DIR>/state/lead-pane.id` is non-empty, after the final-report file has been written and the routing recommendation has been issued, the lead MUST run `$HOME/.okstra/bin/okstra-trace-cleanup.sh --list --run-dir "<RUN_DIR>"` exactly once. The output lists every residual okstra pane (worker-agent + trace) for this run, never the lead's own pane.
   - If the list is empty, skip the question — there is nothing to ask about (the phase-start resets above usually already cleared prior phases).
@@ -56,6 +48,18 @@ profile document.
   - On `아니오` / `n` / `keep` → leave the panes intact; remind the user that they will be cleaned up automatically when Claude `/exit` fires the `SessionEnd` hook (`--reap`).
   - The question MUST be a clean yes/no — do NOT offer "close some / keep some" partial answers, do NOT propose alternatives like "close only codex panes". The whole-set decision keeps the wrap-up predictable.
   - This step is mandatory for every phase (`requirements-discovery`, `error-analysis`, `implementation-planning`, `implementation`, `final-verification`, `release-handoff`). It is silent-skipped when `<RUN_DIR>/state/lead-pane.id` is empty/absent (lead running outside tmux); the lead MUST NOT fabricate a synthetic pane list in that case.
+- Run-end teammate teardown (shared — MUST run AFTER the pane disposition question and BEFORE `PROGRESS: complete`):
+  - The lead created the worker team in Phase 3 (`TeamCreate(team_name: "okstra-<task-key>")`). Worker teammates are NOT reclaimed on their own — without an explicit teardown they linger in the FleetView roster across this and later runs in the session.
+  - This step applies only when team-state's `teamCreate.status == "ok"` (Teams mode was actually used). In the no-`team_name` fallback there is no team to delete, so silent-skip.
+  - After the pane disposition step above, the lead MUST ask the user whether to disband the worker teammates. This is a strict binary choice:
+    > worker teammate 팀 `okstra-<task-key>` 을 해제할까요?
+    > (예) 팀원 정리 / (아니오) 그대로 두기
+  - On `아니오` / `n` / `keep` → do not call `TeamDelete()`. Tell the user that the team will remain visible in FleetView/Teams and can be removed later from the Teams UI, or by asking the lead in this thread to clean up `okstra-<task-key>`.
+  - On `예` / `y` / `cleanup` → emit `PROGRESS: phase-7-teardown disbanding team`, then run the sequence below. Token-usage collection MUST already be complete — `TeamDelete` removes `~/.claude/teams/<team>/` + `~/.claude/tasks/<team>/` but NOT the `~/.claude/projects/` jsonls Phase 7 reads, yet the read MUST precede teardown.
+    1. Run `$HOME/.okstra/bin/okstra-team-reconcile.sh "okstra-<task-key>"` exactly once. It flips dead-pane stale-active members to inactive, and no-ops when tmux is unavailable or nothing is stale. Do NOT loop it.
+    2. Call `TeamDelete()` — the single synchronization point for teammate teardown. If it errors with an active-members message, send each named active member a structured `SendMessage(to: <name>, message: { type: "shutdown_request" })` — the `message` MUST be the object literal shown, NEVER a JSON string stuffed into a text field — wait briefly, run `okstra-team-reconcile.sh` one more time, retry `TeamDelete()` once, and proceed regardless of the result. NEVER loop and never use `TaskStop` (teammates are not background tasks — `TaskStop` 404s on a member address).
+  - If `TeamDelete()` is unavailable in the current host, or teardown still fails after the single retry, do not pretend cleanup succeeded. Report the exact residual action instead: `Teams/FleetView 에서 team okstra-<task-key> 삭제`, and if tmux panes were kept earlier also show the pane command `$HOME/.okstra/bin/okstra-trace-cleanup.sh --run-dir "<RUN_DIR>"`.
+  - Report successful teardown in one short line (e.g. `worker teammate 팀 해제`, or `stale 멤버 1명 reconcile 후 팀 해제`) and proceed to the final `PROGRESS: complete ...` line.
 - Brief handoff contract (shared — applies whenever the run consumes a task brief produced by `okstra-brief`):
   - the brief is a **pre-discovery artifact**: it converts a domain-reporter's words (non-expert *or* developer) into expert-consumable form so this and later phases can run with zero fill-in questions to the operator. The brief is **not** authoritative on solution decisions; it is authoritative on the reporter's intent.
   - **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:
@@ -78,14 +82,21 @@ profile document.
   - Any decision in this run that contradicts the brief's `Source Material` must be raised back to the reporter via a `Clarification Items` row; it must NOT be silently overridden. Disagreement with the reporter is allowed only after the row is resolved.
   - This contract is the single authority on brief consumption. Phase-specific addenda may *tighten* these rules but may not relax them.
 - Clarification request policy (shared — applies whenever a profile uses `## 1. Clarification Items`):
-  - **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.
+  - **Canonical column schema (SSOT — must match `templates/reports/final-report.template.md` §1 exactly):** every `## 1. Clarification Items` table has exactly these 4 columns, in this order:
+    `| <record-meta> | Statement | Expected form | User input |` (the first header is the i18n `columns.recordMeta` label — `항목` / `Record`).
+    The five short fields (ID, Ticket ID, Kind, Blocks, Status) are stacked inside the single record-meta cell, one per line separated by `<br>`, in this fixed order (mirrors the §2.1 Primary-Evidence meta column):
+
+    ```
+    **<ID>**<br>Ticket: `<TicketId>`<br>Kind: `<Kind>`<br>Blocks: `<Blocks>`<br>Status: <Status>
+    ```
+
+    The labels `Ticket:` / `Kind:` / `Blocks:` / `Status:` stay English in every locale so the approval-gate parser (`clarification_items.parse_meta_cell`) reads them regardless of report language.
+    Profile-specific addenda may tighten cell content but MUST NOT add, remove, rename, or reorder columns, nor change the meta-cell field order. The `ID` is `C-NNN` (3-digit zero-padded), the `Status` ∈ `{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 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` `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.
+  - if a phase requires a recommended answer, alternatives, or an evidence-check note, encode it inside the existing 4-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, and do not break the merged record-meta cell back into separate 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.
   - if a clarification response was carried in for this run, render the conditional `## 0. Clarification Response Carried In From Previous Run` section (the template's `RENDER_IF` guard activates it), walk every `C-*` row of the prior report's `## 1. Clarification Items` table, reconcile each one against new evidence, and update its `Status` to `resolved` or `obsolete` before issuing the next decision/verdict. When no carry-in path was provided, omit the `## 0.` heading entirely — the validator fails reports that emit an empty Section 0 stub (e.g. "No prior clarification response was provided for this run.").
 - Verdict Card (shared — applies to every final-report regardless of profile):

package/runtime/python/okstra_ctl/clarification_items.py

@@ -26,7 +26,15 @@ from pathlib import Path
 from typing import Optional
 
 
-SECTION_HEADING_PATTERN = re.compile(r"^##\s+1\.\s+Clarification Items\s*$", re.MULTILINE)
+# The final-report renderer (render_final_report.py:_inject_anchors) appends a
+# ` <a id="slug"></a>` scroll anchor to every heading. The §1 slice MUST tolerate
+# that trailing anchor — otherwise `_section_1_slice` fails on every *rendered*
+# report, parse returns None, and the Blocks=approval approval gate is silently
+# bypassed (run.py:_validate_approved_plan soft-passes None).
+SECTION_HEADING_PATTERN = re.compile(
+    r'^##\s+1\.\s+Clarification Items\s*(?:<a id="[^"]+"></a>\s*)?$',
+    re.MULTILINE,
+)
 NEXT_TOP_LEVEL_HEADING_PATTERN = re.compile(r"^##\s+(?!1\.)", re.MULTILINE)
 
 
@@ -97,10 +105,55 @@ def _section_1_slice(report_text: str) -> Optional[str]:
     return rest[: end_match.start()] if end_match else rest
 
 
+_META_ID_RE = re.compile(r"([A-Za-z][A-Za-z0-9]*-\d+)")
+
+
+def _meta_field(cell: str, key: str) -> str:
+    """Extract a ``<key>: value`` field from a stacked §1 meta cell.
+
+    The §1 table collapses the short columns into one ``<br>``-delimited
+    metadata cell (``**C-101**<br>Ticket: `DEV-1`<br>Kind: `decision`<br>
+    Blocks: `approval`<br>Status: open``). Values may be backtick-wrapped.
+    """
+    m = re.search(
+        rf"{re.escape(key)}:\s*`?\s*([^`<|]+?)\s*`?\s*(?:<br\s*/?>|$)",
+        cell,
+        re.IGNORECASE,
+    )
+    return m.group(1).strip() if m else ""
+
+
+def _meta_id(cell: str) -> str:
+    """The bold headline ID of a §1 meta cell (the part before the first <br>)."""
+    headline = re.split(r"<br\s*/?>", cell, maxsplit=1)[0]
+    m = _META_ID_RE.search(headline)
+    return m.group(1) if m else ""
+
+
+def parse_meta_cell(cell: str) -> Optional[ClarificationItem]:
+    """Parse one §1 stacked meta cell into a ``ClarificationItem``, or ``None``
+    when the cell is not a §1 meta cell (no ``Blocks:``/``Status:`` markers —
+    e.g. a header or an unrelated table). Shared by the approval-gate parser
+    and the HTML view's form-attach pass so both read the cell identically.
+    """
+    raw_blocks = _meta_field(cell, "Blocks")
+    raw_status = _meta_field(cell, "Status")
+    if not (raw_blocks and raw_status):
+        return None
+    return ClarificationItem(
+        row_id=_meta_id(cell),
+        kind=_meta_field(cell, "Kind").lower(),
+        blocks=raw_blocks.lower(),
+        status=raw_status.lower(),
+        raw_blocks=raw_blocks,
+        raw_status=raw_status,
+    )
+
+
 def parse_clarification_items(report_text: str) -> Optional[list[ClarificationItem]]:
-    """Return the list of §1 rows. ``None`` means "no unified §1 table
-    detected" (legacy report or missing section) — caller must NOT treat
-    that as "table is empty".
+    """Return the list of §1 rows. ``None`` means "no §1 meta table detected"
+    (legacy report or missing section) — caller must NOT treat that as "table
+    is empty".
 
     An empty list ``[]`` means "table exists but has no data rows" (e.g.,
     just the ``- 추가 정보 요청 없음.`` placeholder); that IS a confident
@@ -111,30 +164,21 @@ def parse_clarification_items(report_text: str) -> Optional[list[ClarificationIt
         return None
 
     lines = section.splitlines()
-    # Locate the header row containing both `Blocks` and `Status` columns.
-    # We scan for the first table-shaped header line that includes both
-    # column names (case-insensitive); anything else (legacy 5.1 / 5.2
-    # tables, intro tables) is rejected.
+    # Locate the §1 data table by its header. The merged-meta layout collapses
+    # ID/Ticket/Kind/Blocks/Status into one metadata cell and keeps the
+    # English `Statement` + `User input` columns; detect on those two (any
+    # other table — intro, legacy 5.1/5.2 — is rejected by returning None).
     header_idx = -1
-    headers: list[str] = []
     for idx, line in enumerate(lines):
         if not line.lstrip().startswith("|"):
             continue
         cells = [c.lower() for c in _split_pipe_row(line)]
-        if "blocks" in cells and "status" in cells:
+        if "user input" in cells and any(c.startswith("statement") for c in cells):
             header_idx = idx
-            headers = cells
             break
     if header_idx < 0:
-        # Section heading present but no Blocks/Status header — legacy
-        # layout or schema not yet adopted.
         return None
 
-    blocks_col = headers.index("blocks")
-    status_col = headers.index("status")
-    id_col = headers.index("id") if "id" in headers else 0
-    kind_col = headers.index("kind") if "kind" in headers else None
-
     items: list[ClarificationItem] = []
     body_started = False
     for line in lines[header_idx + 1:]:
@@ -146,30 +190,13 @@ def parse_clarification_items(report_text: str) -> Optional[list[ClarificationIt
             body_started = True
             continue
         if not body_started:
-            # A second header (unlikely) or a malformed row before the
-            # separator — skip.
             continue
         cells = _split_pipe_row(line)
-        if max(blocks_col, status_col, id_col) >= len(cells):
-            # malformed row; skip rather than crash
+        if not cells:
             continue
-        raw_blocks = cells[blocks_col]
-        raw_status = cells[status_col]
-        row_id = cells[id_col]
-        kind = cells[kind_col] if kind_col is not None and kind_col < len(cells) else ""
-        # Treat template-placeholder rows (e.g. literal ``C-001`` with
-        # angle-bracket sample text) as still-real rows but caller can
-        # filter on raw_id == "C-001" if needed.
-        items.append(
-            ClarificationItem(
-                row_id=row_id,
-                kind=kind.lower(),
-                blocks=raw_blocks.lower(),
-                status=raw_status.lower(),
-                raw_blocks=raw_blocks,
-                raw_status=raw_status,
-            )
-        )
+        item = parse_meta_cell(cells[0])
+        if item is not None:
+            items.append(item)
     return items
 
 
@@ -191,3 +218,25 @@ def unresolved_approval_blockers(report_text: str) -> Optional[list[Clarificatio
         it for it in items
         if it.blocks == "approval" and it.status in UNRESOLVED_STATUSES
     ]
+
+
+# 느슨한 §1 헤딩 탐지: 엄격한 SECTION_HEADING_PATTERN 이 실패해도 이게 매칭되면
+# "§1 헤딩은 있는데 형태가 어긋나 파싱에 실패" 한 상태다. trailing 부분을 보지
+# 않으므로 앵커 변형·수동 편집·미래 렌더 변경 어디서든 헤딩의 존재만 잡는다.
+_LOOSE_SECTION_1_RE = re.compile(r"^##\s+1\.\s+Clarification Items\b", re.MULTILINE)
+
+
+def section_1_present_but_unparsed(report_text: str) -> bool:
+    """§1 헤딩이 느슨 탐지엔 잡히지만 엄격 SECTION_HEADING_PATTERN 에는 매칭하지
+    못하는 경우 True — 헤딩 형태가 어긋나(앵커·포맷 drift) §1 슬라이스 자체가
+    실패하는 상태다.
+
+    이때 ``_section_1_slice`` 가 None 을 반환해 parse 가 통째로 None 이 되고 승인
+    게이트가 "schema 없음 → soft-pass" 로 조용히 열린다. §1 앵커 버그가 정확히 이
+    메커니즘으로 터졌다. 헤딩 자체가 없는 legacy 리포트(둘 다 불매칭)와, 엄격
+    매칭에 성공하는 정상 헤딩(테이블이 없는 emptyState placeholder 포함)은 False —
+    placeholder 는 헤딩이 멀쩡하므로 fail-closed 로 오인하지 않는다. 정규식만 넓혀 온
+    과거 수정과 달리, 이 판별은 "헤딩 형태 drift" 자체를 차단해 재발 클래스를 닫는다."""
+    if SECTION_HEADING_PATTERN.search(report_text):
+        return False
+    return bool(_LOOSE_SECTION_1_RE.search(report_text))

package/runtime/python/okstra_ctl/render_final_report.py

@@ -50,6 +50,7 @@ from jinja2 import ChainableUndefined, Environment, FileSystemLoader
 
 from okstra_ctl.final_report_schema import SchemaError, load_schema, validate as schema_validate
 from okstra_ctl.i18n import I18nError, SUPPORTED_LANGS, load_dictionary, make_jinja_global
+from okstra_ctl.models import UnknownModelError, resolve_model_metadata
 
 
 DEFAULT_TEMPLATE_REL = ("templates", "reports", "final-report.template.md")
@@ -351,6 +352,44 @@ def _enforce_schema(data: dict) -> None:
         )
 
 
+# 일반 alias('opus'/'sonnet'/'haiku')가 런타임에 해소되는, okstra 가 아는 최신
+# 구체버전 — final-report '표시 전용'. 실행 인자(execution value)는 바꾸지 않으며
+# (여전히 'opus' 가 `claude --model` 로 전달됨), 이 매핑은 보고서에서 "어느
+# 구체버전 계열로 돌았는지" 가독성만 준다. CLI 가 실제 고른 버전과 다를 수
+# 있으나 표시이므로 실행에는 무해하다. 새 버전이 나오면 여기만 갱신한다.
+_DISPLAY_CONCRETE_CLAUDE = {
+    "opus": "claude-opus-4-7",
+    "sonnet": "claude-sonnet-4-6",
+    "haiku": "claude-haiku-4-5",
+}
+
+
+def _model_detail(display: Any) -> str:
+    """모델 display alias(예: 'opus')를 'opus (claude-opus-4-7)' 형태로 상세화한다.
+
+    lead·report-writer 헤더 모델은 항상 claude provider 다. 구체 alias('opus-4-7'
+    등)는 claude 매핑의 실행 ID 를, 일반 alias('opus' 등)는 표시 전용
+    `_DISPLAY_CONCRETE_CLAUDE` 의 권장 구체버전을 병기한다. 어느 쪽에도 없는 값
+    (이미 실행 ID 이거나 'default' 등)은 원본을 그대로 돌려준다. 바깥 백틱은
+    템플릿이 감싸므로 여기서는 넣지 않는다."""
+    text = str(display or "").strip()
+    if not text:
+        return text
+    try:
+        meta = resolve_model_metadata(
+            provider="claude", raw_value=text,
+            default_display=text, default_execution="",
+        )
+    except UnknownModelError:
+        meta = None
+    if meta and meta.execution and meta.execution != text:
+        return f"{text} ({meta.execution})"
+    concrete = _DISPLAY_CONCRETE_CLAUDE.get(text.lower())
+    if concrete:
+        return f"{text} ({concrete})"
+    return text
+
+
 def _build_environment(template_dir: Path) -> Environment:
     # ChainableUndefined lets optional fields (e.g.
     # ``clarificationCarryIn``, ``ticketCoverage.omit``) silently evaluate
@@ -370,6 +409,7 @@ def _build_environment(template_dir: Path) -> Environment:
     env.filters["format_duration_ms"] = _format_duration_ms
     env.filters["yaml_scalar"] = _yaml_scalar
     env.filters["yaml_inline_list"] = _yaml_inline_list
+    env.filters["model_detail"] = _model_detail
     return env
 
 

package/runtime/python/okstra_ctl/report_views.py

@@ -60,6 +60,7 @@ from .clarification_items import (
     _section_1_slice,
     _split_pipe_row,
     parse_clarification_items,
+    parse_meta_cell,
 )
 
 
@@ -319,16 +320,16 @@ def _emit_table(lines: list[str], start: int, section_path: list[str]) -> tuple[
         rows.append(_split_pipe_row(lines[i]))
         i += 1
 
-    grouped_spec = _grouped_table_spec(header_cells, section_path)
-    if grouped_spec is not None:
-        return _emit_grouped_table(header_cells, rows, grouped_spec), i - start
-
+    # §1 Clarification Items is the only interactive table. Its short columns
+    # are collapsed into one stacked meta cell (`**C-101**<br>Ticket: …<br>
+    # Kind: …<br>Blocks: …<br>Status: …`) in the markdown; the HTML view
+    # re-attaches a form widget to the `User input` column by re-parsing that
+    # meta cell (the SAME parser the approval gate uses).
     is_clarification_table = (
         not _section_forbids_form(section_path)
         and any("Clarification Items" in h for h in section_path)
-        and "ID" in header_cells
-        and "Blocks" in header_cells
-        and "Status" in header_cells
+        and "User input" in header_cells
+        and any(h.startswith("Statement") for h in header_cells)
     )
 
     narrow_cols = _narrow_columns(header_cells, rows)
@@ -348,47 +349,38 @@ def _emit_table(lines: list[str], start: int, section_path: list[str]) -> tuple[
         + "</tr></thead>"
     )
 
-    body_rows: list[str] = []
-    id_col = header_cells.index("ID") if "ID" in header_cells else -1
-    kind_col = header_cells.index("Kind") if "Kind" in header_cells else -1
-    status_col = header_cells.index("Status") if "Status" in header_cells else -1
     statement_col = next(
-        (i for i, h in enumerate(header_cells) if h.startswith("Statement")),
+        (j for j, h in enumerate(header_cells) if h.startswith("Statement")),
         -1,
     )
     user_input_col = (
         header_cells.index("User input") if "User input" in header_cells else -1
     )
+    body_rows: list[str] = []
     for row in rows:
+        meta = parse_meta_cell(row[0]) if (is_clarification_table and row) else None
         if (
-            is_clarification_table
-            and id_col >= 0
-            and id_col < len(row)
-            and re.fullmatch(r"C-\d+", row[id_col])
+            meta is not None
+            and re.fullmatch(r"C-\d+", meta.row_id)
             and user_input_col >= 0
         ):
-            response_id = row[id_col]
-            kind = row[kind_col] if 0 <= kind_col < len(row) else ""
-            status = row[status_col] if 0 <= status_col < len(row) else ""
             statement = (
-                row[statement_col]
-                if 0 <= statement_col < len(row)
-                else ""
+                row[statement_col] if 0 <= statement_col < len(row) else ""
             )
             cells_html: list[str] = []
             for idx, cell in enumerate(row):
                 if idx == user_input_col:
                     cells_html.append(
-                        f"<td>{_form_control(response_id, kind, status, cell, statement)}</td>"
+                        f"<td>{_form_control(meta.row_id, meta.kind, meta.status, cell, statement)}</td>"
                     )
                 else:
                     cells_html.append(
                         f"<td{_col_class(idx, narrow_cols)}>{_inline(cell)}</td>"
                     )
             body_rows.append(
-                f'<tr data-response-id="{html.escape(response_id)}" '
-                f'data-kind="{html.escape(kind)}" '
-                f'data-status="{html.escape(status)}">'
+                f'<tr data-response-id="{html.escape(meta.row_id)}" '
+                f'data-kind="{html.escape(meta.kind)}" '
+                f'data-status="{html.escape(meta.status)}">'
                 + "".join(cells_html)
                 + "</tr>"
             )
@@ -406,155 +398,6 @@ def _emit_table(lines: list[str], start: int, section_path: list[str]) -> tuple[
     return f"<table>{head}{body}</table>", i - start
 
 
-@dataclass(frozen=True)
-class _GroupedSpec:
-    """Plan for rendering a wide table as a compact grouped layout: the
-    short columns (``group_cols``) collapse into one stacked ``key:
-    value`` metadata cell led by ``headline_col``; the long columns
-    (``wide_cols``) each keep their own min-width column.
-
-    ``kind == "clarification"`` additionally re-attaches the §1 form
-    widget to the ``user_input_col`` cell and the ``data-*`` row attrs."""
-    headline_col: int
-    group_cols: tuple[int, ...]
-    wide_cols: tuple[int, ...]
-    kind: str  # "plain" | "clarification"
-    id_col: int = -1
-    kind_col: int = -1
-    status_col: int = -1
-    statement_col: int = -1
-    user_input_col: int = -1
-
-
-def _grouped_table_spec(
-    header_cells: list[str], section_path: list[str]
-) -> Optional[_GroupedSpec]:
-    """Only §1 Clarification Items is grouped in the HTML view (it keeps the
-    interactive form and stays flat in the .md). All other narrative tables are
-    already rendered compactly by the template, so no grouping is applied here."""
-    norm = [h.strip() for h in header_cells]
-
-    def _spec(headline: int, wide: tuple[int, ...], **kw) -> _GroupedSpec:
-        wide_set = set(wide)
-        group = tuple(c for c in range(len(norm)) if c != headline and c not in wide_set)
-        return _GroupedSpec(headline_col=headline, group_cols=group, wide_cols=wide, **kw)
-
-    # §1 Clarification Items — keep the interactive form, and widen the three
-    # long-prose columns (Expected form is prose too, not a code column).
-    if (
-        any("Clarification Items" in h for h in section_path)
-        and not _section_forbids_form(section_path)
-        and "ID" in norm
-        and "User input" in norm
-        and any(h.startswith("Statement") for h in norm)
-    ):
-        statement_col = next(i for i, h in enumerate(norm) if h.startswith("Statement"))
-        user_input_col = norm.index("User input")
-        expected_col = next(
-            (i for i, h in enumerate(norm) if h.startswith("Expected form")), -1
-        )
-        wide_cols = tuple(
-            c for c in (expected_col, statement_col, user_input_col) if c >= 0
-        )
-        return _spec(
-            norm.index("ID"),
-            wide_cols,
-            kind="clarification",
-            id_col=norm.index("ID"),
-            kind_col=norm.index("Kind") if "Kind" in norm else -1,
-            status_col=norm.index("Status") if "Status" in norm else -1,
-            statement_col=statement_col,
-            user_input_col=user_input_col,
-        )
-
-    return None
-
-
-def _grouped_meta_cell(
-    header_cells: list[str], row: list[str], spec: _GroupedSpec
-) -> str:
-    """The leading metadata ``<td>``: a bold headline (``headline_col``)
-    above one ``key: value`` line per collapsed short column."""
-    headline = row[spec.headline_col] if spec.headline_col < len(row) else ""
-    fields = "".join(
-        '<div class="grp-field">'
-        f'<span class="grp-key">{_inline(header_cells[col])}</span>'
-        f'<span class="grp-val">{_inline(row[col] if col < len(row) else "")}</span>'
-        "</div>"
-        for col in spec.group_cols
-    )
-    return (
-        '<td class="grp-meta">'
-        f'<div class="grp-headline">{_inline(headline)}</div>'
-        f"{fields}</td>"
-    )
-
-
-def _grouped_clarification_row(
-    row: list[str], spec: _GroupedSpec
-) -> tuple[str, str]:
-    """Return ``(tr_attrs, wide_cells_html)`` for one §1 row, re-attaching
-    the form widget + ``data-*`` attrs to ``C-\\d+`` rows exactly as the
-    non-grouped path does."""
-    rid = row[spec.id_col] if 0 <= spec.id_col < len(row) else ""
-    is_form_row = bool(re.fullmatch(r"C-\d+", rid)) and spec.user_input_col >= 0
-    kind = row[spec.kind_col] if is_form_row and 0 <= spec.kind_col < len(row) else ""
-    status = row[spec.status_col] if is_form_row and 0 <= spec.status_col < len(row) else ""
-    statement = (
-        row[spec.statement_col]
-        if is_form_row and 0 <= spec.statement_col < len(row)
-        else ""
-    )
-    tr_attrs = (
-        f' data-response-id="{html.escape(rid)}" '
-        f'data-kind="{html.escape(kind)}" '
-        f'data-status="{html.escape(status)}"'
-        if is_form_row
-        else ""
-    )
-    cells: list[str] = []
-    for col in spec.wide_cols:
-        value = row[col] if col < len(row) else ""
-        if is_form_row and col == spec.user_input_col:
-            cells.append(
-                f'<td class="grp-wide grp-form">'
-                f"{_form_control(rid, kind, status, value, statement)}</td>"
-            )
-        else:
-            cells.append(f'<td class="grp-wide">{_inline(value)}</td>')
-    return tr_attrs, "".join(cells)
-
-
-def _emit_grouped_table(
-    header_cells: list[str], rows: list[list[str]], spec: _GroupedSpec
-) -> str:
-    """Render a wide table in the compact grouped layout described by
-    ``spec`` — one metadata cell plus the min-width long columns."""
-    head = (
-        "<thead><tr>"
-        f"<th>{_inline(header_cells[spec.headline_col])}</th>"
-        + "".join(
-            f'<th class="grp-wide">{_inline(header_cells[col])}</th>'
-            for col in spec.wide_cols
-        )
-        + "</tr></thead>"
-    )
-    body_rows: list[str] = []
-    for row in rows:
-        meta = _grouped_meta_cell(header_cells, row, spec)
-        if spec.kind == "clarification":
-            tr_attrs, wide_cells = _grouped_clarification_row(row, spec)
-        else:
-            tr_attrs = ""
-            wide_cells = "".join(
-                f'<td class="grp-wide">{_inline(row[col] if col < len(row) else "")}</td>'
-                for col in spec.wide_cols
-            )
-        body_rows.append(f"<tr{tr_attrs}>{meta}{wide_cells}</tr>")
-    body = "<tbody>" + "".join(body_rows) + "</tbody>"
-    return f'<table class="grouped-table">{head}{body}</table>'
-
-
 _ENUM_LETTERS = "abcde"
 _ENUM_CUE_WORDS: tuple[str, ...] = (
     "권장은", "권장 ", "추천은", "추천 ", "사유:", "사유 ", "근거:",

package/runtime/python/okstra_ctl/run.py

@@ -28,7 +28,10 @@ from pathlib import Path
 
 from okstra_project import project_json_path, upsert_project_json
 from .analysis_packet import build_analysis_packet
-from .clarification_items import unresolved_approval_blockers
+from .clarification_items import (
+    section_1_present_but_unparsed,
+    unresolved_approval_blockers,
+)
 from .qa_commands import format_errors as _format_qa_errors, validate_qa_commands
 from .material import (
     build_analysis_material,
@@ -341,6 +344,14 @@ def _validate_approved_plan(path: str) -> None:
     # frontmatter approved == true 상태. §1 Clarification Items 의
     # Blocks=approval 행이 아직 open/answered 면 승인을 무효화한다.
     blockers = unresolved_approval_blockers(body)
+    if blockers is None and section_1_present_but_unparsed(body):
+        raise PrepareError(
+            f"approved plan has a `## 1. Clarification Items` heading but its table "
+            f"could not be parsed (heading/anchor/format drift): {path}\n"
+            "  the approval gate cannot confirm there are no unresolved "
+            "`Blocks=approval` rows, so it refuses to soft-pass. Re-render the report "
+            "with scripts/okstra-render-final-report.py so §1 matches the schema, then retry."
+        )
     if blockers:
         lines = [
             f"approved plan frontmatter has `approved: true` but §1 has {len(blockers)} "

package/runtime/python/okstra_ctl/wizard.py

@@ -31,7 +31,10 @@ from okstra_ctl.models import (
     UnknownModelError,
     resolve_model_metadata,
 )
-from okstra_ctl.clarification_items import unresolved_approval_blockers
+from okstra_ctl.clarification_items import (
+    section_1_present_but_unparsed,
+    unresolved_approval_blockers,
+)
 from okstra_ctl.pr_template import PrTemplateError, resolve_pr_template_path
 from okstra_ctl.run import (
     APPROVED_FRONTMATTER_PATTERN,
@@ -455,6 +458,13 @@ def _validate_approved_plan(path_str: str, project_root: Path) -> Path:
     # frontmatter approved == true 라도 §1 의 Blocks=approval 행이 미해결이면
     # 승인이 무효 — prepare_task_bundle 의 _validate_approved_plan 과 동일 규약.
     blockers = unresolved_approval_blockers(body)
+    if blockers is None and section_1_present_but_unparsed(body):
+        raise WizardError(
+            f"approved plan has a `## 1. Clarification Items` heading but its table "
+            f"could not be parsed (heading/anchor/format drift): {p}\n"
+            "  the approval gate cannot confirm there are no unresolved "
+            "`Blocks=approval` rows — re-render the report so §1 matches the schema."
+        )
     if blockers:
         lines = [
             f"approved plan frontmatter has `approved: true` but §1 has {len(blockers)} "
@@ -716,7 +726,7 @@ def _build_task_pick(state: WizardState) -> Prompt:
     latest_key = latest.get("taskKey") or ""
     latest_suffix = t["options"].get("_LATEST_SUFFIX", "")
     options: list[Option] = []
-    for entry in tasks[:8]:
+    for entry in tasks[:16]:
         key = entry.get("taskKey") or ""
         ttype = entry.get("taskType") or ""
         phase = (entry.get("workflow") or {}).get("currentPhase") or ttype
@@ -985,11 +995,31 @@ def _submit_task_id_text(state: WizardState, value: str) -> Optional[str]:
     return f"task-id: {state.task_id}"
 
 
+def _existing_task_next_phase(state: WizardState) -> str:
+    """새 task 로 시작했더라도 입력한 task-key 가 이미 존재하면(=사실상 이어가기)
+    그 기존 manifest 의 nextRecommendedPhase 를 반환한다. 없으면 ''.
+
+    사용자가 picker 에서 기존 task-key 를 고르지 않고 new-task 흐름으로 같은
+    task-group/task-id 를 다시 입력한 경우에도 직전 phase 의 추천이 끊기지 않게
+    하는 안전장치."""
+    if not (state.project_id and state.task_group and state.task_id):
+        return ""
+    key = f"{state.project_id}:{state.task_group}:{state.task_id}"
+    root = find_task_root(Path(state.project_root), key)
+    if root is None:
+        return ""
+    workflow = (read_task_manifest(root) or {}).get("workflow") or {}
+    nxt = workflow.get("nextRecommendedPhase") or ""
+    return nxt if isinstance(nxt, str) else ""
+
+
 def _build_task_type(state: WizardState) -> Prompt:
     t = _p(state.workspace_root, "task_type")
     recommended_suffix = t["options"].get("_RECOMMENDED_SUFFIX", "")
     options: list[Option] = []
     recommended = state.task_type if not state.is_new_task else ""
+    if not recommended and state.is_new_task:
+        recommended = _existing_task_next_phase(state)
     seen: list[str] = []
     if recommended and recommended in TASK_TYPE_VALUES:
         d = dict(TASK_TYPES)[recommended]
@@ -1340,8 +1370,11 @@ def _suggest_latest_final_report(state: WizardState) -> str:
     runs_base = task_runs_dir(state.project_root, state.task_group, state.task_id)
     if not runs_base.is_dir():
         return ""
+    # run 산출물 구조는 runs/<task-type>/reports/final-report-*.md (1단계).
+    # 과거 `*/*/reports/...` (2단계) glob 은 실제 구조와 어긋나 항상 빈 결과여서
+    # clarification 단계가 직전 final-report 를 추천하지 못했다.
     candidates = [
-        p for p in runs_base.glob("*/*/reports/final-report-*.md")
+        p for p in runs_base.glob("*/reports/final-report-*.md")
         if p.is_file()
     ]
     if not candidates:
@@ -1671,7 +1704,10 @@ def _submit_defaults_or_custom(state: WizardState, value: str) -> Optional[str]:
     if value not in ("defaults", "customize"):
         raise WizardError(f"expected 'defaults' or 'customize', got: {value!r}")
     state.use_defaults = value == "defaults"
-    return f"customize: {'no' if state.use_defaults else 'yes'}"
+    mode = ("defaults (recommended models as-is)"
+            if state.use_defaults
+            else "customize (manual model pick)")
+    return f"model-mode: {mode}"
 
 
 def _build_workers_override(state: WizardState) -> Prompt:
@@ -1719,7 +1755,13 @@ def _submit_workers_override(state: WizardState, value: str) -> Optional[str]:
 
 
 def _model_pick(step: str, label: str, options: list[str], echo: str) -> Prompt:
-    opts = [_opt(o, o) for o in options]
+    # "default" picks the role's recommended model — leaving it here yields
+    # the SAME result as the 'Use defaults' branch. Spell that out on the
+    # label so default ↔ customize never reads as "no difference".
+    opts = [
+        _opt(o, "default (recommended model)" if o == "default" else o)
+        for o in options
+    ]
     return Prompt(step=step, kind="pick", label=label,
                   options=opts, echo_template=echo)
 
@@ -2192,14 +2234,19 @@ STEPS: list[Step] = [
                             and S_RELATED_TASKS not in s.answered),
          build=_build_related_tasks, submit=_submit_related_tasks,
          owns=("related_tasks_raw", "related_tasks_pending_text")),
+    # clarification(직전 phase final-report 입력)은 customize 전용이 아니다.
+    # 이어가기에 필수인 직전 final-report 가 존재하면 use_defaults 와 무관하게
+    # 입력 기회를 노출한다. (과거: use_defaults 게이트 뒤에 숨어 "Use defaults"
+    # 를 고르면 직전 리포트가 통째로 누락됐다.)
     Step(S_CLARIFICATION_PICK,
-         applies=lambda s: (s.use_defaults is False
-                            and S_CLARIFICATION_PICK not in s.answered),
+         applies=lambda s: (S_CLARIFICATION_PICK not in s.answered
+                            and s.use_defaults is not None
+                            and (s.use_defaults is False
+                                 or bool(_suggest_latest_final_report(s)))),
          build=_build_clarification_pick, submit=_submit_clarification_pick,
          owns=("clarification_response_path", "clarification_pending_text")),
     Step(S_CLARIFICATION,
-         applies=lambda s: (s.use_defaults is False
-                            and s.clarification_pending_text
+         applies=lambda s: (s.clarification_pending_text
                             and S_CLARIFICATION not in s.answered),
          build=_build_clarification, submit=_submit_clarification,
          owns=("clarification_response_path", "clarification_pending_text")),

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

@@ -536,7 +536,10 @@
               "type": "array",
               "items": { "$ref": "#/$defs/DiffFileRow" }
             }
-          }
+          },
+          "$comment": "rawStat(git diff --stat 원문)이 비어있지 않으면(=변경 있음) files 표는 최소 1행이어야 한다. 변경을 stat 으로는 보고하면서 files 표를 비워 미선언-surface conformance 게이트를 우회하는 fail-open(SUSP-1)을 차단. 0파일 변경은 rawStat 이 빈 문자열이라 허용된다.",
+          "if": { "required": ["rawStat"], "properties": { "rawStat": { "minLength": 1 } } },
+          "then": { "properties": { "files": { "minItems": 1 } } }
         },
         "outOfPlanEdits": {
           "type": "array",

package/runtime/skills/okstra-report-writer/SKILL.md

@@ -131,7 +131,7 @@ The four steps below MUST execute in this exact order. Reordering them is the re
 
 The status file is written after step 3 completes.
 
-**Run-end team teardown follows this whole sequence.** Token-usage collection (step 1) reads the worker session jsonls, so the lead MUST NOT disband the team until every step above is done. Only then does the lead shut down worker teammates + `TeamDelete` per `_common-contract.md` "Run-end team teardown" (Teams mode only; silent-skip in the no-`team_name` fallback).
+**Run-end teammate teardown follows this whole sequence.** Token-usage collection (step 1) reads the worker session jsonls, so the lead MUST NOT disband the team until every step above is done. Only then — after the pane-disposition prompt and only when the user approves teammate cleanup — does the lead shut down worker teammates + `TeamDelete` per `_common-contract.md` "Run-end teammate teardown" (Teams mode only; silent-skip in the no-`team_name` fallback; if the user keeps the team, leave it intact and surface the manual Teams/FleetView cleanup path).
 
 ## Final Report Structure
 
@@ -273,7 +273,7 @@ Section numbering follows `templates/reports/final-report.template.md` exactly
 2. **Final Verdict** — `Direction` ∈ `continue-investigation` / `begin-implementation` / `approve` / `reject` / `hold`. **Verdict Token** is `not-applicable` for every task-type except `final-verification` — see "Final-verification verdict token contract" below for that case.
 3. **Evidence and Detailed Analysis** — primary evidence rows (file path, line, snippet); secondary evidence / alternate interpretations. If `reference-expectations.md` lists explicit expected values, record match/gap per row.
 4. **Missing Information and Risks** — uncertain / "I don't know" items. `implementation-planning` adds §5.5 (see heading contract below); `release-handoff` adds §5.6.
-5. **Clarification Items** — single unified `C-*` table; column schema, ID convention, and rerun behaviour are owned by `_common-contract.md §Clarification request policy` (8-column SSOT). The deprecated `5.5.9 Open Questions` / `1.1 추가 자료 요청` / `1.2 사용자 확인 질문` sub-sections are removed; the validator fails reports that reintroduce them.
+5. **Clarification Items** — single unified `C-*` table; column schema (4 columns with the short fields stacked in one record-meta cell), ID convention, and rerun behaviour are owned by `_common-contract.md §Clarification request policy` (SSOT). The deprecated `5.5.9 Open Questions` / `1.1 추가 자료 요청` / `1.2 사용자 확인 질문` sub-sections are removed; the validator fails reports that reintroduce them.
 6. **Recommended Next Steps** — prioritized actions. After Phase 7's follow-up spawner runs, append a row per newly created task-key (see "Phase 6 → Phase 7 execution sequence" above).
 7. **Follow-up Tasks** — auto-spawn-eligible table. Each row drives `okstra-spawn-followups.py`; see template §7 for the row schema.
 

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

@@ -26,10 +26,11 @@ implementation-option: {{ frontmatter.implementationOption | yaml_scalar }}
 - Created at: {{ header.createdAt }}
 - Task Key: {{ header.taskKey }}
 - Task Type: {{ header.taskType }}
-- Report Owner: `{{ header.reportOwner }}`
+- Report Owner: `{{ header.reportOwner }}` (model: `{{ header.leadModel | model_detail }}`)
 - Report Author: `{{ header.reportAuthor }}`
-- Lead Model: `{{ header.leadModel }}`
-- Okstra Version: `{{ header.okstraVersion }}`
+- Lead Model: `{{ header.leadModel | model_detail }}`
+{% for row in followUpTasks if row.origin == 'phase-continuation' %}{% if loop.first %}- Next Step: run `/okstra-run`, select task `{{ header.taskKey }}`, choose task-type `{{ row.suggestedTaskType }}`
+{% endif %}{% endfor %}- Okstra Version: `{{ header.okstraVersion }}`
 
 ## Verdict Card
 
@@ -55,10 +56,10 @@ implementation-option: {{ frontmatter.implementationOption | yaml_scalar }}
 - Claude Code: `/okstra-run resume-clarification task-key={{ header.taskKey }}`
 - {{ t("clarification.separateTerminalLabel") }}: `scripts/okstra.sh --resume-clarification --task-key {{ header.taskKey }}`
 
-| ID | Ticket ID | Kind | Statement | Expected form | Blocks | Status | User input |
-|----|-----------|------|-----------|---------------|--------|--------|-----------|
+| {{ t("columns.recordMeta") }} | Statement | Expected form | User input |
+|---|---|---|---|
 {% for row in clarificationItems -%}
-| {{ row.id }} | `{{ row.ticketId }}` | `{{ row.kind }}` | {{ row.statement }} | {{ row.expectedForm }} | `{{ row.blocks }}` | {{ row.status }} | {{ row.userInput or '' }} |
+| **{{ row.id }}**<br>Ticket: `{{ row.ticketId }}`<br>Kind: `{{ row.kind }}`<br>Blocks: `{{ row.blocks }}`<br>Status: {{ row.status }} | {{ row.statement }} | {{ row.expectedForm }} | {{ row.userInput or '' }} |
 {% endfor %}
 
 {{ t("clarification.columnGuide") }}

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

@@ -127,7 +127,7 @@
   "clarification": {
     "fillAndRerun": "Fill in your answers then re-run the same phase:",
     "separateTerminalLabel": "Separate terminal",
-    "columnGuide": "Column descriptions:"
+    "columnGuide": "Record cell field values:"
   },
   "followUpTasks": {
     "headingAside": "Follow-up Tasks"

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

@@ -127,7 +127,7 @@
   "clarification": {
     "fillAndRerun": "답을 채우신 뒤 같은 phase 를 다시 실행:",
     "separateTerminalLabel": "별도 터미널",
-    "columnGuide": "각 컬럼 설명:"
+    "columnGuide": "항목 칸 안의 값 설명:"
   },
   "followUpTasks": {
     "headingAside": "후속 작업"

package/runtime/templates/reports/report.css

@@ -132,38 +132,6 @@ td.td-narrow, th.td-narrow {
   width: 5%;
   white-space: nowrap;
 }
-/* Compact grouped layout for the wide final-report tables (Execution
- * Status, §5 Clarification Items, §7 Follow-up Tasks): the short
- * columns collapse into one stacked `key: value` metadata cell, while
- * each long-prose column keeps its own guaranteed min-width so it never
- * gets squashed into a one-character ladder. */
-table.grouped-table td.grp-meta {
-  width: 24%;
-}
-table.grouped-table th.grp-wide,
-table.grouped-table td.grp-wide {
-  min-width: 18ch;
-}
-.grp-meta .grp-headline {
-  font-weight: 600;
-  margin-bottom: 0.4em;
-}
-.grp-meta .grp-field {
-  display: flex;
-  gap: 0.45em;
-  font-size: 0.88rem;
-  line-height: 1.55;
-}
-.grp-meta .grp-key {
-  color: GrayText;
-  white-space: nowrap;
-}
-.grp-meta .grp-key::after {
-  content: ":";
-}
-.grp-meta .grp-val {
-  overflow-wrap: anywhere;
-}
 thead th {
   position: sticky;
   top: 3rem;

package/runtime/templates/worker-prompt-preamble.md

@@ -113,3 +113,13 @@ Every item in sections 1–5 (and any section 6) MUST carry a worker-internal it
 For task types `requirements-discovery`, `error-analysis`, `implementation-planning`, or `implementation`, every item in sections 1–5 MUST carry a ticket identifier. Use the `Ticket ID` column in table-form items and the `[TICKETID: <id>]` prefix in bullet/numbered items.
 
 See `skills/okstra-team-contract/SKILL.md` "Worker Output Contract" for the full frontmatter schema and section ordering rules. This preamble is consistent with that contract; the team-contract document is authoritative if the two ever diverge.
+
+## Writing style (all prose output — analysis workers + report-writer)
+
+When you write in Korean (`Report Language: ko` / `meta.reportLanguage = "ko"`), write so a Korean developer understands it on first read. Translate the **meaning**, never the dictionary word.
+
+- Keep code identifiers, file paths, symbols, model names, CLI flags, and status tokens in English (`strategy`, `overlay`, `accepted`, …). Translate the ordinary words around them.
+- Do NOT render a technical term as its literal dictionary noun. Use the term a developer actually says:
+  - `authoritative` → **기준값 / 정본 / 우선 적용** (NEVER 권위)
+  - e.g. "overlays this row as authoritative" → "이 행을 최종 기준값으로 덮어쓴다" (NEVER "이 행을 권위로 overlay")
+- Self-check before emitting any Korean sentence: if it reads like an awkward word-for-word translation, rewrite it by meaning. Confident-but-unreadable direct translation is a defect.

package/runtime/validators/validate-implementation-plan-stages.py

@@ -13,9 +13,6 @@ from pathlib import Path
 from typing import List, Tuple
 
 STAGE_MAP_HEADING = re.compile(r"^##\s+5\.5\s+Stage\s+Map\b", re.M)
-STAGE_SECTION = re.compile(
-    r"^##\s+5\.5\.(\d+)\s+Stage\s+\1\s*:\s*(.+)$", re.M
-)
 REQUIRED_SUBSECTIONS = (
     "Carry-In",
     "Stepwise Execution Order",

package/runtime/validators/validate-report-views.py

@@ -29,7 +29,10 @@ SCRIPTS_DIR = REPO_ROOT / "scripts"
 if str(SCRIPTS_DIR) not in sys.path:
     sys.path.insert(0, str(SCRIPTS_DIR))
 
-from okstra_ctl.clarification_items import parse_clarification_items  # noqa: E402
+from okstra_ctl.clarification_items import (  # noqa: E402
+    parse_clarification_items,
+    section_1_present_but_unparsed,
+)
 from okstra_ctl.report_views import (  # noqa: E402
     extract_html_digest,
     source_digest,
@@ -80,6 +83,14 @@ def validate(report_path: Path) -> list[str]:
 
     md = report_path.read_text(encoding="utf-8")
     html_path = report_path.with_name(report_path.stem + ".html")
+    # §1 헤딩이 있는데 파싱이 실패하면 md_ids 가 빈 []이 되어 "clarification 없음
+    # → skip" 으로 흘러 HTML form parity 게이트가 조용히 열린다. fail-closed.
+    if section_1_present_but_unparsed(md):
+        return [
+            "final-report has a `## 1. Clarification Items` heading but its table "
+            "could not be parsed (heading/anchor/format drift) — cannot verify HTML "
+            "form parity. Re-render the report so §1 matches the schema."
+        ]
     md_ids = _md_response_ids(md)
 
     # (1) sibling artifact exists — conditional on §1 clarification rows.

package/runtime/validators/validate-run.py

@@ -510,11 +510,20 @@ TOKEN_PLACEHOLDERS = (
 )
 
 
+# The final-report renderer (render_final_report.py:_inject_anchors) appends a
+# scroll anchor ` <a id="slug"></a>` to every H2+ heading. Section-scoping
+# regexes that pin a heading to end-of-line MUST tolerate this optional suffix
+# or they silently fail to match the rendered markdown — yielding false
+# "missing section" failures and dead consistency checks. Mirror of the strip
+# pattern in scripts/okstra_ctl/report_views.py:_HEADING_ANCHOR_RE.
+_HEADING_TAIL = r'[ \t]*(?:<a id="[^"]+"></a>[ \t]*)?$'
+
 # Token Usage Summary section between its `##` heading and the next `##`
 # heading (or end-of-file). Matched non-greedily so the body of the next
 # section never bleeds in.
 _TOKEN_USAGE_SECTION_RE = re.compile(
-    r"^##[ \t]+(?:Token Usage Summary|토큰 사용량 요약)[ \t]*$\n(?P<body>.*?)(?=^##[ \t]|\Z)",
+    r"^##[ \t]+(?:Token Usage Summary|토큰 사용량 요약)" + _HEADING_TAIL
+    + r"\n(?P<body>.*?)(?=^##[ \t]|\Z)",
     re.DOTALL | re.MULTILINE,
 )
 
@@ -695,7 +704,7 @@ _DEPRECATED_FINAL_REPORT_PATTERNS: tuple[tuple[re.Pattern, str], ...] = (
         ),
         "deprecated `### 1.1 추가 자료 요청` / `Additional Materials` sub-section — "
         "every clarification item lives as one row of the unified `## 1. "
-        "Clarification Items` 8-column table (`Kind=material`).",
+        "Clarification Items` table (`Kind=material`).",
     ),
     (
         re.compile(
@@ -704,7 +713,7 @@ _DEPRECATED_FINAL_REPORT_PATTERNS: tuple[tuple[re.Pattern, str], ...] = (
         ),
         "deprecated `### 1.2 사용자 확인 질문` / `Questions for the User` "
         "sub-section — collapse into the unified `## 1. Clarification Items` "
-        "8-column table (`Kind=decision`).",
+        "table (`Kind=decision`).",
     ),
 )
 
@@ -1046,7 +1055,8 @@ _FINAL_VERDICT_TOKEN_RE = re.compile(
 # the Verdict Card block, scoped to the body between `## Verdict Card`
 # heading and the next `##` heading.
 _VERDICT_CARD_BLOCK_RE = re.compile(
-    r"^##[ \t]+Verdict Card[ \t]*$\n(?P<body>.*?)(?=^##[ \t]|\Z)",
+    r"^##[ \t]+Verdict Card" + _HEADING_TAIL
+    + r"\n(?P<body>.*?)(?=^##[ \t]|\Z)",
     re.DOTALL | re.MULTILINE,
 )
 
@@ -1054,7 +1064,8 @@ _VERDICT_CARD_BLOCK_RE = re.compile(
 # regex so that we don't accidentally match a Verdict Token row that
 # lives in the Verdict Card or anywhere else.
 _FINAL_VERDICT_BLOCK_RE = re.compile(
-    r"^##[ \t]+7\.[ \t]+Final Verdict[ \t]*$\n(?P<body>.*?)(?=^##[ \t]|\Z)",
+    r"^##[ \t]+7\.[ \t]+Final Verdict" + _HEADING_TAIL
+    + r"\n(?P<body>.*?)(?=^##[ \t]|\Z)",
     re.DOTALL | re.MULTILINE,
 )
 
@@ -1114,13 +1125,22 @@ def _extract_final_verdict_token(content: str) -> str | None:
     return match.group("value")
 
 
+# 렌더러는 ID 정의 셀(`<a id="r-001"></a>R-001`)에도 스크롤 앵커를 넣는다.
+# 셀 정규화 때 그 빈 앵커를 벗겨야 ID 컬럼이 bare 토큰으로 읽힌다
+# (clarification_items._CELL_ANCHOR_RE 와 동형).
+_CELL_ANCHOR_RE = re.compile(r'<a id="[^"]*"></a>')
+
+
 def _split_markdown_row(line: str) -> list[str]:
     stripped = line.strip()
     if stripped.startswith("|"):
         stripped = stripped[1:]
     if stripped.endswith("|"):
         stripped = stripped[:-1]
-    return [cell.strip().strip("`").strip() for cell in stripped.split("|")]
+    return [
+        _CELL_ANCHOR_RE.sub("", cell).strip().strip("`").strip()
+        for cell in stripped.split("|")
+    ]
 
 
 def _is_markdown_separator(line: str) -> bool: