okstra 0.72.0 → 0.73.0

package/docs/kr/architecture.md

@@ -496,7 +496,7 @@ task manifest, task index, instruction-set, runs, history가 이 루트 아래
 - `reports/final-report-<task-type>-<seq>.md`
 - `reports/final-report-<task-type>-<seq>.slim.md`  *(Phase 7 결정론적 후처리: AI 다음-phase 입력용 슬림 markdown)*
 - `reports/final-report-<task-type>-<seq>.html`     *(Phase 7 결정론적 후처리: 사람 reviewer 용 self-contained HTML, CSS/JS 인라인)*
-- `user-responses/user-response-<task-type>-<seq>.md` *(HTML 의 `Export user response` 버튼이 생성하는 사이드카; 사용자가 채워 저장하면 다음 phase 가 입력으로 소비)*
+- `user-responses/user-response-<task-type>-<seq>.md` *(HTML 의 `Export user response` 버튼이 같은 이름으로 다운로드해 주는 사이드카; 여기 저장해 두면 `--resume-clarification` 이 instruction-set 의 `clarification-response.md` 에 자동 첨부한다 — `clarification_items.clarification_response_with_sidecars`)*
 - `worker-results/<worker>-audit-<task-type>-<seq>.md` *(워커별 Reading Confirmation 사이드카; 본문이 아니라 audit 용)*
 - `status/final-<task-type>-<seq>.status`
 - `carry/stage-<N>.json` *(implementation 전용: stage N 실행 evidence sidecar; 다음 stage 가 자동 carry-in)*
@@ -969,6 +969,7 @@ Phase 7 step 1.5 가 final-report MD 한 본을 입력으로 두 view 를 결정
 - billable-equivalent token math와 USD cost estimation을 함께 기록합니다. Anthropic billing ratio(`cache_creation_5m=1.25x`, `cache_creation_1h=2.0x`, `cache_read=0.1x`, `output=5x`)를 반영합니다. transcript 의 `usage.cache_creation.ephemeral_5m_input_tokens` / `ephemeral_1h_input_tokens` 분해가 있으면 분리 집계합니다.
 - 가격표는 `scripts/okstra_token_usage/pricing.py` 에서 중앙 관리합니다. 모델 가격이 바뀌면 거기서 갱신합니다. 가격 매칭에 실패한 모델 id 는 `usageSummary.unmatchedModels` 필드로 사용자에게 노출됩니다 (silent zero 사고 방지).
 - **증분 스캔 캐시 (P6)**: 세션 jsonl 재스캔을 피하기 위해 `$OKSTRA_HOME/cache/token-usage/<transcript-dir>/<sessionId>.json` 에 파일별 byte cursor + 윈도우 적용 전 usage 이벤트 추출본을 보존합니다 (`scripts/okstra_token_usage/cursor.py`). run 윈도우(since/until)는 매 호출 시 이벤트 위에서 재평가하므로 재실행으로 윈도우가 좁아져도 합계는 전체 스캔과 동일합니다. 캐시는 파생 데이터라 식별자 불일치·truncate·손상 시 자동으로 전체 재스캔으로 폴백하며, `okstra-token-usage.py --no-cache` 로 강제 우회할 수 있습니다.
+- **단계 타임라인 (P0 계측)**: 수집기가 lead 세션 jsonl 의 `PROGRESS: phase-*` 체크포인트 라인(agents/SKILL.md "Progress reporting")을 run 윈도우로 스코핑해 추출하고, team-state 에 `phaseTimeline` 블록(`{source, phases: [{phase, firstAt, lastAt, markerCount, wallMsToNext}]}`)으로 기록합니다 (`scripts/okstra_token_usage/collect.py :: phase_timeline`). run 내부 단계별 wall-clock 의 측정 지점이며, `okstra-inspect` time facet 의 "Per-run phase breakdown" 이 소비합니다. 마커가 없는 run 은 `phases: []` 로 측정 불가를 명시합니다.
 
 ## Validators
 

package/docs/kr/cli.md

@@ -384,7 +384,7 @@ scripts/okstra.sh --task-type implementation \
 
 Phase 5.6 의 opt-in critic pass 를 수행할 provider 를 선택합니다. 값은 `off` | `claude` | `codex` | `gemini` 중 하나이며 기본값은 `off` 입니다.
 
-- critic pass 는 convergence(Phase 5.5) 직후 reused-worker 1라운드로 수행됩니다 — discovery / error-analysis / implementation-planning 에서는 coverage gap 탐지, final-verification 에서는 acceptance devil's-advocate 역할입니다. 상세 규약은 `okstra-convergence` skill 의 "Coverage critic pass" / "Acceptance critic pass" 섹션을 따릅니다.
+- critic 디스패치는 convergence(Phase 5.5) 첫 reverify 라운드와 동시에 실행되고(critic 입력은 Round 0 통합 결과로 고정), gap/blocker 검증 1라운드는 convergence 종료 후 Phase 5.6 에서 수행됩니다 — discovery / error-analysis / implementation-planning 에서는 coverage gap 탐지, final-verification 에서는 acceptance devil's-advocate 역할입니다. 상세 규약은 `okstra-convergence` skill 의 "Coverage critic pass" / "Acceptance critic pass" 섹션을 따릅니다.
 - in-session `okstra-run` wizard 의 critic 선택 단계와 동일한 값 공간을 공유합니다. 허용값 검증은 `prepare_task_bundle` 의 `_resolve_model_bindings` 가 수행하며, 그 외 값은 `PrepareError` 로 즉시 거부됩니다.
 
 ### `--approved-plan`

package/docs/kr/performance-improvement-plan-v2.md

@@ -10,6 +10,7 @@
   - [2.4 worker 구조](#24-worker-구조)
 - [3. 성능 병목 가설](#3-성능-병목-가설)
 - [4. 측정 기준](#4-측정-기준)
+  - [4.1 실측 결과 (2026-06-11)](#41-실측-결과-2026-06-11-fontradar-v2-api-dev-9186)
 - [5. 개선 우선순위](#5-개선-우선순위)
   - [P0. Baseline 계측과 용어 정리](#p0-baseline-계측과-용어-정리)
   - [P1. Convergence 재검증 범위 축소](#p1-convergence-재검증-범위-축소)
@@ -98,12 +99,13 @@
 
 | ID | 병목 | 영향도 | 근거 / 확인 위치 | 판정 |
 |---|---|---:|---|---|
-| B1 | Convergence reverify round가 worker 수만큼 추가 dispatch를 만든다 | 높음 | `skills/okstra-convergence/SKILL.md` Round 1-N | 1차 개선 대상 |
-| B2 | analysis worker prompt와 required reading이 길다 | 높음 | `agents/SKILL.md`, `okstra-team-contract`, worker definitions | 별도 prompt diet 작업 |
-| B3 | report-writer가 worker 결과 + convergence + final-report-template을 다시 읽는다 | 중간 | `skills/okstra-report-writer/SKILL.md` | 구조상 필요. 중복 축소만 검토 |
+| B1 | Convergence reverify round가 worker 수만큼 추가 dispatch를 만든다 | 높음 | `skills/okstra-convergence/SKILL.md` Round 1-N | **해소** — P1 queue pruning 구현 + critic 직렬화 병렬화(§4.1 ②) |
+| B2 | analysis worker prompt와 required reading이 길다 | 높음 | `agents/SKILL.md`, `okstra-team-contract`, worker definitions | **대부분 해소** — analysis-packet-primary 실측 22KB/worker(§4.1) |
+| B3 | report-writer가 worker 결과 + convergence + final-report-template을 다시 읽는다 | ~~중간~~ 낮음 | `skills/okstra-report-writer/SKILL.md` | **입력 압축 기각** — 실측상 읽기 1~2분, 생성이 지배(§4.1 ③) |
 | B4 | prepare 단계에서 여러 render/write가 직렬 수행된다 | 낮음~중간 | `scripts/okstra_ctl/run.py` render block | 후순위 |
-| B5 | token usage collector가 session jsonl을 선형 스캔한다 | 낮음~중간 | `scripts/okstra_token_usage/` | run 종료 시 비용. 후순위 |
-| B6 | 단순 작업도 같은 full workflow를 탄다 | 중간 | task-type lifecycle / requirements routing | fast-track 설계 필요 |
+| B5 | token usage collector가 session jsonl을 선형 스캔한다 | 낮음~중간 | `scripts/okstra_token_usage/` | **해소** — P6 증분 캐시 구현 완료 |
+| B6 | 단순 작업도 같은 full workflow를 탄다 | 중간 | task-type lifecycle / requirements routing | fast-track 설계 필요 — 남은 최대 레버 |
+| B7 | report-writer 의 final-report/data.json **생성량 자체**가 크다 (90~140KB) | 높음 | 실측 §4.1 ③ — 생성 8~19분/run | 보고서 계약 슬림화 또는 report-writer 모델 선택 — **사용자 결정 필요** |
 
 확정 전제:
 
@@ -128,6 +130,18 @@ P1 구현 전 최소 fixture:
 2. mixed/unresolved 사례: Round 1 후 일부 finding만 남아 선택적 Round 2가 필요한 run.
 3. worker failure 사례: reverify dispatch 일부가 `timeout`/`error`인 run.
 
+### 4.1 실측 결과 (2026-06-11, fontradar-v2-api dev-9186)
+
+실 run 3개(req-discovery / impl-planning / implementation stage-1)의 산출물 mtime, team-state `phaseTimeline`, report-writer 세션 jsonl 툴콜 타임라인으로 측정했다.
+
+① **run 단계별 wall 분해** — 분석 run 에서 "본 분석"은 wall 의 17~24%에 불과하다. 셋업 4~6분 / 분석 16~24분 / convergence+critic 23분 / report-writer 12~24분.
+
+② **critic 직렬화** — reverify 종료 후에야 critic 이 디스패치되어 런당 6~12분이 직렬로 낭비됐다. critic 입력은 Round 0 통합 결과로 고정이므로 첫 reverify 라운드와 병렬 디스패치로 변경했다 (`skills/okstra-convergence/SKILL.md` §When).
+
+③ **report-writer 는 생성 지배** — 세션 툴콜 실측: 전체 입력(~404KB, 16 files) 읽기는 **1~2분**, data.json 생성(스켈레톤 Write 후 섹션별 Edit 증분 작성)이 **8~19분**, 자체 검증·audit 이 ~3분. 따라서 B3 입력 압축의 wall 절감은 ~1분 수준이라 **기각**. 남는 레버는 출력 측(B7): 보고서 계약 슬림화(품질 trade-off, 사용자 결정) 또는 `--report-writer-model` 하향(기존 knob).
+
+④ **계측 자동화** — Phase 7 수집기가 lead 의 `PROGRESS: phase-*` 마커를 추출해 team-state `phaseTimeline` 으로 영속한다 (`scripts/okstra_token_usage/collect.py :: phase_timeline`). 이후 run 부터 본 섹션의 ①을 수작업 mtime 분석 없이 `/okstra-inspect time` 으로 확인할 수 있다. `okstra context-cost` 의 reportWriter 표면도 실 dispatch 계약(현재 seq + analysis-packet)에 정렬했다.
+
 ## 5. 개선 우선순위
 
 ### P0. Baseline 계측과 용어 정리
@@ -347,8 +361,14 @@ Optional Round 2:
 3. P3 fast-track과 P4 prompt caching은 별도 설계/검증이 필요한 후속 작업으로 둔다.
 4. prepare render 병렬화와 token usage 증분화는 효과가 작거나 종료 단계 비용이므로 P1 이후 병렬 보조 작업으로 처리한다.
 
+**2026-06-11 갱신** — §4.1 실측으로 P0/P1/P6 + critic 병렬화 + phaseTimeline 계측이 완료됐고, B3(report-writer 입력 압축)는 기각됐다. 남은 우선순위는 두 개뿐이며 둘 다 사용자 결정이 선행한다:
+
+1. **B7 — report-writer 출력 측 단축**: 보고서 계약 슬림화(템플릿/스키마 축소, validator 계약 변경 수반) 또는 기본 report-writer 모델 하향. 런당 5~12분 절감 추정.
+2. **B6/P3 — fast-track routing**: 단순 작업의 lifecycle 단축. 승인 게이트 정책 결정 필요.
+
 ### 구현 plan 링크
 
-- P0 + P1: `docs/superpowers/plans/2026-05-14-convergence-queue-pruning.md`
+- P0 + P1: `docs/superpowers/plans/2026-05-14-convergence-queue-pruning.md` (구현 완료 — convergence state v1.2 에 반영)
 - P6: `docs/superpowers/plans/2026-06-10-p6-token-usage-incremental.md` (구현 완료)
-- P2 / P3 / P4 / P5: 미작성 (각 트랙별로 별도 plan 작성 필요)
+- critic 병렬화 + phaseTimeline 계측: plan 없이 직접 구현 (2026-06-11, `CHANGES.md` 해당 항목 참조)
+- P3 / P4 / P5 / B7: 미작성 (각 트랙별로 별도 plan 작성 필요)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "okstra",
-  "version": "0.72.0",
+  "version": "0.73.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.72.0",
-  "builtAt": "2026-06-11T07:01:57.638Z",
+  "package": "0.73.0",
+  "builtAt": "2026-06-11T14:40:52.876Z",
   "repoRoot": "/home/runner/work/okstra/okstra"
 }

package/runtime/agents/SKILL.md

@@ -42,7 +42,7 @@ This SKILL.md is the operating contract and phase index. Detailed procedures liv
 | 4. Execution | Spawn analysis workers (Teams preferred) | `okstra-team-contract` |
 | 5. Fallback | Sequential/background dispatch when Teams unavailable | `okstra-team-contract` |
 | 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" |
+| 5.6 Critic pass | (opt-in) reused-worker critic pass: coverage gaps (discovery/error-analysis/impl-planning) or acceptance devil's-advocate (final-verification). The critic dispatch fires concurrently with the first 5.5 reverify round (its input is fixed at Round 0); gap/blocker verification (one round) completes here | `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, 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" |
 
@@ -94,7 +94,7 @@ Required checkpoints:
 - `PROGRESS: phase-5-poll pending=<n> done=<m>` — emitted on each wakeup while the pending set is non-empty.
 - `PROGRESS: phase-5-collect worker=<role> status=<terminal-status>` — once per worker, immediately after the result file is verified.
 - `PROGRESS: phase-5.5-convergence round=<N> queue=<count>` — at the start of each convergence round (Phase 5.5).
-- `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-5.6-critic provider=<provider> gaps=<n>` — after the critic result is collected (Phase 5.6, opt-in; the critic dispatch itself fires concurrently with the first 5.5 reverify round). 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 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.

package/runtime/prompts/profiles/error-analysis.md

@@ -32,7 +32,7 @@
   - **Evidence note required inside `Statement`**: every clarification row includes `Evidence checked: <path:line>` or `Evidence checked: none — <reporter-only reason>` in the `Statement` cell. `none` is allowed ONLY when the row's nature is "only the reporter can answer this" (reporter-side data, business priority, environment they observed). A row with `none` that *could* have been answered by code or logs is a defect.
 - Cross-verification mode:
   - Phase 5.5 convergence runs in **adversarial mode** for this phase (`convergence.adversarial=true`). Verifiers actively try to refute each root-cause / reproduction claim by directly re-inspecting the cited code, logs, or config; the burden of proof sits on the claim. See `skills/okstra-convergence/SKILL.md` §"Adversarial Verification Mode". A single evidence-backed refutation prevents a finding from reaching consensus.
-  - **Coverage critic (opt-in)**: when `convergence.critic.enabled=true` (chosen via the okstra-run picker or `--critic`), a reused-worker critic pass runs after convergence to surface missed findings; its gaps are merged only after a 1-round adversarial reverify. See `skills/okstra-convergence/SKILL.md` "Coverage critic pass".
+  - **Coverage critic (opt-in)**: when `convergence.critic.enabled=true` (chosen via the okstra-run picker or `--critic`), a reused-worker critic pass is dispatched concurrently with the first convergence reverify round to surface missed findings; its gaps are merged only after a 1-round adversarial reverify that follows convergence. See `skills/okstra-convergence/SKILL.md` "Coverage critic pass".
 - Non-goals:
   - implementation details unless they are necessary to validate the cause
   - **source code edits, builds, migrations, or deployments** — this run produces evidence and cause analysis only; the fix belongs to a later `implementation-planning` run followed by an `implementation` run

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

@@ -48,7 +48,7 @@
   4. **Verifier dissent preserved** — if workers reach different verdicts, the disagreement is visible in section 1.2; synthesis hides nothing.
   5. **No source-mutation audit** — scan the run's session transcripts for Edit / Write or state-mutating Bash commands that touch paths OUTSIDE `<PROJECT_ROOT>/.okstra/**` and outside the assigned run-artifact paths. Writes to worker prompts, audit sidecars, team-state, the final-report `data.json`, and rendered reports under the run directory are allowed okstra artifacts. Any source/schema/deployment mutation means the run has crossed into implementation and MUST be re-routed; do NOT silently strip the evidence.
 - Cross-verification mode:
-  - **Acceptance critic (opt-in)**: when `convergence.critic.enabled=true` (chosen via the okstra-run picker or `--critic`), a reused-worker **acceptance devil's-advocate** pass runs after convergence to surface candidate acceptance blockers the verifiers may have missed. Each candidate is verified **confirm-or-downgrade**: confirmed → an `Acceptance Blockers` row (which, since `accepted` requires zero blockers, moves the verdict to `conditional-accept` / `blocked`); unconfirmed → a `Residual Risk` row (never dropped). See `skills/okstra-convergence/SKILL.md` "Acceptance critic pass (final-verification)".
+  - **Acceptance critic (opt-in)**: when `convergence.critic.enabled=true` (chosen via the okstra-run picker or `--critic`), a reused-worker **acceptance devil's-advocate** pass is dispatched concurrently with the first convergence reverify round to surface candidate acceptance blockers the verifiers may have missed; candidates are verified only after convergence completes. Each candidate is verified **confirm-or-downgrade**: confirmed → an `Acceptance Blockers` row (which, since `accepted` requires zero blockers, moves the verdict to `conditional-accept` / `blocked`); unconfirmed → a `Residual Risk` row (never dropped). See `skills/okstra-convergence/SKILL.md` "Acceptance critic pass (final-verification)".
 - Non-goals:
   - proposing unrelated refactors beyond the delivered scope
   - **source code edits, follow-up bug fixes, or scope expansion** — this run renders a verdict only; defects detected here become inputs to a new `error-analysis` or `implementation-planning` run

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

@@ -41,7 +41,7 @@
 - Cross-verification mode:
   - Phase 5.5 finding convergence runs in **adversarial mode** for this phase (`convergence.adversarial=true`). Verifiers actively try to refute each worker finding (requirement gap / risk / option) by re-inspecting its cited evidence; the burden of proof sits on the claim. See `skills/okstra-convergence/SKILL.md` §"Adversarial Verification Mode".
   - §5.5.9 plan-body verification runs with an **adversarial posture** (`skills/okstra-convergence/SKILL.md` §"Adversarial plan-body posture"): verifiers open and confirm every cited path / command and put the burden of proof on the plan. The gate threshold is unchanged — a *majority* `DISAGREE` (`majority-disagree`) is still required to block approval; a single dissent does not.
-  - **Coverage critic (opt-in)**: when `convergence.critic.enabled=true` (chosen via the okstra-run picker or `--critic`), a reused-worker critic pass runs after convergence to surface missed findings; its gaps are merged only after a 1-round adversarial reverify. See `skills/okstra-convergence/SKILL.md` "Coverage critic pass".
+  - **Coverage critic (opt-in)**: when `convergence.critic.enabled=true` (chosen via the okstra-run picker or `--critic`), a reused-worker critic pass is dispatched concurrently with the first convergence reverify round to surface missed findings; its gaps are merged only after a 1-round adversarial reverify that follows convergence. See `skills/okstra-convergence/SKILL.md` "Coverage critic pass".
 - Non-goals:
   - code-level micro-optimization unless it changes the implementation approach
   - **source code edits of any kind** — this run produces a plan document only; Edit/Write on project source files is forbidden until the plan is approved and a separate `implementation` run starts

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

@@ -53,7 +53,7 @@
   - **Evidence note required inside `Statement`**: every clarification row includes `Evidence checked: <path:line>` or `Evidence checked: none — <human-only reason>` in the `Statement` cell. `none` is allowed ONLY when the row's nature is "only a human can answer this" (reporter intent, business priority, external authority). A row with `none` that *could* have been answered by the codebase is a defect.
 - Cross-verification mode:
   - Phase 5.5 convergence runs in **adversarial mode** for this phase (`convergence.adversarial=true`). Verifiers actively try to refute each worker's finding by directly re-inspecting the cited evidence; the burden of proof sits on the claim. See `skills/okstra-convergence/SKILL.md` §"Adversarial Verification Mode". A single evidence-backed refutation prevents a finding from reaching consensus.
-  - **Coverage critic (opt-in)**: when `convergence.critic.enabled=true` (chosen via the okstra-run picker or `--critic`), a reused-worker critic pass runs after convergence to surface missed findings; its gaps are merged only after a 1-round adversarial reverify. See `skills/okstra-convergence/SKILL.md` "Coverage critic pass".
+  - **Coverage critic (opt-in)**: when `convergence.critic.enabled=true` (chosen via the okstra-run picker or `--critic`), a reused-worker critic pass is dispatched concurrently with the first convergence reverify round to surface missed findings; its gaps are merged only after a 1-round adversarial reverify that follows convergence. See `skills/okstra-convergence/SKILL.md` "Coverage critic pass".
 - Non-goals:
   - full implementation design unless it is required to decide the next phase
   - **source code edits, plan authoring, builds, or deployments** — this run only classifies the work and routes it; deeper analysis and planning belong to subsequent phases

package/runtime/python/okstra_ctl/clarification_items.py

@@ -299,3 +299,29 @@ def section_1_present_but_unparsed(report_text: str) -> bool:
     if SECTION_HEADING_PATTERN.search(report_text):
         return False
     return bool(_LOOSE_SECTION_1_RE.search(report_text))
+
+
+def clarification_response_with_sidecars(source: Path) -> str:
+    """clarification-response 원문 뒤에 `user-responses/` 사이드카를 덧붙인 본문.
+
+    ``source`` 가 ``runs/<task-type>/reports/final-report-*.md`` 레이아웃일 때만
+    형제 ``user-responses/`` 디렉토리를 찾는다(HTML 뷰의 `Export user response`
+    가 내려준 파일을 사용자가 거기 저장). 그 외 경로·사이드카 부재 시 원문 그대로 —
+    호출자는 항상 이 함수를 거쳐 instruction-set 사본을 쓰면 된다.
+    """
+    text = source.read_text(encoding="utf-8")
+    responses_dir = source.parent.parent / "user-responses"
+    if source.parent.name != "reports" or not responses_dir.is_dir():
+        return text
+    sidecars = sorted(
+        p for p in responses_dir.glob("user-response-*.md") if p.is_file()
+    )
+    if not sidecars:
+        return text
+    parts = [text.rstrip("\n"), "\n\n---\n\n# Attached User Responses\n"]
+    for sidecar in sidecars:
+        parts.append(
+            f"\n## {sidecar.name}\n\n"
+            f"{sidecar.read_text(encoding='utf-8').strip()}\n"
+        )
+    return "".join(parts)

package/runtime/python/okstra_ctl/context_cost.py

@@ -306,19 +306,46 @@ def _analysis_worker_metric(task_root: Path, project_root: Path) -> dict:
     }
 
 
+_SEQ_RESULT_RE = re.compile(r"-(\d{3,})\.md$")
+
+
+def _current_seq_worker_results(run_dir: Path) -> list[Path]:
+    """현재 run seq 의 분석 worker 결과만 추린다.
+
+    같은 worker-results 디렉토리에 seq-less 레거시(`codex-worker.md`)와 이전
+    seq 결과가 공존한다(관측: dev-9186 에 5월 레거시 72KB 혼입 → reportWriter
+    표면 과대 측정). 실 dispatch 계약은 현재 seq 파일만 열거하므로 max seq 로
+    스코핑한다."""
+    candidates = [
+        path for path in (run_dir / "worker-results").glob("*.md")
+        if "-audit-" not in path.name and "report-writer" not in path.name
+    ]
+    by_seq: dict[str, list[Path]] = {}
+    for path in candidates:
+        match = _SEQ_RESULT_RE.search(path.name)
+        if match:
+            by_seq.setdefault(match.group(1), []).append(path)
+    if not by_seq:
+        return []
+    return sorted(by_seq[max(by_seq)])
+
+
 def _report_writer_metric(run_dir: Path | None, task_root: Path, project_root: Path) -> dict:
     instruction_set = task_root / "instruction-set"
     files = [instruction_set / name for name in INPUT_FILES]
+    # 실 dispatch 계약(report-writer prompt 의 required reading)은 packet 이
+    # 있으면 analysis-material 대신 analysis-packet 을 읽는다 — worker metric
+    # 의 packet-primary 규칙과 동일.
+    packet = instruction_set / "analysis-packet.md"
+    if packet.is_file():
+        files = [path for path in files if path.name != "analysis-material.md"]
+        files.append(packet)
     files.extend([
         instruction_set / "final-report-template.md",
         instruction_set / "final-report-schema.json",
     ])
     if run_dir is not None:
-        worker_results = run_dir / "worker-results"
-        files.extend(
-            path for path in worker_results.glob("*.md")
-            if "-audit-" not in path.name and "report-writer" not in path.name
-        )
+        files.extend(_current_seq_worker_results(run_dir))
         convergence = _latest_matching_file(
             run_dir / "state", f"convergence-{run_dir.name}-*.json"
         )

package/runtime/python/okstra_ctl/report_views.py

@@ -109,6 +109,8 @@ def render_html(src_md: str, *, run_meta: RunMeta, css: str, js: str) -> str:
 
     title = html.escape(f"{run_meta.task_key} — {run_meta.task_type} #{run_meta.seq}")
     response_ids_json = "[" + ",".join('"' + html.escape(rid) + '"' for rid in response_ids) + "]"
+    sidecar_name = html.escape(f"user-response-{run_meta.task_type}-{run_meta.seq}.md")
+    sidecar_dir = html.escape(f"runs/{run_meta.task_type}/user-responses/")
 
     return (
         f"<!DOCTYPE html>\n"
@@ -127,6 +129,8 @@ def render_html(src_md: str, *, run_meta: RunMeta, css: str, js: str) -> str:
         f"<main>{body_html}</main>\n"
         f"<footer class=\"report-footer\">\n"
         f"  <button type=\"button\" data-action=\"export-user-response\">Export user response</button>\n"
+        f"  <p class=\"user-response-hint\">Export 클릭 시 <code>{sidecar_name}</code> 가 다운로드됩니다 — "
+        f"<code>{sidecar_dir}</code> 에 저장하면 resume-clarification 이 자동으로 첨부합니다.</p>\n"
         f"  <pre id=\"user-response-output\" aria-live=\"polite\"></pre>\n"
         f"  <button type=\"button\" data-action=\"copy-user-response\">Copy</button>\n"
         f"</footer>\n"
@@ -353,6 +357,10 @@ def _emit_table(lines: list[str], start: int, section_path: list[str]) -> tuple[
         (j for j, h in enumerate(header_cells) if h.startswith("Statement")),
         -1,
     )
+    expected_form_col = next(
+        (j for j, h in enumerate(header_cells) if h.startswith("Expected form")),
+        -1,
+    )
     user_input_col = (
         header_cells.index("User input") if "User input" in header_cells else -1
     )
@@ -367,11 +375,14 @@ def _emit_table(lines: list[str], start: int, section_path: list[str]) -> tuple[
             statement = (
                 row[statement_col] if 0 <= statement_col < len(row) else ""
             )
+            expected_form = (
+                row[expected_form_col] if 0 <= expected_form_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(meta.row_id, meta.kind, meta.status, cell, statement)}</td>"
+                        f"<td>{_form_control(meta.row_id, meta.kind, meta.status, cell, statement, expected_form)}</td>"
                     )
                 else:
                     cells_html.append(
@@ -439,12 +450,51 @@ def _parse_enum_options(statement: str) -> list[tuple[str, str]]:
     return out if len(out) >= 2 else []
 
 
+_RECOMMENDED_CUE = "Recommended:"
+_ALTERNATIVES_CUE = "Alternatives:"
+
+
+def _parse_expected_form_options(expected_form: str) -> list[tuple[str, str]]:
+    """Parse the ``Expected form`` contract format
+    (``Recommended: <answer> — <rationale>; Alternatives: <options>``,
+    `_common-contract.md` §Clarification request policy) into select
+    ``(value, label)`` options. Returns ``[]`` when the cell carries no
+    ``Recommended:`` cue — the caller falls back to the statement enum."""
+    if not expected_form:
+        return []
+    rec_idx = expected_form.find(_RECOMMENDED_CUE)
+    if rec_idx < 0:
+        return []
+    rec_body = expected_form[rec_idx + len(_RECOMMENDED_CUE):]
+    alt_body = ""
+    alt_idx = rec_body.find(_ALTERNATIVES_CUE)
+    if alt_idx >= 0:
+        alt_body = rec_body[alt_idx + len(_ALTERNATIVES_CUE):]
+        rec_body = rec_body[:alt_idx]
+    # The rationale follows " — "; the option keeps only the answer part.
+    answer = rec_body.split(" — ", 1)[0].strip(" .,;—-")
+    options: list[tuple[str, str]] = []
+    if answer:
+        options.append(("recommended", f"추천: {answer}"))
+    enum_alts = _parse_enum_options(alt_body)
+    if enum_alts:
+        options.extend(
+            (letter, f"({letter}) {text}") for letter, text in enum_alts
+        )
+    else:
+        alt_text = alt_body.strip(" .,;—-")
+        if alt_text:
+            options.append(("alternative", alt_text))
+    return options
+
+
 def _form_control(
     response_id: str,
     kind: str,
     status: str,
     current_value: str,
     statement: str = "",
+    expected_form: str = "",
 ) -> str:
     rid = html.escape(response_id)
     disabled = "" if status.lower() in ("open", "answered", "") else " disabled"
@@ -456,14 +506,21 @@ def _form_control(
         "data-point": "값",
     }.get(kind_lc, "응답")
 
-    # decision 인 경우 statement 에서 (a)(b)(c) 후보를 추출해 select+기타 input 으로 렌더.
+    # decision 의 후보는 Expected form 의 `Recommended: …; Alternatives: …`
+    # 계약(_common-contract.md §Clarification request policy)이 1순위,
+    # statement 안 (a)(b)(c) 열거가 fallback. 후보가 있으면 select+기타 input.
     if kind_lc == "decision":
-        opts = _parse_enum_options(statement)
+        opts = _parse_expected_form_options(expected_form)
+        if not opts:
+            opts = [
+                (letter, f"({letter}) {text}")
+                for letter, text in _parse_enum_options(statement)
+            ]
         if opts:
             select_opts = "".join(
-                f'<option value="{letter}">'
-                f'{_inline(f"({letter}) " + text)}</option>'
-                for letter, text in opts
+                f'<option value="{html.escape(value)}">'
+                f"{_inline(label)}</option>"
+                for value, label in opts
             )
             select_html = (
                 f'<select name="{rid}" data-response-id="{rid}" '

package/runtime/python/okstra_ctl/run.py

@@ -30,7 +30,7 @@ from okstra_project import project_json_path, upsert_project_json
 from okstra_project.state import slugify
 from . import fix_cycles
 from .analysis_packet import build_analysis_packet
-from .clarification_items import scan_approval_gate
+from .clarification_items import clarification_response_with_sidecars, scan_approval_gate
 from .qa_commands import format_errors as _format_qa_errors, validate_qa_commands
 from .material import (
     build_analysis_material,
@@ -1776,9 +1776,9 @@ def _write_instruction_set_sources(
     (instruction_set / "analysis-material.md").write_text(review_material, encoding="utf-8")
     shutil.copyfile(inp.brief_path, instruction_set / "task-brief.md")
     if inp.clarification_response_path:
-        shutil.copyfile(
-            inp.clarification_response_path,
-            instruction_set / "clarification-response.md",
+        (instruction_set / "clarification-response.md").write_text(
+            clarification_response_with_sidecars(Path(inp.clarification_response_path)),
+            encoding="utf-8",
         )
     if inp.directive:
         (instruction_set / "directive.txt").write_text(inp.directive + "\n", encoding="utf-8")

package/runtime/python/okstra_token_usage/claude.py

@@ -2,12 +2,18 @@
 from __future__ import annotations
 
 import json
+import re
 from datetime import datetime
 from pathlib import Path
 
 from .cursor import MAX_NEEDLES, fresh_cache, load_cache, save_cache
 from .paths import claude_project_dir, ts_in_window
 
+# lead 의 단계 체크포인트 라인(agents/SKILL.md "Progress reporting") — phase id 가
+# `phase-<digit>` 로 시작하는 라인만 마커로 인정해 일반 대화의 오탐을 줄인다.
+_PROGRESS_RE = re.compile(r"^PROGRESS:\s+(phase-\d\S*(?:[ \t].*)?)$", re.MULTILINE)
+_PROGRESS_MARKER_MAX_CHARS = 160
+
 
 def _event_from_record(rec: dict) -> dict | None:
     """jsonl 레코드 1개 → 압축 이벤트. 집계에 기여하지 않으면 None.
@@ -48,6 +54,18 @@ def _event_from_record(rec: dict) -> dict | None:
                     if isinstance(b, dict) and b.get("type") == "tool_use")
         if tools:
             ev["u"] = tools
+        markers = [
+            m.group(1).strip()[:_PROGRESS_MARKER_MAX_CHARS]
+            for b in (msg.get("content") or [])
+            if isinstance(b, dict) and b.get("type") == "text"
+            for m in _PROGRESS_RE.finditer(b.get("text") or "")
+        ]
+        # 서로 다른 phase id 가 한 메시지에 섞이면 계약 인용/회고 요약이라 그
+        # 시각은 단계 경계가 아니다(관측: dev-9186 run 의 막판 요약 1건이 전
+        # phase 의 lastAt 을 오염). 같은 phase id 의 반복(병렬 dispatch 3줄,
+        # intake reading+complete)은 라이브 체크포인트로 인정한다.
+        if markers and len({m.split(None, 1)[0] for m in markers}) == 1:
+            ev["p"] = markers
     ts = rec.get("timestamp") or msg.get("timestamp")
     if ts:
         ev["t"] = ts
@@ -133,6 +151,7 @@ def _totals_from_events(events: list[dict], agent_name: str | None,
     input_t = output_t = cache_create_t = cache_read_t = 0
     cache_create_5m_t = cache_create_1h_t = 0
     tool_uses = 0
+    progress_markers: list[dict] = []
     first_ts: str | None = None
     last_ts: str | None = None
     for ev in events:
@@ -146,6 +165,8 @@ def _totals_from_events(events: list[dict], agent_name: str | None,
         cache_create_1h_t += ev.get("c1", 0)
         cache_read_t += ev.get("r", 0)
         tool_uses += ev.get("u", 0)
+        for marker in ev.get("p", ()):
+            progress_markers.append({"at": ts, "marker": marker})
         if ts:
             if first_ts is None or ts < first_ts:
                 first_ts = ts
@@ -179,6 +200,7 @@ def _totals_from_events(events: list[dict], agent_name: str | None,
         "model": model,
         "startedAt": first_ts,
         "endedAt": last_ts,
+        "progressMarkers": progress_markers,
     }
 
 

package/runtime/python/okstra_token_usage/collect.py

@@ -141,6 +141,51 @@ def resolve_run_window(team_state_path: Path, state: dict) -> tuple[str | None,
     return since, until
 
 
+def _wall_ms(start_iso: str | None, end_iso: str | None) -> int | None:
+    if not start_iso or not end_iso:
+        return None
+    try:
+        a = datetime.fromisoformat(start_iso.replace("Z", "+00:00"))
+        b = datetime.fromisoformat(end_iso.replace("Z", "+00:00"))
+    except ValueError:
+        return None
+    return max(0, int((b - a).total_seconds() * 1000))
+
+
+def phase_timeline(markers: list[dict]) -> dict:
+    """lead 의 PROGRESS 체크포인트(agents/SKILL.md "Progress reporting")로
+    run 내부 단계 경계 wall-clock 을 복원한다 (perf plan v2 P0 계측).
+
+    phase id = marker 의 첫 토큰(`phase-5.5-convergence` 등). 같은 phase 의
+    반복 마커(poll/collect/dispatch)는 first/last 로 접는다. `wallMsToNext` 는
+    다음 phase 의 firstAt 까지 — 마지막 phase 는 None(run 종료 신호가 마커에
+    없으므로 추정하지 않는다). 마커가 하나도 없으면 phases 가 빈 채로 남아
+    "이 run 은 측정 불가"를 명시적으로 표현한다.
+    """
+    phases: list[dict] = []
+    by_id: dict[str, dict] = {}
+    for m in markers:
+        at = m.get("at")
+        phase_id = (m.get("marker") or "").split(None, 1)[0]
+        if not phase_id:
+            continue
+        entry = by_id.get(phase_id)
+        if entry is None:
+            entry = {"phase": phase_id, "firstAt": at, "lastAt": at,
+                     "markerCount": 0, "wallMsToNext": None}
+            by_id[phase_id] = entry
+            phases.append(entry)
+        entry["markerCount"] += 1
+        if at:
+            if entry["firstAt"] is None or at < entry["firstAt"]:
+                entry["firstAt"] = at
+            if entry["lastAt"] is None or at > entry["lastAt"]:
+                entry["lastAt"] = at
+    for current, nxt in zip(phases, phases[1:]):
+        current["wallMsToNext"] = _wall_ms(current["firstAt"], nxt["firstAt"])
+    return {"source": "lead-progress-markers", "phases": phases}
+
+
 def resolve_team_name(state: dict) -> str:
     """team-state 에서 이 run 의 team name 을 해소한다.
 
@@ -232,6 +277,7 @@ def collect(team_state_path: Path, project_root: Path | None = None, *,
                                        incremental=incremental)
         state["leadUsage"] = usage_block(totals, source="claude-jsonl")
         state["leadUsage"]["sessionId"] = lead_sid
+        state["phaseTimeline"] = phase_timeline(totals.get("progressMarkers") or [])
     else:
         state["leadUsage"] = na_block(
             f"lead session jsonl not found under {claude_project_dir(cwd)} (sessionId={lead_sid})"

package/runtime/python/okstra_token_usage/cursor.py

@@ -18,7 +18,9 @@ from pathlib import Path
 
 from okstra_project.dirs import okstra_home
 
-CACHE_SCHEMA_VERSION = 1
+# v2: usage 이벤트에 `p`(lead PROGRESS 마커) 키 추가 — v1 캐시는 이미 스캔한
+# 구간의 마커가 없으므로 폐기하고 전체 재스캔한다(fail-open).
+CACHE_SCHEMA_VERSION = 2
 IDENTITY_PREFIX_BYTES = 256
 MAX_NEEDLES = 16
 

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

@@ -1242,9 +1242,10 @@
 
     "ValidationCheckRow": {
       "type": "object",
-      "required": ["phase", "ticketId", "check", "commandOrObservation", "expectedOutcome"],
+      "required": ["id", "phase", "ticketId", "check", "commandOrObservation", "expectedOutcome"],
       "additionalProperties": false,
       "properties": {
+        "id": { "type": "string", "pattern": "^VC-\\d{3,}$" },
         "phase": { "enum": ["pre", "mid", "post"] },
         "ticketId": { "$ref": "#/$defs/TicketId" },
         "check": { "type": "string", "minLength": 1 },

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

@@ -519,14 +519,18 @@ Schema rules:
 Runs only when `convergence.critic.enabled == true` (set by `--critic <provider>` or the okstra-run `critic_pick` step; default off). Applies to the three finding-producing phases (`requirements-discovery`, `error-analysis`, `implementation-planning`); for `final-verification` the critic runs in a different mode — see §"Acceptance critic pass (final-verification)". This pass targets **coverage** (missed findings), distinct from convergence which targets **agreement quality**.
 
 ### When
-After Phase 5.5 finding convergence completes (findings classified) and BEFORE the Phase 6 report-writer dispatch.
+
+The critic input is the Round 0 consolidated finding list. Reverify rounds only classify findings — they never add or remove them (in-round queue insertions are forbidden, see §"Convergence State Artifact" `carriedForwardCount`) — so the critic dispatch MUST NOT wait for classification to finish:
+
+- **Dispatch**: immediately after Round 0 grouping, CONCURRENTLY with the first reverify round's dispatches. When the verification queue is empty after Round 0 (no reverify round runs), dispatch right after grouping. Concurrent dispatch to the same provider is safe — the critic result path (`<provider>-critic-...`) never collides with a reverify result path.
+- **Gap verification + merge**: only after BOTH the finding-convergence loop has exited AND the critic result is collected, and BEFORE the Phase 6 report-writer dispatch. If the loop exited `aborted-non-result`, do NOT dispatch a gap-verification round — surface the gaps as unverified `clarification` items per §"Gap verification" and record that fact.
 
 ### Dispatch (reused worker)
 Dispatch ONE pass to the `config.critic.provider`'s existing subagent (`claude-worker` / `codex-worker` / `gemini-worker`) with `model = config.critic.modelExecutionValue` — no new agent type. If `config.critic.modelExecutionValue` is null/empty (model could not be resolved), skip the critic pass and record `critic-skipped: model-unresolved` in the convergence state rather than dispatching with no model. Result path: `runs/<task-type>/worker-results/<provider>-critic-<task-type>-<seq>.md`. The critic prompt seeds the consolidated findings and asks ONLY for coverage gaps:
 
 ```
-You are the coverage critic for <task-key>. Below are the findings the workers
-already agreed on. Your ONLY job is to name what is MISSING:
+You are the coverage critic for <task-key>. Below are the consolidated findings
+the workers produced. Your ONLY job is to name what is MISSING:
 - files / directories / execution paths nobody inspected,
 - requirements or acceptance points with zero findings,
 - claims raised but never verified.
@@ -543,7 +547,7 @@ Each critic gap enters the verification queue as a finding with `originWorker =
 
 ## Acceptance critic pass (final-verification)
 
-The `final-verification` phase reuses the SAME reused-worker dispatch as §"Coverage critic pass" (provider + `config.critic.modelExecutionValue` from the `convergence.critic` block; default off; same model-unresolved skip rule). Only the prompt, the verification semantics, and the output sink differ — final-verification's findings are defects/blockers, so the critic acts as an **acceptance devil's advocate** (find reasons NOT to accept), and its candidate blockers are NEVER dropped (that would suppress real defects).
+The `final-verification` phase reuses the SAME reused-worker dispatch AND the same dispatch timing as §"Coverage critic pass" §"When" (provider + `config.critic.modelExecutionValue` from the `convergence.critic` block; default off; same model-unresolved skip rule) — the delivered work the critic inspects is likewise fixed before the reverify round starts. Only the prompt, the verification semantics, and the output sink differ — final-verification's findings are defects/blockers, so the critic acts as an **acceptance devil's advocate** (find reasons NOT to accept), and its candidate blockers are NEVER dropped (that would suppress real defects).
 
 ### Prompt
 

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

@@ -425,6 +425,15 @@ Display rule for `workerId` vs `agent`:
 
 Never write `claude (claude)` — the parenthesized agent is shown only when it adds information.
 
+**C. Per-run phase breakdown (when `phaseTimeline` is present):**
+
+team-state written by collector ≥ v0.73 carries a `phaseTimeline` block — the Phase 7 collector reconstructs lead operating-phase boundaries from the lead session's `PROGRESS: phase-*` checkpoint lines (`{source: "lead-progress-markers", phases: [{phase, firstAt, lastAt, markerCount, wallMsToNext}]}`).
+
+- When the user asks for a per-phase / per-run breakdown ("단계별", "phase별", "어느 단계가 오래"), render one table per requested run: `| Phase | Start | Wall to next |` using `firstAt` and `wallMsToNext`.
+- `wallMsToNext` is `null` on the last phase (the run-end signal is not a marker) — render `--`.
+- `phases: []` means the lead emitted no markers (run predates the contract, or markers were skipped) — say "phase timeline 측정 불가(마커 없음)" rather than estimating from other fields.
+- Older team-state files have no `phaseTimeline` key at all — omit the section silently.
+
 **Timestamp parsing:** for `startedAt` / `endedAt`, normalize ISO-8601: replace trailing `Z` with `+00:00`, accept explicit offsets as-is, parse via `datetime.fromisoformat(s.replace("Z", "+00:00"))`. Strings without an offset are assumed UTC. Mixed-form comparisons must be done as `datetime` objects, never raw strings.
 
 ### time.4 — Format output
@@ -458,6 +467,17 @@ Never write `claude (claude)` — the parenthesized agent is shown only when it
 | report-writer  | 2    | 00:01:00 | 00:00:30 |
 
 > Unavailable: 1 run (implementation / 2026-04-30_03-03-48) — team-state has no durationMs (Phase 7 not reached)
+
+### Phase breakdown — requirements-discovery (run 002)
+
+| Phase                  | Start (UTC)      | Wall to next |
+|------------------------|------------------|--------------|
+| phase-1-intake         | 2026-06-11 09:00 | 00:04:00     |
+| phase-2-prompts        | 2026-06-11 09:04 | 00:02:10     |
+| phase-4-dispatch       | 2026-06-11 09:06 | 00:18:30     |
+| phase-5.5-convergence  | 2026-06-11 09:25 | 00:21:00     |
+| phase-6-synthesis      | 2026-06-11 09:46 | 00:15:00     |
+| phase-7-persist        | 2026-06-11 10:01 | --           |
 ```
 
 **Rules:**

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

@@ -105,7 +105,7 @@ The four steps below MUST execute in this exact order. Reordering them is the re
    ```
 
    Output (idempotent — re-running overwrites):
-   - `runs/<task-type>/reports/final-report-<task-type>-<seq>.html` — single-file self-contained human view, **generated only when the report has at least one §5 `C-*` clarification row**. Those rows with `Status` ∈ {`open`, `answered`} embed form widgets (`<select>` for enum-style decisions, `<input>` for material / data-point kinds, `<textarea>` fallback); an `Export user response` button serialises form values to a markdown sidecar (schema in [`templates/reports/user-response.template.md`](../../templates/reports/user-response.template.md)) that the user pastes to `runs/<task-type>/user-responses/user-response-<task-type>-<seq>.md`. The original final-report MD is **never** mutated by user input — the sidecar is the single write target.
+   - `runs/<task-type>/reports/final-report-<task-type>-<seq>.html` — single-file self-contained human view, **generated only when the report has at least one §5 `C-*` clarification row**. Those rows with `Status` ∈ {`open`, `answered`} embed form widgets (`<select>` for enum-style decisions, `<input>` for material / data-point kinds, `<textarea>` fallback); an `Export user response` button serialises form values to a markdown sidecar (schema in [`templates/reports/user-response.template.md`](../../templates/reports/user-response.template.md)) and downloads it as `user-response-<task-type>-<seq>.md`; the user saves it to `runs/<task-type>/user-responses/`, and `--resume-clarification` auto-appends every sidecar found there to the next run's `clarification-response.md` (`clarification_items.clarification_response_with_sidecars`). The original final-report MD is **never** mutated by user input — the sidecar is the single write target.
    - When the report has **no** `C-*` clarification rows, the html carries no interactive forms (it would only duplicate the MD), so the renderer prints `html: skipped (...)` and writes nothing. This is the expected state for clarification-free runs — `validators/validate-report-views.py` treats "no C-* rows + no html" as a pass, not a missing artifact.
 
    Must run AFTER step 1 (so token placeholders are substituted in any rendered html) and BEFORE step 2 (so the html artifact, when generated, exists for the validator step that checks it).
@@ -276,7 +276,7 @@ Section numbering follows `templates/reports/final-report.template.md` exactly
 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 (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).
+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). **Approval-gate consistency:** when §1 carries any `Blocks: approval` row with `Status` ∈ {open, answered}, the Verdict Card `Next Step` and the first recommended step MUST point to the clarification rerun (`resume-clarification` of the SAME task-type) — never to "frontmatter `approved: true` 플립 → `implementation` 직행". Run-prep enforces this gate (`run.py _validate_approved_plan` fail-closes on those rows and on a blocking data.json `gateResult`), so a direct-implementation next-step is an instruction the reader cannot actually follow.
 7. **Follow-up Tasks** — auto-spawn-eligible table. Each row drives `okstra-spawn-followups.py`; see template §7 for the row schema.
 
 **§5.10 Fix History (data-presence gated).** When the run-manifest carries a `fixCycleId`, fill the data.json `fixCycle` block (`cycle` / `targetReport` / `symptom` / `runs`). Read the values from the task root's `history/fix-cycles.jsonl`: `cycle` MUST equal `fixCycleId`, `targetReport` / `symptom` come from that cycle's `opened` row, and `runs` lists its attached `run` rows (`taskType` / `runSeq` / `runManifest`). The validator (`validators/validate-run.py` → `_validate_fix_cycle`) fails the run when the block is missing or `fixCycle.cycle` does not match `fixCycleId`. When the run-manifest has no `fixCycleId`, OMIT the `fixCycle` block entirely — the renderer omits §5.10.

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

@@ -202,10 +202,10 @@ implementation-option: {{ frontmatter.implementationOption | yaml_scalar }}
 
 ### Validation Checklist{% if t("sectionAside.validationChecklist") != "Validation Checklist" %} ({{ t("sectionAside.validationChecklist") }}){% endif %}
 
-| Phase | Ticket ID | Check | Command / Observation | Expected outcome |
-|-------|-----------|-------|------------------------|-------------------|
+| ID | Phase | Ticket ID | Check | Command / Observation | Expected outcome |
+|----|-------|-----------|-------|------------------------|-------------------|
 {% for row in implementationPlanning.validationChecklist -%}
-| {{ row.phase }} | `{{ row.ticketId }}` | {{ row.check }} | `{{ row.commandOrObservation }}` | {{ row.expectedOutcome }} |
+| {{ row.id }} | {{ row.phase }} | `{{ row.ticketId }}` | {{ row.check }} | `{{ row.commandOrObservation }}` | {{ row.expectedOutcome }} |
 {% endfor %}
 
 ### Rollback Strategy{% if t("sectionAside.rollbackStrategy") != "Rollback Strategy" %} ({{ t("sectionAside.rollbackStrategy") }}){% endif %}

package/runtime/templates/reports/report.js

@@ -9,8 +9,11 @@
  *      (everything else / fallback).
  *   2. Serialise the entries into markdown whose bytes are IDENTICAL
  *      to scripts/okstra_ctl/report_views.py serialize_user_response.
- *   3. Write the result to <pre id="user-response-output"> and offer a
- *      [Copy] button.
+ *   3. Write the result to <pre id="user-response-output">, offer a
+ *      [Copy] button, and download it as
+ *      user-response-<task-type>-<seq>.md — the user drops that file in
+ *      runs/<task-type>/user-responses/ and --resume-clarification
+ *      auto-appends it to the next run's clarification-response.md.
  *
  * The byte-identity contract is enforced by tests/test_report_views.py
  * which spawns Node to execute buildUserResponseMarkdown and diffs the
@@ -143,12 +146,30 @@
     return head + chunks;
   }
 
+  function downloadUserResponse(md, runMeta) {
+    var name =
+      "user-response-" + (runMeta["task-type"] || "report") + "-" +
+      (runMeta["seq"] || "000") + ".md";
+    var blob = new Blob([md], { type: "text/markdown" });
+    var url = URL.createObjectURL(blob);
+    var a = document.createElement("a");
+    a.href = url;
+    a.download = name;
+    document.body.appendChild(a);
+    a.click();
+    document.body.removeChild(a);
+    setTimeout(function () { URL.revokeObjectURL(url); }, 0);
+  }
+
   function exportUserResponse() {
     var runMeta = readRunMeta();
     var entries = collectEntries();
     var md = buildUserResponseMarkdown(runMeta, entries, isoNowUtc());
     var out = document.getElementById("user-response-output");
     if (out) out.textContent = md;
+    // Nothing answered yet — show the empty serialisation as feedback but
+    // don't download a useless file.
+    if (entries.length > 0) downloadUserResponse(md, runMeta);
     return md;
   }