okstra 0.57.0 → 0.59.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.57.0",
+  "version": "0.59.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.57.0",
-  "builtAt": "2026-06-08T17:08:29.657Z",
+  "package": "0.59.0",
+  "builtAt": "2026-06-09T01:52:37.281Z",
   "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/prompts/wizard/prompts.ko.json

@@ -236,14 +236,20 @@
       "label": "추가 critic 패스를 돌릴까요? (놓친 finding/blocker 를 캐는 검증 패스 — opt-in)",
       "echo_template": "critic: {value}",
       "options": {
-        "off": "사용 안 함 (기본·추천)",
-        "claude": "claude critic (추천)",
-        "__free_input__": "직접 입력 (codex / gemini)"
+        "off": "사용 안 함 (기본·추천)"
+      },
+      "labels": {
+        "provider_recommended": "{provider} critic (추천)",
+        "provider": "{provider} critic"
       }
     },
     "critic_text": {
-      "label": "critic provider 를 직접 입력하세요 (codex / gemini)",
-      "echo_template": "critic: {value}"
+      "label": "critic provider 를 선택하세요",
+      "echo_template": "critic: {value}",
+      "labels": {
+        "provider_recommended": "{provider} critic (추천)",
+        "provider": "{provider} critic"
+      }
     },
     "defaults_or_custom": {
       "label": "역할별로 어떤 모델을 쓸지 정하는 단계입니다 (참여 워커 구성을 바꾸는 게 아닙니다).\n· 기본값으로 진행 — lead·실행자/워커·report-writer 를 모두 추천 모델로 두고 바로 진행합니다.\n· 커스터마이즈 — 역할별 모델을 직접 고르고, 추가 directive·관련 task 도 지정합니다.",

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
 
 

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/wizard.py

@@ -1572,17 +1572,29 @@ def _submit_pr_template_pick(state: WizardState, value: str) -> Optional[str]:
     return _submit_optional_cached_pick(state, value, _PR_TEMPLATE_PICK_SPEC)
 
 
-CRITIC_CHOICES = ["off", "claude", "codex", "gemini"]
+def _critic_provider_choices() -> list[str]:
+    return list(EXECUTORS)
+
+
+def _critic_choices() -> list[str]:
+    return ["off", *_critic_provider_choices()]
+
+
+def _critic_provider_label(provider: str, t: dict) -> str:
+    labels = t.get("labels", {})
+    if provider == "claude":
+        template = labels.get("provider_recommended", "{provider} critic (recommended)")
+    else:
+        template = labels.get("provider", "{provider} critic")
+    return template.format(provider=provider)
 
 
 def _build_critic_pick(state: WizardState) -> Prompt:
     t = _p(state.workspace_root, "critic_pick")
-    options: list[Option] = []
-    for k, v in t["options"].items():
-        if not k.startswith("_"):
-            options.append(_opt(k, v))
-    custom_label = t["options"].get(PICK_TYPE_CUSTOM, PICK_TYPE_CUSTOM)
-    options.append(_opt(PICK_TYPE_CUSTOM, custom_label))
+    off_label = t["options"].get("off", "off")
+    options = [_opt("off", off_label)]
+    for provider in _critic_provider_choices():
+        options.append(_opt(provider, _critic_provider_label(provider, t)))
     return Prompt(
         step=S_CRITIC_PICK, kind="pick",
         label=t["label"],
@@ -1592,12 +1604,10 @@ def _build_critic_pick(state: WizardState) -> Prompt:
 
 
 def _submit_critic_pick(state: WizardState, value: str) -> Optional[str]:
-    if value == PICK_TYPE_CUSTOM:
-        state.critic_pending_text = True
-        return None
     choice = (value or "").strip().lower()
-    if choice not in CRITIC_CHOICES:
-        raise WizardError(f"critic must be one of {CRITIC_CHOICES}, got: {value!r}")
+    choices = _critic_choices()
+    if choice not in choices:
+        raise WizardError(f"critic must be one of {choices}, got: {value!r}")
     state.critic = choice
     state.critic_pending_text = False
     return f"critic: {choice}"
@@ -1605,17 +1615,23 @@ def _submit_critic_pick(state: WizardState, value: str) -> Optional[str]:
 
 def _build_critic_text(state: WizardState) -> Prompt:
     t = _p(state.workspace_root, "critic_text")
+    options = [
+        _opt(provider, _critic_provider_label(provider, t))
+        for provider in _critic_provider_choices()
+    ]
     return Prompt(
-        step=S_CRITIC_TEXT, kind="text",
+        step=S_CRITIC_TEXT, kind="pick",
         label=t["label"],
+        options=options,
         echo_template=t["echo_template"],
     )
 
 
 def _submit_critic_text(state: WizardState, value: str) -> Optional[str]:
     choice = (value or "").strip().lower()
-    if choice not in CRITIC_CHOICES:
-        raise WizardError(f"critic must be one of {CRITIC_CHOICES}, got: {value!r}")
+    providers = _critic_provider_choices()
+    if choice not in providers:
+        raise WizardError(f"critic must be one of {providers}, got: {value!r}")
     state.critic = choice
     state.critic_pending_text = False
     return f"critic: {choice}"

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

@@ -55,10 +55,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-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,
 )