okstra 0.102.2 → 0.102.3

package/docs/superpowers/plans/2026-06-12-html-plan-approval.md

@@ -1,1000 +0,0 @@
-# final-report HTML 승인·옵션 선택 구현 계획
-
-> **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking.
-
-**Goal:** implementation-planning final-report 의 HTML 뷰에 승인 체크 + 구현 옵션 선택 위젯을 추가하고, Export sidecar 의 `## APPROVAL` 블록을 implementation 마법사가 감지·확인 후 기존 승인 경로로 적용한다.
-
-**Architecture:** HTML 은 원본 md/data.json 을 절대 수정하지 않는다 — 위젯 값은 기존 user-response sidecar 에 `## APPROVAL` 블록으로 직렬화되고, 마법사 `approve_plan_confirm` 단계가 sidecar 를 감지해 기존 `_approve_plan_in_place`(data.json 플립) + `_apply_cli_implementation_option`(frontmatter 치환)을 재사용해 적용한다. 스펙: `docs/superpowers/specs/2026-06-12-html-plan-approval-design.md`.
-
-**Tech Stack:** Python 3.11 (scripts/okstra_ctl), vanilla JS (templates/reports/report.js), pytest (+ Node byte-identity 하니스).
-
-**전제 (이미 코드베이스에 있음):**
-- `scan_approval_gate` — `scripts/okstra_ctl/clarification_items.py` (§1 Blocks=approval 스캔, fail-closed).
-- `_approve_plan_in_place` / `_classify_approved_plan` — `scripts/okstra_ctl/wizard.py:538` / `:486`.
-- `_apply_cli_implementation_option` — `scripts/okstra_ctl/run.py:744`.
-- 마법사 prompt 텍스트 SOT — `prompts/wizard/prompts.ko.json` → `steps.approve_plan_confirm`.
-- 동시 세션 주의: `scripts/okstra_ctl/md_table.py`(escape_pipes/split_pipe_row)는 다른 세션이 작업 중인 미커밋 변경 — 그 파일을 수정하지도 커밋하지도 말 것. 커밋은 항상 이 계획의 파일만 `git add <paths>` 로 명시.
-
----
-
-### Task 1: Python serializer — `## APPROVAL` 블록
-
-**Files:**
-- Modify: `scripts/okstra_ctl/report_views.py` (serialize_user_response, ~:726)
-- Test: `tests/test_report_views.py`
-
-- [ ] **Step 1: 실패 테스트 작성** — `tests/test_report_views.py` 의 serializer 섹션(`test_python_and_js_serialisers_byte_identical_nonempty` 위)에 추가:
-
-```python
-def test_serialize_user_response_appends_approval_block():
-    from okstra_ctl.report_views import UserResponseApproval
-
-    meta = _meta("implementation-planning")
-    out = serialize_user_response(
-        run_meta=meta, entries=[], created_at="2026-06-12T00:00:00Z",
-        approval=UserResponseApproval(approved=True, implementation_option="Option B — y"),
-    )
-    assert out.endswith(
-        "# User Response\n\n## APPROVAL\n- Approved: true\n- Implementation-Option: Option B — y\n"
-    )
-    # 승인이 있으면 빈-응답 플레이스홀더는 나오지 않는다.
-    assert "_(No user responses recorded.)_" not in out
-
-
-def test_serialize_user_response_approval_without_option_omits_line():
-    from okstra_ctl.report_views import UserResponseApproval
-
-    meta = _meta("implementation-planning")
-    out = serialize_user_response(
-        run_meta=meta,
-        entries=[UserResponseEntry("C-001", "decision", "(a)", None)],
-        created_at="2026-06-12T00:00:00Z",
-        approval=UserResponseApproval(approved=True),
-    )
-    assert "\n## APPROVAL\n- Approved: true\n" in out
-    assert "Implementation-Option" not in out
-
-
-def test_serialize_user_response_without_approval_is_unchanged():
-    meta = _meta("implementation-planning")
-    out = serialize_user_response(run_meta=meta, entries=[], created_at="2026-06-12T00:00:00Z")
-    assert out.endswith("_(No user responses recorded.)_\n")
-```
-
-- [ ] **Step 2: 실패 확인** — Run: `python3 -m pytest tests/test_report_views.py -k approval_block -q`
-  Expected: FAIL (`cannot import name 'UserResponseApproval'` 또는 TypeError unexpected keyword `approval`)
-
-- [ ] **Step 3: 구현** — `report_views.py` 의 `UserResponseEntry` dataclass 아래에 추가하고 `serialize_user_response` 를 다음으로 교체:
-
-```python
-@dataclass(frozen=True)
-class UserResponseApproval:
-    """HTML Plan Approval 위젯의 Export 결과. ``implementation_option`` 이 빈
-    문자열이면 라인을 생략한다 (소비 측은 Recommended Option 폴백)."""
-    approved: bool
-    implementation_option: str = ""
-
-
-def serialize_user_response(
-    *,
-    run_meta: RunMeta,
-    entries: list[UserResponseEntry],
-    created_at: str,
-    approval: UserResponseApproval | None = None,
-) -> str:
-    """Return the canonical markdown text the HTML 'Export user
-    response' button must produce. Used by validators to confirm that
-    pasted sidecar files conform to the schema and that the JS
-    serialiser stayed in sync.
-    """
-    head = (
-        "---\n"
-        f"task-key: {run_meta.task_key}\n"
-        f"task-type: {run_meta.task_type}\n"
-        f"seq: {run_meta.seq}\n"
-        f"source-report: {run_meta.source_report}\n"
-        "created-by: user\n"
-        f"created-at: {created_at}\n"
-        "---\n"
-        "\n"
-        "# User Response\n"
-    )
-    has_approval = approval is not None and approval.approved
-    body_chunks: list[str] = []
-    for e in entries:
-        chunk = (
-            f"\n## {e.response_id}\n"
-            f"- Kind: {e.kind}\n"
-            "- Value:\n"
-            f"  > {e.value.strip()}\n"
-        )
-        if e.rationale:
-            chunk += f"- Rationale: {e.rationale.strip()}\n"
-        body_chunks.append(chunk)
-    if not entries and not has_approval:
-        body_chunks.append("\n_(No user responses recorded.)_\n")
-    if has_approval:
-        chunk = "\n## APPROVAL\n- Approved: true\n"
-        if approval.implementation_option:
-            chunk += f"- Implementation-Option: {approval.implementation_option.strip()}\n"
-        body_chunks.append(chunk)
-    return head + "".join(body_chunks)
-```
-
-- [ ] **Step 4: 통과 확인** — Run: `python3 -m pytest tests/test_report_views.py -q` → 전체 PASS
-- [ ] **Step 5: Commit** — `git add scripts/okstra_ctl/report_views.py tests/test_report_views.py && git commit -m "feat(okstra-ctl/report-views): user-response sidecar 에 APPROVAL 블록 직렬화 추가"`
-
----
-
-### Task 2: JS serializer + byte-identity
-
-**Files:**
-- Modify: `templates/reports/report.js` (buildUserResponseMarkdown :116, exportUserResponse :164)
-- Test: `tests/test_report_views.py` (`_js_serialise` :484)
-
-- [ ] **Step 1: 실패 테스트** — `_js_serialise` 를 4번째 인자를 받도록 교체하고 parity 테스트 추가:
-
-```python
-def _js_serialise(
-    meta: dict, entries: list[dict], created_at: str, approval: dict | None = None
-) -> str:
-    """Run templates/reports/report.js via Node + vm to get the JS
-    serialiser's bytes."""
-    assert NODE is not None
-    script = (
-        "const fs=require('fs');const vm=require('vm');"
-        f"vm.runInThisContext(fs.readFileSync({str((REPO_ROOT / 'templates' / 'reports' / 'report.js'))!r},'utf8'));"
-        "const m=globalThis.__okstraReportViewExports__;"
-        "const meta=JSON.parse(process.argv[1]);"
-        "const entries=JSON.parse(process.argv[2]);"
-        "const approval=JSON.parse(process.argv[4]);"
-        "process.stdout.write(m.buildUserResponseMarkdown(meta, entries, process.argv[3], approval));"
-    )
-    import json as _json
-
-    result = subprocess.run(
-        [NODE, "-e", script, _json.dumps(meta), _json.dumps(entries), created_at,
-         _json.dumps(approval)],
-        check=True,
-        capture_output=True,
-        text=True,
-    )
-    return result.stdout
-
-
-@pytest.mark.skipif(NODE is None, reason="node not available")
-def test_python_and_js_serialisers_byte_identical_with_approval():
-    from okstra_ctl.report_views import UserResponseApproval
-
-    meta = _meta("implementation-planning")
-    py_out = serialize_user_response(
-        run_meta=meta, entries=[], created_at="2026-06-12T00:00:00Z",
-        approval=UserResponseApproval(approved=True, implementation_option="Option B — y"),
-    )
-    js_out = _js_serialise(
-        {"task-key": meta.task_key, "task-type": meta.task_type,
-         "seq": meta.seq, "source-report": meta.source_report},
-        [], "2026-06-12T00:00:00Z",
-        {"approved": True, "implementationOption": "Option B — y"},
-    )
-    assert py_out == js_out
-```
-
-- [ ] **Step 2: 실패 확인** — Run: `python3 -m pytest tests/test_report_views.py -k byte_identical -q`
-  Expected: with_approval FAIL (JS 가 4번째 인자를 무시 → empty 플레이스홀더 출력), 기존 2종은 PASS 유지
-- [ ] **Step 3: 구현** — `report.js` 의 `buildUserResponseMarkdown` 을 교체:
-
-```js
-  function buildUserResponseMarkdown(runMeta, entries, createdAt, approval) {
-    var head =
-      "---\n" +
-      "task-key: " + (runMeta["task-key"] || "") + "\n" +
-      "task-type: " + (runMeta["task-type"] || "") + "\n" +
-      "seq: " + (runMeta["seq"] || "") + "\n" +
-      "source-report: " + (runMeta["source-report"] || "") + "\n" +
-      "created-by: user\n" +
-      "created-at: " + createdAt + "\n" +
-      "---\n" +
-      "\n" +
-      "# User Response\n";
-
-    entries = entries || [];
-    var hasApproval = !!(approval && approval.approved);
-    var chunks = "";
-    for (var i = 0; i < entries.length; i++) {
-      var e = entries[i];
-      var chunk =
-        "\n## " + e.responseId + "\n" +
-        "- Kind: " + e.kind + "\n" +
-        "- Value:\n" +
-        "  > " + trimMultiline(e.value) + "\n";
-      if (e.rationale) {
-        chunk += "- Rationale: " + trimMultiline(e.rationale) + "\n";
-      }
-      chunks += chunk;
-    }
-    if (entries.length === 0 && !hasApproval) {
-      chunks += "\n_(No user responses recorded.)_\n";
-    }
-    if (hasApproval) {
-      chunks += "\n## APPROVAL\n- Approved: true\n";
-      if (approval.implementationOption) {
-        chunks +=
-          "- Implementation-Option: " + trimMultiline(approval.implementationOption) + "\n";
-      }
-    }
-    return head + chunks;
-  }
-```
-
-같은 파일의 `collectEntries` 아래에 위젯 수집 함수를 추가하고 `exportUserResponse` 를 교체:
-
-```js
-  // Plan Approval 위젯 (implementation-planning 보고서에만 존재). 체크박스가
-  // disabled(§1 차단 미해소)이거나 미체크면 null. 옵션이 추천(data-recommended)
-  // 그대로면 implementationOption 을 비워 보낸다 → 소비 측 Recommended 폴백.
-  function collectApproval() {
-    var box = document.getElementById("approval-checkbox");
-    if (!box || box.disabled || !box.checked) return null;
-    var sel = document.getElementById("approval-option");
-    var option = "";
-    if (sel && sel.selectedIndex >= 0) {
-      var opt = sel.options[sel.selectedIndex];
-      if (opt && opt.getAttribute("data-recommended") !== "true") {
-        option = opt.value;
-      }
-    }
-    return { approved: true, implementationOption: option };
-  }
-
-  function exportUserResponse() {
-    var runMeta = readRunMeta();
-    var entries = collectEntries();
-    var approval = collectApproval();
-    var md = buildUserResponseMarkdown(runMeta, entries, isoNowUtc(), approval);
-    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 || approval) downloadUserResponse(md, runMeta);
-    return md;
-  }
-```
-
-`window.okstraReportView` export 객체에 `collectApproval: collectApproval,` 한 줄 추가.
-
-- [ ] **Step 4: 통과 확인** — Run: `python3 -m pytest tests/test_report_views.py -q` → 전체 PASS
-- [ ] **Step 5: Commit** — `git add templates/reports/report.js tests/test_report_views.py && git commit -m "feat(reports/report.js): Plan Approval 위젯 수집 + APPROVAL 블록 직렬화 (Python 과 byte-identical)"`
-
----
-
-### Task 3: HTML 위젯 렌더 + 생성 조건 확장
-
-**Files:**
-- Modify: `scripts/okstra_ctl/report_views.py` (render_html :94, render_html_view :783)
-- Modify: `templates/reports/report.css`
-- Modify: `validators/validate-report-views.py` (:101 분기)
-- Test: `tests/test_report_views.py`
-
-- [ ] **Step 1: 실패 테스트 작성**:
-
-```python
-def _planning_md(*, c_row: bool = True) -> str:
-    clar = (
-        "| 항목 | Statement | User input |\n|---|---|---|\n"
-        "| **C-001**<br>Ticket: `T-1`<br>Kind: `decision`<br>Blocks: `none`<br>Status: open | 질문 | |\n"
-        if c_row else "- 추가 정보 요청 없음.\n"
-    )
-    return (
-        "---\napproved: false\nimplementation-option:\n---\n"
-        "# demo/T-1 - Multi-Agent Cross Verification Final Report\n\n"
-        "## 1. Clarification Items\n\n" + clar + "\nbody\n"
-    )
-
-
-def _planning_data_json() -> str:
-    import json as _json
-    return _json.dumps({
-        "frontmatter": {"approved": False},
-        "implementationPlanning": {
-            "optionCandidates": [{"name": "Option A — x"}, {"name": "Option B — y"}],
-            "recommendedOption": {"name": "Option A — x"},
-        },
-    })
-
-
-def _render_planning_view(tmp_path, md_text: str, *, with_data: bool = True):
-    from okstra_ctl.report_views import render_html_view
-
-    reports = tmp_path / "runs" / "implementation-planning" / "reports"
-    reports.mkdir(parents=True)
-    md = reports / "final-report-implementation-planning-002.md"
-    md.write_text(md_text, encoding="utf-8")
-    if with_data:
-        md.with_name(md.stem + ".data.json").write_text(_planning_data_json(), encoding="utf-8")
-    return md, render_html_view(md, run_meta=_meta("implementation-planning"), css=CSS, js=JS)
-
-
-def test_html_plan_approval_widget_renders_with_recommended_default(tmp_path):
-    md, html_path = _render_planning_view(tmp_path, _planning_md())
-    body = html_path.read_text(encoding="utf-8")
-    assert '<section id="plan-approval">' in body
-    assert 'data-recommended="true" selected>Option A — x (권장)</option>' in body
-    assert '<option value="Option B — y">Option B — y</option>' in body
-    assert '<input type="checkbox" id="approval-checkbox">' in body  # disabled 아님
-
-
-def test_html_plan_approval_disabled_when_blockers_open(tmp_path):
-    blocked = _planning_md().replace("Blocks: `none`", "Blocks: `approval`")
-    md, html_path = _render_planning_view(tmp_path, blocked)
-    body = html_path.read_text(encoding="utf-8")
-    assert '<section id="plan-approval">' in body
-    assert 'id="approval-checkbox" disabled' in body
-    assert "승인 차단 항목 1건" in body
-
-
-def test_html_plan_approval_absent_without_data_json(tmp_path):
-    md, html_path = _render_planning_view(tmp_path, _planning_md(), with_data=False)
-    assert 'id="plan-approval"' not in html_path.read_text(encoding="utf-8")
-
-
-def test_html_view_generated_for_approval_only_report(tmp_path):
-    # C-행이 없어도 승인 위젯이 적용되면 html 을 생성한다 (생성 조건 확장).
-    md, html_path = _render_planning_view(tmp_path, _planning_md(c_row=False))
-    assert html_path is not None
-    assert 'id="plan-approval"' in html_path.read_text(encoding="utf-8")
-```
-
-- [ ] **Step 2: 실패 확인** — Run: `python3 -m pytest tests/test_report_views.py -k plan_approval -q` → 4건 FAIL
-- [ ] **Step 3: 구현** — `report_views.py` 상단 import 에 `import json` 이 없으면 추가하고, `report_has_clarification_items` 아래에 추가:
-
-```python
-@dataclass(frozen=True)
-class PlanApprovalContext:
-    """Plan Approval 위젯 렌더 입력. ``disabled_reason`` 이 비어 있지 않으면
-    위젯은 disabled 로 렌더된다 (run-prep 승인 게이트와 동일한 fail-closed 기준)."""
-    option_names: tuple[str, ...]
-    recommended_option: str
-    disabled_reason: str
-
-
-def plan_approval_context(
-    src_md_path: Path, src_text: str
-) -> PlanApprovalContext | None:
-    """implementation-planning 보고서 + sibling data.json 의 optionCandidates 가
-    있을 때만 컨텍스트를 만든다. planning 여부는 task-type 문자열이 아니라
-    data.json 의 ``implementationPlanning`` 키(SSOT)로 판정한다 — renderer 와
-    validator 가 같은 판정을 공유한다."""
-    data_path = src_md_path.with_name(src_md_path.stem + ".data.json")
-    if not data_path.is_file():
-        return None
-    try:
-        data = json.loads(data_path.read_text(encoding="utf-8"))
-    except (OSError, json.JSONDecodeError):
-        return None
-    planning = data.get("implementationPlanning")
-    if not isinstance(planning, dict):
-        return None
-    names = tuple(
-        c.get("name", "")
-        for c in (planning.get("optionCandidates") or [])
-        if isinstance(c, dict) and c.get("name")
-    )
-    if not names:
-        return None
-    recommended = ""
-    rec = planning.get("recommendedOption")
-    if isinstance(rec, dict):
-        recommended = rec.get("name") or ""
-    scan = scan_approval_gate(src_text)
-    if scan.unreadable_reason:
-        reason = "§1 승인 게이트를 읽을 수 없어 승인이 비활성화되었습니다 — 보고서를 재렌더하세요."
-    elif scan.blockers:
-        reason = (
-            f"§1 승인 차단 항목 {len(scan.blockers)}건 미해소 — 답변을 채워 Export 한 뒤 "
-            "resume-clarification 으로 해소한 다음 보고서에서 승인하세요."
-        )
-    else:
-        reason = ""
-    return PlanApprovalContext(
-        option_names=names, recommended_option=recommended, disabled_reason=reason
-    )
-
-
-def _plan_approval_section(ctx: PlanApprovalContext) -> str:
-    disabled = " disabled" if ctx.disabled_reason else ""
-    opts: list[str] = []
-    for name in ctx.option_names:
-        is_rec = name == ctx.recommended_option
-        label = f"{name} (권장)" if is_rec else name
-        attrs = ' data-recommended="true" selected' if is_rec else ""
-        opts.append(f'<option value="{html.escape(name)}"{attrs}>{html.escape(label)}</option>')
-    reason_html = (
-        f'\n  <p class="approval-disabled-reason">{html.escape(ctx.disabled_reason)}</p>'
-        if ctx.disabled_reason else ""
-    )
-    return (
-        '<section id="plan-approval">\n'
-        "  <h2>Plan Approval</h2>\n"
-        f'  <label>구현 옵션: <select id="approval-option"{disabled}>{"".join(opts)}</select></label>\n'
-        f'  <label><input type="checkbox" id="approval-checkbox"{disabled}> '
-        "이 plan 을 승인합니다 — Export 시 sidecar 에 APPROVAL 블록으로 기록되고, "
-        "implementation 시작 마법사가 확인 후 적용합니다.</label>"
-        f"{reason_html}\n"
-        "</section>\n"
-    )
-```
-
-`scan_approval_gate` 가 report_views 에 이미 import 되어 있는지 확인하고 없으면 `from okstra_ctl.clarification_items import scan_approval_gate` 형태로 기존 import 블록에 추가 (기존 import 스타일을 그대로 따른다).
-
-`render_html` 시그니처에 `approval_ctx: PlanApprovalContext | None = None` 키워드를 추가하고, 본문 f-string 의 `f"<main>{body_html}</main>\n"` 다음 줄에 삽입:
-
-```python
-        f"<main>{body_html}</main>\n"
-        f"{_plan_approval_section(approval_ctx) if approval_ctx else ''}"
-        f"<footer class=\"report-footer\">\n"
-```
-
-`render_html_view` 를 다음으로 교체 (생성 조건 확장 + ctx 전달):
-
-```python
-def render_html_view(
-    src_md_path: Path,
-    *,
-    run_meta: RunMeta,
-    css: str,
-    js: str,
-) -> Path | None:
-    """Write ``<stem>.html`` next to ``src_md_path`` and return its path,
-    or return ``None`` when the report needs no interactive view — §1
-    clarification rows 도 없고 Plan Approval 위젯 대상도 아닐 때
-    (``report_has_clarification_items`` / ``plan_approval_context``).
-    Idempotent — overwrites an existing html sibling, and removes a stale
-    one when the report no longer needs a view."""
-    src_text = src_md_path.read_text(encoding="utf-8")
-    html_path = src_md_path.with_name(src_md_path.stem + ".html")
-    approval_ctx = plan_approval_context(src_md_path, src_text)
-    if not report_has_clarification_items(src_text) and approval_ctx is None:
-        if html_path.is_file():
-            html_path.unlink()
-        return None
-    html_text = render_html(
-        src_text, run_meta=run_meta, css=css, js=js, approval_ctx=approval_ctx
-    )
-    html_path.write_text(html_text, encoding="utf-8")
-    return html_path
-```
-
-`templates/reports/report.css` 끝부분 `@media print` 블록 **앞**에 추가:
-
-```css
-#plan-approval {
-  max-width: 120ch;
-  margin: 1.5rem auto;
-  padding: 0.8em 1rem;
-  border: 1px solid color-mix(in srgb, GrayText 40%, transparent);
-  border-radius: 4px;
-}
-#plan-approval h2 { margin-top: 0; }
-#plan-approval label { display: block; margin: 0.4em 0; }
-#plan-approval select { font: inherit; max-width: 100%; }
-.approval-disabled-reason { color: GrayText; margin: 0.4em 0 0; }
-```
-
-그리고 `@media print` 블록 안에 `#plan-approval { display: none; }` 추가.
-
-`validators/validate-report-views.py` 의 html 부재 분기(:101)를 교체 — import 블록의 `from okstra_ctl.report_views import (...)` 에 `plan_approval_context` 를 추가하고:
-
-```python
-    if not html_path.is_file():
-        if not md_ids and plan_approval_context(report_path, md) is None:
-            return []
-        return [f"missing html artifact: {html_path}"]
-```
-
-- [ ] **Step 4: 통과 확인** — Run: `python3 -m pytest tests/test_report_views.py -q` → 전체 PASS. 이어서 `python3 -m pytest tests/ -q` 로 validator 회귀 확인.
-- [ ] **Step 5: Commit** — `git add scripts/okstra_ctl/report_views.py templates/reports/report.css validators/validate-report-views.py tests/test_report_views.py && git commit -m "feat(okstra-ctl/report-views): Plan Approval 위젯 렌더 + 위젯 대상 보고서로 html 생성 조건 확장"`
-
----
-
-### Task 4: user-responses/ 디렉토리 선생성
-
-**Files:**
-- Modify: `scripts/okstra_ctl/report_views.py` (render_html_view)
-- Test: `tests/test_report_views.py`
-
-- [ ] **Step 1: 실패 테스트**:
-
-```python
-def test_html_view_precreates_user_responses_dir(tmp_path):
-    md, html_path = _render_planning_view(tmp_path, _planning_md())
-    assert (md.parent.parent / "user-responses").is_dir()
-
-
-def test_no_user_responses_dir_when_view_skipped(tmp_path):
-    from okstra_ctl.report_views import render_html_view
-
-    reports = tmp_path / "runs" / "implementation" / "reports"
-    reports.mkdir(parents=True)
-    md = reports / "final-report-implementation-001.md"
-    md.write_text("# demo/T-1 - Final Report\n\nbody\n", encoding="utf-8")
-    assert render_html_view(md, run_meta=_meta("implementation"), css=CSS, js=JS) is None
-    assert not (md.parent.parent / "user-responses").exists()
-```
-
-- [ ] **Step 2: 실패 확인** — Run: `python3 -m pytest tests/test_report_views.py -k user_responses_dir -q` → precreates FAIL
-- [ ] **Step 3: 구현** — `render_html_view` 의 `html_path.write_text(...)` 바로 다음에:
-
-```python
-    # 사용자 확인(폼/승인)이 필요한 보고서 — Export 파일의 저장 위치를 미리
-    # 만들어 사용자가 디렉토리를 만들 필요가 없게 한다 (reports/ 의 sibling).
-    (src_md_path.parent.parent / "user-responses").mkdir(parents=True, exist_ok=True)
-```
-
-- [ ] **Step 4: 통과 확인** — Run: `python3 -m pytest tests/test_report_views.py -q` → PASS
-- [ ] **Step 5: Commit** — `git add scripts/okstra_ctl/report_views.py tests/test_report_views.py && git commit -m "feat(okstra-ctl/report-views): 인터랙티브 html 렌더 시 user-responses/ 디렉토리 선생성"`
-
----
-
-### Task 5: sidecar APPROVAL 파서
-
-**Files:**
-- Modify: `scripts/okstra_ctl/clarification_items.py` (파일 끝에 추가)
-- Test: `tests/test_clarification_sidecar_approval.py` (Create)
-
-- [ ] **Step 1: 실패 테스트** — 새 파일 `tests/test_clarification_sidecar_approval.py`:
-
-```python
-import sys
-from pathlib import Path
-
-REPO = Path(__file__).resolve().parents[1]
-if str(REPO / "scripts") not in sys.path:
-    sys.path.insert(0, str(REPO / "scripts"))
-
-from okstra_ctl.clarification_items import parse_user_response_approval  # noqa: E402
-
-_SIDE = (
-    "---\n"
-    "task-key: demo/T-1\n"
-    "task-type: implementation-planning\n"
-    "seq: 002\n"
-    "source-report: runs/implementation-planning/reports/final-report-implementation-planning-002.md\n"
-    "created-by: user\n"
-    "created-at: 2026-06-12T00:00:00Z\n"
-    "---\n\n# User Response\n"
-)
-
-
-def test_parses_approval_with_option():
-    rec = parse_user_response_approval(
-        _SIDE + "\n## APPROVAL\n- Approved: true\n- Implementation-Option: Option B — y\n"
-    )
-    assert rec is not None
-    assert rec.approved is True
-    assert rec.implementation_option == "Option B — y"
-    assert rec.seq == "002"
-    assert rec.source_report.endswith("final-report-implementation-planning-002.md")
-
-
-def test_parses_approval_without_option():
-    rec = parse_user_response_approval(_SIDE + "\n## APPROVAL\n- Approved: true\n")
-    assert rec is not None and rec.implementation_option == ""
-
-
-def test_returns_none_without_block_or_when_not_true():
-    assert parse_user_response_approval(_SIDE + "\n## C-001\n- Kind: decision\n- Value:\n  > x\n") is None
-    assert parse_user_response_approval(_SIDE + "\n## APPROVAL\n- Approved: false\n") is None
-
-
-def test_option_scoped_to_approval_block_only():
-    text = (
-        _SIDE
-        + "\n## APPROVAL\n- Approved: true\n"
-        + "\n## C-009\n- Kind: decision\n- Value:\n  > Implementation-Option: 가짜\n"
-    )
-    rec = parse_user_response_approval(text)
-    assert rec is not None and rec.implementation_option == ""
-```
-
-- [ ] **Step 2: 실패 확인** — Run: `python3 -m pytest tests/test_clarification_sidecar_approval.py -q` → ImportError FAIL
-- [ ] **Step 3: 구현** — `clarification_items.py` 파일 끝에 추가:
-
-```python
-# --------------------------------------------------------------------------- #
-# User-response sidecar APPROVAL block (HTML Plan Approval 위젯의 Export 산출)
-# --------------------------------------------------------------------------- #
-
-_APPROVAL_HEADING_RE = re.compile(r"^## APPROVAL\s*$", re.MULTILINE)
-_NEXT_RESPONSE_HEADING_RE = re.compile(r"^## ", re.MULTILINE)
-
-
-@dataclass(frozen=True)
-class UserResponseApprovalRecord:
-    """sidecar 의 ``## APPROVAL`` 블록 + 매칭에 필요한 frontmatter 필드."""
-    approved: bool
-    implementation_option: str
-    source_report: str
-    seq: str
-
-
-def parse_user_response_approval(
-    sidecar_text: str,
-) -> Optional[UserResponseApprovalRecord]:
-    """``## APPROVAL`` 블록이 ``- Approved: true`` 를 가질 때만 record 를
-    반환한다. 옵션 라인은 블록 내부에서만 읽는다 (다른 응답 본문의 우연한
-    동일 문구를 옵션으로 오인하지 않도록)."""
-    m = _APPROVAL_HEADING_RE.search(sidecar_text)
-    if not m:
-        return None
-    block = sidecar_text[m.end():]
-    nxt = _NEXT_RESPONSE_HEADING_RE.search(block)
-    if nxt:
-        block = block[: nxt.start()]
-    if re.search(r"^- Approved:\s*true\s*$", block, re.MULTILINE) is None:
-        return None
-    om = re.search(r"^- Implementation-Option:\s*(\S.*?)\s*$", block, re.MULTILINE)
-    sm = re.search(r"^seq:\s*(\S+)\s*$", sidecar_text, re.MULTILINE)
-    rm = re.search(r"^source-report:\s*(\S.*?)\s*$", sidecar_text, re.MULTILINE)
-    return UserResponseApprovalRecord(
-        approved=True,
-        implementation_option=om.group(1) if om else "",
-        source_report=rm.group(1) if rm else "",
-        seq=sm.group(1) if sm else "",
-    )
-```
-
-- [ ] **Step 4: 통과 확인** — Run: `python3 -m pytest tests/test_clarification_sidecar_approval.py tests/test_okstra_clarification_items.py -q` (후자가 없으면 `tests/ -k clarification`) → PASS
-- [ ] **Step 5: Commit** — `git add scripts/okstra_ctl/clarification_items.py tests/test_clarification_sidecar_approval.py && git commit -m "feat(okstra-ctl/clarification-items): user-response sidecar APPROVAL 블록 파서 추가"`
-
----
-
-### Task 6: 마법사 — sidecar 감지·확인·적용
-
-**Files:**
-- Modify: `scripts/okstra_ctl/wizard.py`
-- Modify: `prompts/wizard/prompts.ko.json` (steps.approve_plan_confirm)
-- Test: `tests/test_wizard_approve_plan_confirm.py`
-
-- [ ] **Step 1: 실패 테스트** — `tests/test_wizard_approve_plan_confirm.py` 끝에 추가 (기존 `_load_wizard`/`_state`/`_GATE_CLEAR_BODY` 재사용):
-
-```python
-def _planning_run(tmp_path, *, approved: bool, option_in_sidecar: str):
-    """runs/implementation-planning/{reports,user-responses} 구조 + APPROVAL sidecar."""
-    reports = tmp_path / "runs" / "implementation-planning" / "reports"
-    reports.mkdir(parents=True)
-    plan = reports / "final-report-implementation-planning-002.md"
-    flag = "true" if approved else "false"
-    plan.write_text(
-        f"---\napproved: {flag}\nimplementation-option:\n---\n{_GATE_CLEAR_BODY}",
-        encoding="utf-8",
-    )
-    plan.with_name(plan.name[:-3] + ".data.json").write_text(json.dumps({
-        "frontmatter": {"approved": approved},
-        "implementationPlanning": {
-            "optionCandidates": [{"name": "Option A — x"}, {"name": "Option B — y"}],
-            "recommendedOption": {"name": "Option A — x"},
-        },
-    }), encoding="utf-8")
-    ur = reports.parent / "user-responses"
-    ur.mkdir()
-    option_line = (
-        f"- Implementation-Option: {option_in_sidecar}\n" if option_in_sidecar else ""
-    )
-    (ur / "user-response-implementation-planning-002.md").write_text(
-        "---\ntask-key: demo/T-1\ntask-type: implementation-planning\nseq: 002\n"
-        f"source-report: runs/implementation-planning/reports/{plan.name}\n"
-        "created-by: user\ncreated-at: 2026-06-12T00:00:00Z\n---\n\n"
-        f"# User Response\n\n## APPROVAL\n- Approved: true\n{option_line}",
-        encoding="utf-8",
-    )
-    return plan
-
-
-def test_plan_selection_detects_html_approval_sidecar(tmp_path):
-    wizard = _load_wizard()
-    state = _state(wizard, tmp_path)
-    plan = _planning_run(tmp_path, approved=True, option_in_sidecar="Option B — y")
-
-    wizard._submit_approved_plan(state, str(plan))
-
-    assert state.approve_plan_candidate == str(plan)
-    assert state.html_approval_sidecar.endswith("user-response-implementation-planning-002.md")
-    assert state.html_approval_option == "Option B — y"
-    prompt = wizard.STEP_BY_ID[wizard.S_APPROVE_PLAN_CONFIRM].build(state)
-    assert {o.value for o in prompt.options} == {"yes_apply", "yes", "no"}
-    assert "HTML 승인 기록" in prompt.label
-
-
-def test_confirm_yes_apply_sets_implementation_option(tmp_path):
-    wizard = _load_wizard()
-    state = _state(wizard, tmp_path)
-    plan = _planning_run(tmp_path, approved=True, option_in_sidecar="Option B — y")
-    wizard._submit_approved_plan(state, str(plan))
-
-    echo = wizard._submit_approve_plan_confirm(state, "yes_apply")
-
-    body = plan.read_text(encoding="utf-8")
-    assert "implementation-option:" in body and "Option B — y" in body
-    assert state.approved_plan_path == str(plan)
-    assert state.html_approval_sidecar == "" and state.html_approval_option == ""
-    assert "Option B — y" in echo
-
-
-def test_confirm_yes_ignores_sidecar_option(tmp_path):
-    wizard = _load_wizard()
-    state = _state(wizard, tmp_path)
-    plan = _planning_run(tmp_path, approved=True, option_in_sidecar="Option B — y")
-    wizard._submit_approved_plan(state, str(plan))
-
-    wizard._submit_approve_plan_confirm(state, "yes")
-
-    body = plan.read_text(encoding="utf-8")
-    assert "Option B — y" not in body  # 기록 무시 → frontmatter 무변경
-    assert state.approved_plan_path == str(plan)
-
-
-def test_yes_apply_rejects_unknown_option(tmp_path):
-    wizard = _load_wizard()
-    state = _state(wizard, tmp_path)
-    plan = _planning_run(tmp_path, approved=True, option_in_sidecar="Option Z — 없음")
-    wizard._submit_approved_plan(state, str(plan))
-
-    with pytest.raises(wizard.WizardError) as excinfo:
-        wizard._submit_approve_plan_confirm(state, "yes_apply")
-    msg = str(excinfo.value)
-    assert "Option Z — 없음" in msg and "Option A — x" in msg
-
-
-def test_seq_mismatch_sidecar_ignored(tmp_path):
-    wizard = _load_wizard()
-    state = _state(wizard, tmp_path)
-    plan = _planning_run(tmp_path, approved=True, option_in_sidecar="Option B — y")
-    ur = plan.parent.parent / "user-responses"
-    old = ur / "user-response-implementation-planning-002.md"
-    old.rename(ur / "user-response-implementation-planning-001.md")
-    text = (ur / "user-response-implementation-planning-001.md").read_text(encoding="utf-8")
-    (ur / "user-response-implementation-planning-001.md").write_text(
-        text.replace("seq: 002", "seq: 001").replace("-002.md", "-001.md"),
-        encoding="utf-8",
-    )
-
-    wizard._submit_approved_plan(state, str(plan))
-
-    assert state.html_approval_sidecar == ""
-    prompt = wizard.STEP_BY_ID[wizard.S_APPROVE_PLAN_CONFIRM].build(state)
-    assert {o.value for o in prompt.options} == {"yes", "no"}
-```
-
-- [ ] **Step 2: 실패 확인** — Run: `python3 -m pytest tests/test_wizard_approve_plan_confirm.py -q` → 신규 5건 FAIL (AttributeError `html_approval_sidecar` 등), 기존 9건 PASS 유지
-- [ ] **Step 3: 구현** — `wizard.py`:
-
-(a) import 블록(:41 부근)의 `from .run import (...)` 에 `_apply_cli_implementation_option,` 추가. `from .clarification_items import` 블록에 `parse_user_response_approval,` 추가 (기존 import 스타일 확인 후 동일하게).
-
-(b) `WizardState` (:339 부근) 에 필드 추가:
-
-```python
-    # HTML Plan Approval 위젯이 남긴 sidecar 감지 결과. 선택된 plan 과
-    # source-report·seq 가 일치하는 APPROVAL 블록이 있을 때만 채워지고,
-    # approve-confirm 단계가 3-옵션(yes_apply/yes/no)으로 확장된다.
-    html_approval_sidecar: str = ""
-    html_approval_option: str = ""
-```
-
-그리고 wizard.py:3007 부근의 state 초기값 dict 에 `"html_approval_sidecar": "", "html_approval_option": "",` 추가.
-
-(c) `_stage_plan_for_confirmation` (:556) 의 `state.approve_plan_candidate = str(p)` 다음에:
-
-```python
-    state.html_approval_sidecar = ""
-    state.html_approval_option = ""
-    found = _find_html_approval_sidecar(p)
-    if found is not None:
-        sidecar_path, record = found
-        state.html_approval_sidecar = str(sidecar_path)
-        state.html_approval_option = record.implementation_option
-```
-
-같은 파일 `_approve_plan_in_place` 아래에 추가:
-
-```python
-def _find_html_approval_sidecar(
-    plan_path: Path,
-) -> Optional[tuple[Path, "UserResponseApprovalRecord"]]:
-    """plan 의 run 디렉토리 sibling ``user-responses/`` 에서 APPROVAL 블록을
-    가진 sidecar 를 찾는다. source-report 파일명과 seq 가 plan 과 일치해야
-    하며, 복수면 mtime 최신을 택한다."""
-    responses_dir = plan_path.parent.parent / "user-responses"
-    if not responses_dir.is_dir():
-        return None
-    m = re.search(r"-(\d+)\.md$", plan_path.name)
-    plan_seq = m.group(1) if m else ""
-    best: Optional[tuple[float, Path, "UserResponseApprovalRecord"]] = None
-    for f in sorted(responses_dir.glob("user-response-*.md")):
-        try:
-            text = f.read_text(encoding="utf-8", errors="replace")
-        except OSError:
-            continue
-        rec = parse_user_response_approval(text)
-        if rec is None or rec.seq != plan_seq:
-            continue
-        if Path(rec.source_report).name != plan_path.name:
-            continue
-        mtime = f.stat().st_mtime
-        if best is None or mtime > best[0]:
-            best = (mtime, f, rec)
-    return (best[1], best[2]) if best else None
-
-
-def _validate_sidecar_option(plan_path: Path, option_name: str, errors_t: dict) -> None:
-    """sidecar 의 옵션 이름이 plan data.json 의 optionCandidates 에 있는지
-    검증한다. 없으면 유효 후보를 나열하며 거부한다 (fail-closed)."""
-    data_path = plan_path.with_name(plan_path.name[: -len(".md")] + ".data.json")
-    candidates: list[str] = []
-    if data_path.is_file():
-        try:
-            data = json.loads(data_path.read_text(encoding="utf-8"))
-            planning = data.get("implementationPlanning") or {}
-            candidates = [
-                c.get("name", "") for c in planning.get("optionCandidates") or []
-                if isinstance(c, dict) and c.get("name")
-            ]
-        except (OSError, json.JSONDecodeError):
-            candidates = []
-    if option_name not in candidates:
-        raise WizardError(
-            errors_t["unknown_option"].format(
-                option=option_name,
-                candidates=", ".join(candidates) if candidates else "(없음)",
-            )
-        )
-```
-
-(`json` / `re` 는 wizard.py 에 이미 import 되어 있는지 확인; 없으면 추가. `UserResponseApprovalRecord` 는 타입 주석용 — import 에 포함.)
-
-(d) `_build_approve_plan_confirm` (:1605) 교체:
-
-```python
-def _build_approve_plan_confirm(state: WizardState) -> Prompt:
-    t = _p(state.workspace_root, "approve_plan_confirm",
-           path=state.approve_plan_candidate)
-    label = t["label"]
-    options_map = t["options"]
-    if state.html_approval_sidecar:
-        label += t["html_approval_note"].format(
-            sidecar=state.html_approval_sidecar,
-            option=state.html_approval_option or "(추천 옵션 그대로)",
-        )
-        options_map = t["options_html_approval"]
-    return Prompt(
-        step=S_APPROVE_PLAN_CONFIRM, kind="pick",
-        label=label,
-        options=[_opt(k, v) for k, v in options_map.items()],
-        echo_template=t["echo_template"],
-    )
-```
-
-(e) `_submit_approve_plan_confirm` (:1616) 교체 — `yes_apply` 분기 추가:
-
-```python
-def _submit_approve_plan_confirm(state: WizardState, value: str) -> Optional[str]:
-    allowed = ("yes_apply", "yes", "no") if state.html_approval_sidecar else ("yes", "no")
-    if value not in allowed:
-        raise WizardError(f"expected one of {allowed}, got: {value!r}")
-    candidate = state.approve_plan_candidate
-    if not candidate:
-        raise WizardError("approve-plan: no candidate plan to approve")
-    t = _p(state.workspace_root, "approve_plan_confirm", path=candidate)
-    if value == "no":
-        # Declining leaves the candidate set so the confirm step re-prompts;
-        # implementation cannot proceed without choosing to proceed.
-        raise WizardError(t["errors"]["declined"])
-    apply_option = value == "yes_apply" and bool(state.html_approval_option)
-    p = Path(candidate)
-    if apply_option:
-        # 승인 플립 전에 옵션 유효성부터 검증한다 — 무효 옵션으로 plan 이
-        # 절반만(승인만) 적용되는 상태를 만들지 않는다.
-        _validate_sidecar_option(p, state.html_approval_option, t["errors"])
-    resolved, fully_approved = _classify_approved_plan(
-        str(p), Path(state.project_root))
-    if not fully_approved:
-        # Not yet approved → flip data.json (SSOT) + re-render, then re-verify.
-        _approve_plan_in_place(p)
-        resolved, fully_approved = _classify_approved_plan(
-            str(p), Path(state.project_root))
-        if not fully_approved:
-            raise WizardError(t["errors"]["still_unapproved"].format(path=resolved))
-    echo = t["echo_variants"]["approved"].format(path=resolved)
-    if apply_option:
-        _apply_cli_implementation_option(str(resolved), state.html_approval_option)
-        echo = t["echo_variants"]["approved_with_option"].format(
-            path=resolved, option=state.html_approval_option)
-    state.approved_plan_path = str(resolved)
-    state.approve_plan_candidate = ""
-    state.html_approval_sidecar = ""
-    state.html_approval_option = ""
-    return echo
-```
-
-주의: `_apply_cli_implementation_option` 은 `PrepareError` 를 던진다 — `_approve_plan_in_place` 의 기존 전파 방식과 동일하게 그대로 전파시킨다 (별도 try 불요).
-
-(f) `prompts/wizard/prompts.ko.json` 의 `steps.approve_plan_confirm` 에 키 추가 (기존 키는 무변경):
-
-```json
-"html_approval_note": "\nHTML 승인 기록 발견: {sidecar}\n  선택 옵션: {option}\n· 예(기록 적용) — 승인과 함께 위 옵션을 frontmatter 에 기록합니다.",
-"options_html_approval": {
-  "yes_apply": "예 — HTML 기록대로 승인 + 옵션 적용 (추천)",
-  "yes": "예 — 승인만 (HTML 기록 무시)",
-  "no": "아니오 — 진행하지 않음"
-},
-"echo_variants": {
-  "selected": "(기존 값 유지)",
-  "approved": "(기존 값 유지)",
-  "approved_with_option": "approved-plan: {path} (승인 + 옵션 `{option}` 적용됨)"
-},
-"errors": {
-  "declined": "(기존 값 유지)",
-  "still_unapproved": "(기존 값 유지)",
-  "unknown_option": "HTML 승인 기록의 옵션 `{option}` 이 plan 의 Option Candidates 에 없습니다. 유효 후보: {candidates}. 보고서 HTML 에서 다시 Export 하거나 '예 — 승인만' 을 선택하세요."
-}
-```
-
-("(기존 값 유지)" 는 실제 JSON 에 그 문구를 쓰라는 뜻이 아니라 **기존 값을 건드리지 말라**는 지시 — `echo_variants` / `errors` 객체에 새 키만 추가한다.)
-
-- [ ] **Step 4: 통과 확인** — Run: `python3 -m pytest tests/test_wizard_approve_plan_confirm.py tests/test_wizard_prompts.py tests/test_okstra_ctl_wizard.py -q` → PASS (prompts 스키마 테스트가 새 키를 거부하면 해당 테스트의 허용 키 목록에 추가)
-- [ ] **Step 5: Commit** — `git add scripts/okstra_ctl/wizard.py prompts/wizard/prompts.ko.json tests/test_wizard_approve_plan_confirm.py && git commit -m "feat(okstra-ctl/wizard): HTML APPROVAL sidecar 감지 — 확인 후 승인+옵션을 기존 경로로 적용"`
-
----
-
-### Task 7: 문서·빌드·전체 검증
-
-**Files:**
-- Modify: `templates/reports/user-response.template.md`
-- Modify: `skills/okstra-report-writer/SKILL.md` (:108 HTML 뷰 설명)
-- Modify: `skills/okstra-run/SKILL.md` (:126 implementation sub-flow)
-- Modify: `CHANGES.md`
-
-- [ ] **Step 1: sidecar 템플릿 문서** — `user-response.template.md` 의 "## 호환성 규칙" 앞에 섹션 추가:
-
-```markdown
-## APPROVAL 블록 (implementation-planning 전용)
-
-Plan Approval 위젯에서 승인을 체크하고 Export 하면 본문 끝에 다음 블록이 추가됩니다:
-
-​```markdown
-## APPROVAL
-- Approved: true
-- Implementation-Option: <Option Candidates 의 name 그대로>
-​```
-
-- 옵션을 추천(권장) 그대로 두면 `Implementation-Option:` 라인은 생략됩니다 — implementation 은 plan 의 Recommended Option 으로 폴백합니다.
-- 이 블록의 소비자는 implementation 시작 마법사의 approve-confirm 단계입니다 (`scripts/okstra_ctl/wizard.py`). 마법사가 사용자 확인 후 기존 `--approve` / `--implementation-option` 경로로 적용하며, sidecar 자체는 승인 게이트 검증을 우회하지 않습니다.
-- `--resume-clarification` 은 sidecar 를 verbatim 첨부하므로 APPROVAL 블록도 그대로 실립니다 — planning 재실행 입력에서는 무해한 잔류 정보입니다.
-```
-
-(코드펜스 안의 ​``` 는 실제 파일에서는 일반 ``` 로.)
-
-- [ ] **Step 2: 스킬 문서 2곳** — `okstra-report-writer/SKILL.md` :108 의 HTML 뷰 설명 문장에 생성 조건 확장과 위젯을 반영: "**generated only when the report has at least one §5 `C-*` clarification row**" 를 "**generated when the report has at least one §1 `C-*` clarification row OR an implementation-planning Plan Approval widget target (sibling data.json 의 optionCandidates)**" 로 교체하고, 같은 항목에 한 문장 추가: "implementation-planning 보고서에는 Plan Approval 섹션(옵션 select + 승인 체크)이 렌더되며, Export sidecar 의 `## APPROVAL` 블록은 implementation 마법사가 확인 후 적용한다." `okstra-run/SKILL.md` :126 의 implementation sub-flow 항목에 추가: "approved-plan 선택 시 user-responses/ 의 HTML APPROVAL sidecar 를 감지하면 confirm 단계가 3-옵션(yes_apply 추천/yes/no)으로 확장된다."
-- [ ] **Step 3: CHANGES.md** — `## 2026-06-12` 섹션에 항목 추가 (기존 항목 위):
-
-```markdown
-### feat(okstra-ctl/report-views, wizard): final-report HTML 에서 plan 승인·구현 옵션 선택 지원
-
-- **배경**: planning 보고서 승인은 frontmatter 수동 편집 또는 `--approve` 플래그, 옵션 선택은 `--implementation-option` 플래그뿐이라 보고서를 검토하는 HTML 화면에서 곧바로 의사를 기록할 수 없었다.
-- **해결**: implementation-planning HTML 에 Plan Approval 섹션(옵션 select — 권장 기본값, 승인 체크; §1 Blocks=approval 미해소 시 disabled) 추가. Export sidecar 에 `## APPROVAL` 블록으로 직렬화하고, implementation 마법사 approve-confirm 단계가 감지해 사용자 확인 후 기존 `--approve`/`--implementation-option` 경로로 적용. 인터랙티브 html 렌더 시 `user-responses/` 디렉토리를 선생성. 강제 지점은 report-views/wizard 단위 테스트와 기존 승인 게이트(`_validate_approved_plan`) 무변경 유지.
-- 사용자 영향: 다음 release 후 planning 보고서 HTML 에서 승인·옵션을 체크해 Export 하고, implementation 시작 마법사에서 "예 — HTML 기록대로" 한 번으로 승인+옵션이 적용된다.
-```
-
-- [ ] **Step 4: 빌드 + 전체 테스트** — Run: `npm run build && python3 -m pytest tests/ -q` → 전체 PASS, `bash validators/validate-workflow.sh` 도 PASS
-- [ ] **Step 5: 실물 검증** — dev-9186 planning 보고서로 재렌더해 위젯 확인:
-
-```bash
-python3 scripts/okstra-render-report-views.py \
-  "/Volumes/Workspaces/workspace/projects/FontsNinja/app/fontradar-v2-api/.okstra/tasks/calcule-des-prix-1-1/dev-9186/runs/implementation-planning/reports/final-report-implementation-planning-002.md"
-grep -c 'id="plan-approval"' .../final-report-implementation-planning-002.html   # expect 1
-ls .../runs/implementation-planning/user-responses/                               # 디렉토리 존재
-```
-
-(해당 보고서는 §1 에 open Blocks=approval 행이 있으므로 위젯이 **disabled + 사유 표시** 로 렌더되는 것까지 확인.)
-
-- [ ] **Step 6: Commit** — `git add templates/reports/user-response.template.md skills/okstra-report-writer/SKILL.md skills/okstra-run/SKILL.md CHANGES.md && git commit -m "docs(reports,skills): HTML Plan Approval 흐름 문서화 + CHANGES 기록"`