okstra 0.210.0 → 0.211.0

package/docs/cli.md

@@ -868,8 +868,8 @@ The `okstra` Node CLI (`bin/okstra`) provides both installer/admin commands and
 | `okstra migrate [--apply] [--cwd <dir>] [--quiet]` | One-time migration of the project artifact root from `.project-docs/okstra/` to `.okstra/`. It is a dry run by default; `--apply` performs the move with `git mv` in a Git worktree, removes an empty `.project-docs/`, and synchronizes the `<PROJECT>/CLAUDE.md` import line, `.gitignore`, the project's rows in `~/.okstra/{recent,active}.jsonl`, and `~/.okstra/worktrees/registry.json`. It exits 1 if `.okstra/` already exists or the legacy directory is absent. Scheduled for removal by the end of v0.x |
 | `okstra task-list [--project-root <path>]` | Combine `list_project_tasks` and `read_latest_task` into JSON containing the task catalog and latest task |
 | `okstra task-show <task-key> [--project-root <path>]` | Summarize workflow, phase, status, and artifacts from the Task Read-Side Snapshot |
-| `okstra stage-map <task-key> [--cwd <dir>\|--project <dir>]` | Dump the task's implementation-planning Stage Map as JSON: `{ ok, taskKey, taskRoot, state, sourcePlanPath, stages:[{stage_number,title,depends_on,step_count}], doneStages:[int] }`. `sourcePlanPath` is the task's latest implementation-planning report — the authority on which stages exist, so a plan amendment's added stages are selectable as soon as the amended plan lands. `state` is `ready` for a resolved source and `missing` when no Stage Map exists; a corrupt source returns a structured non-zero error instead of silently selecting another report. `doneStages` is read from the implementation-planning stage consumer state (with carry recovery). This is the read-side source `/okstra-schedule-gen [task-group]` uses to derive selectable unfinished stages and their completed dependency closure |
-| `okstra stage-close <task-key> --stage <N> --from-commit <sha> [--cwd <dir>\|--project <dir>]` | Record the `done` stage-consumer row an implementation run would have written, for a stage whose work is already committed but which never registered as done — the run ended before writing its carry sidecar, and `backfill_done_from_carry` recovers only from that file. Without it `stage-map` reports `doneStages: []` while the branch carries the commit, the next plan re-describes the stage, and every RED expectation it produces is unreachable. Refuses unless the Stage Map has that stage, no `done`/`failed` row exists for it, `--from-commit` resolves to a commit in the project repo, and the stage's conformance gate permits progress — the same `decide_conformance_gate` the run validator uses, so a stage closed here is not one the validator would have blocked. Closing also moves the `stage-<N>-exit` tag and releases the stage reservation, exactly as a normal stage completion does. Emits `{ ok, taskKey, taskRoot, stage, headCommit, conformance, consumersPath }` |
+| `okstra stage-map <task-key> [--cwd <dir>\|--project <dir>]` | Dump the task's implementation-planning Stage Map as JSON: `{ ok, taskKey, taskRoot, state, sourcePlanPath, stages:[{stage_number,title,depends_on,step_count,cancelled}], doneStages:[int] }`. Each stage row carries `cancelled: true` when the plan marks that Stage Map row `status: cancelled`; such a stage is never selected, cannot be closed, and is left out of whole-task final verification and release handoff. `sourcePlanPath` is the task's latest implementation-planning report — the authority on which stages exist, so a plan amendment's added stages are selectable as soon as the amended plan lands. `state` is `ready` for a resolved source and `missing` when no Stage Map exists; a corrupt source returns a structured non-zero error instead of silently selecting another report. `doneStages` is read from the implementation-planning stage consumer state (with carry recovery). This is the read-side source `/okstra-schedule-gen [task-group]` uses to derive selectable unfinished stages and their completed dependency closure |
+| `okstra stage-close <task-key> --stage <N> --from-commit <sha> [--cwd <dir>\|--project <dir>]` | Record the `done` stage-consumer row an implementation run would have written, for a stage whose work is already committed but which never registered as done — the run ended before writing its carry sidecar, and `backfill_done_from_carry` recovers only from that file. Without it `stage-map` reports `doneStages: []` while the branch carries the commit, the next plan re-describes the stage, and every RED expectation it produces is unreachable. Refuses unless the Stage Map has that stage and does not mark it cancelled, no `done`/`failed` row exists for it, `--from-commit` resolves to a commit in the project repo, and the stage's conformance gate permits progress — the same `decide_conformance_gate` the run validator uses, so a stage closed here is not one the validator would have blocked. Closing also moves the `stage-<N>-exit` tag and releases the stage reservation, exactly as a normal stage completion does. Emits `{ ok, taskKey, taskRoot, stage, headCommit, conformance, consumersPath }` |
 | `okstra incremental-scope <args…>` | Decide re-verify vs carry-forward scope for an `implementation-planning` clarification re-run. Thin shim into `scripts/okstra_ctl/incremental_scope.py` (deterministic): it reads the dependency graph from the prior run `data.json`'s `implementationPlanning.stageMap` and returns `mode:"incremental"` only when the base-ref SHA is unchanged and the affected stages' `downstream_stage_closure` covers at most half of all stages; `--full-reason` (selected option / Stage Map / approach) still forces `mode:"full"`. An answered `C-NNN` that traces to no stage returns `mode:"unresolved"` rather than full — pass `--impacted` with the stage numbers or `--full-reason`. `--run-manifest <path>` is required for a decision (not for `--preview`): the same decision is written to the record that manifest names in `incrementalDecisionPath`, so the report writer's authoring contract and `okstra incremental-carry` read it instead of CSVs the lead re-typed. `mode: "unresolved"` is a question back to the lead and is deliberately not recorded. `--preview --prev-data <path> --answered-clarifications <csv>` runs the link half alone — no base SHA, no side effects — and prints `{wouldForceFull, unlinkedIds, reason}`; unlinked ids set `wouldForceFull: false` and fill `unlinkedIds` |
 | `okstra incremental-carry <args…>` | Merge carried-forward plan-item verdicts into an incremental re-run. Contract v3 takes `--prev-data`, `--cur-narrative`, and the convergence-owned `--state`; it verifies carried stage rows and writes only `--out-state`, tagging copied verdicts with `carriedForwardFromSeq`. Pass `--decision <incrementalDecisionPath>` for the two stage sets — the same record the report writer's authoring contract was built from — instead of `--carry-stages` / `--reverify-stages`, which the lead re-typed off stdout; the two forms cannot be combined, and a record whose `mode` is not `incremental` is refused. Unchanged `P-Val-*` / `P-Req-*` / `P-Rb-*` rows whose extract hash still matches are carried the same way, and the sibling `plan-items-*.json` `dispatchQueue` is rewritten to match. The historical v2 `--cur-data --out` form remains readable. Ownership, scope, item, or schema drift raises `CarryError` and forces a full fallback. |
 | `okstra code-review target --task-key <k> --stage <N> [--project-root <dir>] [--cwd <dir>] [--json]` / `okstra code-review target --branch <name> [--base <ref>] [--date <YYYY-MM-DD>] [--project-root <dir>] [--cwd <dir>] [--json]` | Resolve what a code review reads and where its result file goes. Output is always JSON, so `--json` only makes that explicit. `--project-root` and `--cwd` are shared pre-dispatch arguments and apply to both modes; `--cwd` is only consulted when `--project-root` is absent. Both modes return `{ ok, projectRoot, mode, worktreePath, branch, baseCommit, headCommit, reviewPath, round }`; stage mode additionally returns `taskKey`, `taskRoot`, and `stage`. Stage mode takes the diff base from the `base_ref` recorded on that stage's worktree-registry row when it was provisioned — not from a rule re-applied at review time — and names the result `.okstra/tasks/<task-group>/<task-id>/code-reviews/stage-<NN>.md`, where a re-review of the same stage becomes `-r2`, `-r3`, … (the `round` field). Only a legacy row provisioned before `base_ref` was recorded falls back to re-deriving the base through `stage_targets`, and a failure there is reported as `stage_base_unresolved`. `worktreePath` comes back empty whenever the stage worktree is not usable as a live checkout — the registry row is no longer `active` (whole-task final-verification released it), the row never carried a path, or the recorded directory is gone — and the review then reads the `branch` ref instead. Branch mode uses `--base` when given, otherwise the merge-base with the default branch (`refs/remotes/origin/HEAD`, else `main`/`master`), and names the result `.project-docs/code-reviews/<branch>/<YYYY-MM-DD>-<NN>.md`, where `<NN>` (the `round` field) is the next sequence number for that date — the highest already on disk plus one. Read-only: it resolves paths and creates no directory and no file, so the review directory does not exist until the caller writes the report. Backend for the okstra-code-review skill |

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "okstra",
-  "version": "0.210.0",
+  "version": "0.211.0",
   "description": "Host-aware multi-provider cross-verification orchestrator runtime and agent skills.",
   "license": "MIT",
   "author": "devonshin",

package/runtime/BUILD.json

@@ -1,5 +1,5 @@
 {
-  "package": "0.210.0",
-  "builtAt": "2026-10-05T13:33:31.081Z",
+  "package": "0.211.0",
+  "builtAt": "2026-10-06T01:25:20.915Z",
   "repoRoot": "/home/runner/work/okstra/okstra"
 }

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

@@ -372,14 +372,14 @@
       }
     },
     "directive_pick": {
-      "label": "추가 directive 가 있나요?",
+      "label": "이번 run 에 덧붙일 추가 지시(directive)를 고르세요. directive 는 instruction-set/directive.txt 로 저장되어 리드와 워커가 읽습니다. 브리프와 이전 리포트에 없는 새 결정(직전 run 이후 정한 사항 등)은 여기에 넣어야 계획에 반영됩니다.",
       "echo_template": "directive(pick): {value}",
       "options": {
         "__skip__": "없음 (건너뛰기)",
         "__free_input__": "직접 입력"
       },
       "labels": {
-        "reuse_last": "이전 run 의 directive 재사용: {snippet}"
+        "reuse_last": "이전 run 의 directive 재사용: {snippet}", "context_file": " — 이 directive 는 파일 {path} 을 읽으라는 지시이고, 그 파일은 {date} 에 마지막으로 바뀌었습니다. 이후 정한 결정은 들어 있지 않습니다", "context_missing": " — 이 directive 가 가리키는 파일 {path} 이 없습니다"
       },
       "echo_suffixes": {
         "reuse": "directive: {value} (재사용)",
@@ -477,7 +477,7 @@
       }
     },
     "reuse_previous": {
-      "label": "이 task·phase 의 직전 run 설정이 남아 있습니다. 그대로 재사용할까요?\n· 예 — 직전 run 의 워커 구성·역할별 모델·directive·관련 task 를 그대로 가져오고, 가장 최근 final-report 를 clarification 입력으로 자동 선택해 바로 확인 단계로 넘어갑니다.\n· 아니오 — 모델/워커/directive 등을 단계별로 다시 입력합니다.",
+      "label": "이 task·phase 의 직전 run 설정이 남아 있습니다. 그대로 재사용할까요?\n· 예 — 직전 run 의 워커 구성·역할별 모델·directive·관련 task 를 가져오고, 가장 최근 final-report 를 clarification 입력으로 자동 선택합니다. 가져온 항목은 다시 묻지 않고, 재사용 대상이 아닌 단계(기준 브랜치·재검증 범위 등)는 이어서 묻습니다.\n· 아니오 — 모델/워커/directive 등을 단계별로 다시 입력합니다.\n재사용할 directive: {directive}\n직전 run 이후 새로 정한 결정이 있으면 이 directive 에 없습니다. 확인 단계의 수정에서 directive_pick 을 고르면 directive 부터 다시 고를 수 있습니다(역할별 모델은 유지).",
       "echo_template": "reuse-previous: {value}",
       "options": {
         "yes": "예 — 직전 설정 그대로 진행",

package/runtime/python/okstra_ctl/manager_launch.py

@@ -7,6 +7,7 @@ from pathlib import Path
 from okstra_ctl.jsonl import append_jsonl, read_jsonl
 
 from .manager_paths import (
+    MANAGER_CONTEXT_DIRECTIVE_PREFIX,
     child_context_path,
     children_json_path,
     directives_jsonl_path,
@@ -244,7 +245,7 @@ def build_launch_packet(
         run_args.extend(["--task-brief", str(child["briefPath"])])
     run_args += [
         "--directive",
-        f"Read manager child context: {context_path}",
+        f"{MANAGER_CONTEXT_DIRECTIVE_PREFIX}{context_path}",
     ]
     packet = {
         "managerId": manager_id,

package/runtime/python/okstra_ctl/manager_paths.py

@@ -118,3 +118,7 @@ def child_context_path(
 
 def view_html_path(home: Path, manager_id: str) -> Path:
     return manager_root(home, manager_id) / "view" / "index.html"
+
+
+# manager 가 자식 run 에 넘기는 directive 의 앞부분. 위저드는 이 접두로 컨텍스트 파일을 찾는다.
+MANAGER_CONTEXT_DIRECTIVE_PREFIX = "Read manager child context: "

package/runtime/python/okstra_ctl/phases/implementation/instructions/_implementation-deliverable.md

@@ -12,11 +12,12 @@ are collected and convergence finished. Phase 1-5 do not need it.
 
 - **Plan link & approval evidence**: path to the approved `final-report.md`, the exact quoted approval marker, AND the executed stage number / title quoted from the Stage Map row. For a selected-direction plan, also quote `selectedDirectionRef.optionId`, `snapshotPath`, and the validated snapshot digest; for a legacy plan, quote the effective `implementation-option` or the Recommended Option fallback.
 - **Commit list**: each commit's SHA (or short SHA), message, and the plan step(s) / TDD cycle it satisfies
-- **Diff summary**: capture `git diff --stat <base>..<captured-head>` and `git diff --numstat <base>..<captured-head>` for the full implementation stage, including after a fix run. Supply both outputs to the report writer; populate each `diffSummary.files[].lines` with its added/deleted counts and a one-line change summary. Do not substitute a fix-run aggregate or carry forward older statistics. If the captured commits are unavailable, identify the missing reference in the evidence instead of inventing counts.
+- **Diff summary**: capture `git diff --stat <base>..<captured-head>` and `git diff --numstat <base>..<captured-head>` for the full implementation stage, including after a fix run. Supply both outputs to the report writer; put each file's added/deleted counts alone in `diffSummary.files[].lines` (`+150/-0`) and one sentence on what the change in that file does in `diffSummary.files[].summary` — the report renders `summary` as the file's "what it does" column and `lines` as a separate number column. Do not substitute a fix-run aggregate or carry forward older statistics. If the captured commits are unavailable, identify the missing reference in the evidence instead of inventing counts.
+- **Change narrative scope**: `userNarrative.changeExplanation` describes the same scope as `diffSummary` — the whole stage from its base, every file the table lists. On a fix run, state what the fix run itself changed (its commits and files) as a separate sentence; never present the fix-run delta as the stage's change.
 - **Out-of-plan edits block**: every file edited that was not in the approved plan's file list, with rationale (empty block is acceptable and preferred)
 - **Clarification answers carried in**: when `instruction-set/clarification-response.md` exists, it holds the user's answers to the approved plan's `## 1. Clarification Items` rows. The report MUST render the `## 0. Clarification Response Carried In From Previous Run` section (set `clarificationCarryIn.sourceFile` to that path) and, for every carried-over `## 1.` row whose answer appears there, record the answer in the `User input` cell and flip `Status` to `resolved`. A row left `open`/`answered` despite a matching user answer is a contract violation; an answer that materially changes scope beyond the approved plan is routed to a new `implementation-planning` run, not silently executed.
-- **Stage sidecar evidence**: the JSON payload of `runs/<impl-task-key>/carry/stage-<N>.json` is embedded verbatim in a fenced ```json``` block, AND the `consumers.jsonl` rows this run appended are quoted line-by-line, so reviewers can audit the carry surface without grepping artifact directories.
-- **Validation evidence**: actual command output (stdout/stderr) for every `pre / mid / post` validation command from the plan. Truncated output is acceptable but the command line and exit code MUST be exact. No paraphrasing of test results.
+- **Stage sidecar evidence**: set `stageSidecarEvidence.carryJson` to the path `runs/<impl-task-key>/carry/stage-<N>.json` followed by a one-line summary of its payload — stage number, step results by status, stage commit range, number of files changed. Do not paste the payload itself: the file on disk is the record (`_validate_stage_carry_sidecar_exists` checks that it exists), and a pasted one-line JSON is unreadable in the report. Quote the `consumers.jsonl` rows this run appended line-by-line in `consumerRows`.
+- **Validation evidence**: actual command output (stdout/stderr) for every `pre / mid / post` validation command from the plan. Truncated output is acceptable but the command line and exit code MUST be exact. No paraphrasing of test results. Set `checkId` to the plan's `validationChecklist` id (`VC-007`) when the row runs a checklist command, and `advisory: true` on a row whose check is advisory (an external Tier 3 conformance entry, for example) so a non-zero exit there is not shown as a failure.
 - **TDD evidence (when applicable)**: for steps that should be TDD-ordered, show the failing-test output captured BEFORE the merged commit and the passing-test output after, citing the single `feat|fix` commit SHA (test and implementation share one commit).
 - **Verifier results**: a section per verifier present in the resolved roster (`Claude verifier`, `Codex verifier`, and `Antigravity verifier` when opted in) containing:
   - their independent verdict (PASS / CONCERNS / FAIL),
@@ -66,4 +67,4 @@ are collected and convergence finished. Phase 1-5 do not need it.
 - On a non-`FAIL` verdict, for this run's single stage: append a `status:"done"` row to `runs/<plan-task-key>/consumers.jsonl` with `completed_at`, `carry_path`, `report_path` (this run's final-report path relative to the run root), and the SHA of HEAD. Append it with `okstra_ctl.consumers.append_consumer` (NOT a raw filesystem write) — that call honours the consumers lock AND releases this stage's worktree-registry occupancy, so later runs stop seeing a finished stage as a concurrent run. `report_path` lets `final-verification` cite each stage's originating report when assembling its Source Implementation Report list.
 - **Reopening a settled stage.** Appending a `status:"failed"` row after a `done` one withdraws that stage: `--stage N` accepts it again, its dependents stop resolving a base from the withdrawn head, and whole-task final-verification blocks until it is settled again. Use the same `okstra_ctl.consumers.append_consumer` call with a `reason`, and re-run the stage rather than repairing the tree outside okstra — a stage reverted outside the ledger leaves the recorded `head_commit` and the carry sidecar naming a tree that no longer exists, and the next stage branches from it.
 - The verifier round, Phase 5.5 convergence, and this Phase 6 report run **once per run** over this stage's diff — NOT per step.
-- Quote this stage's new contents (the sidecar JSON in full and the new consumers row by itself) in the final report's `Stage sidecar evidence` deliverable section.
+- Record this stage's new contents in the final report's `Stage sidecar evidence` deliverable section: the sidecar by path with its one-line summary, and the new consumers row quoted by itself.

package/runtime/python/okstra_ctl/phases/implementation/report.py

@@ -1,9 +1,12 @@
 """Human-first implementation delivery view model."""
 from __future__ import annotations
 
+import json
+import re
+from collections import Counter
+
 from okstra_ctl.report_html.common import evidence_index
-from okstra_ctl.report_html.models import HumanReportView, VisualNode
-from okstra_ctl.report_html.visualizations import change_map_figure
+from okstra_ctl.report_html.models import HumanReportView
 
 # Record fields this template anchors as `id-<row id>` (see
 # `HumanReportView.anchored_fields`); ids elsewhere land in the ledger.
@@ -13,39 +16,83 @@ ANCHORED_FIELDS = (
 )
 
 
-_FILE_ACTIONS = {"created": "Created", "modified": "Modified", "deleted": "Deleted"}
+def _carry_payload(text: str) -> dict | None:
+    start = text.find("{")
+    if start < 0:
+        return None
+    try:
+        payload, _ = json.JSONDecoder().raw_decode(text[start:])
+    except json.JSONDecodeError:
+        # expected-miss: carryJson 은 경로+요약 산문일 수 있다. 그때는 본문에 글 그대로 보인다.
+        return None
+    return payload if isinstance(payload, dict) else None
 
 
-def _change_nodes(implementation: dict) -> tuple[VisualNode, ...]:
-    return tuple(
-        VisualNode(
-            row["file"],
-            row["file"],
-            row["planStep"],
-            row["action"],
-            row["lines"],
-            note=f'{_FILE_ACTIONS.get(row["action"], row["action"])} · plan step {row["planStep"]}',
-        )
-        for row in implementation["diffSummary"]["files"]
+def _carry_view(evidence: dict | None) -> dict | None:
+    if not evidence:
+        return None
+    text = evidence["carryJson"]
+    payload = _carry_payload(text)
+    if payload is None:
+        return {"text": text}
+    commit_range = payload.get("stageCommitRange") or {}
+    base, head = commit_range.get("base"), commit_range.get("head")
+    steps = Counter(
+        str(row.get("status"))
+        for row in payload.get("stepResults") or ()
+        if isinstance(row, dict)
     )
+    files = payload.get("filesChanged")
+    return {
+        "path": f"carry/stage-{evidence['stageNumber']}.json",
+        "commitRange": f"{base[:8]}..{head[:8]}" if base and head else None,
+        "steps": ", ".join(f"{status} {count}" for status, count in steps.items()),
+        "filesChanged": len(files) if isinstance(files, list) else None,
+        "raw": json.dumps(payload, indent=2, ensure_ascii=False),
+    }
+
+
+_LEADING_CHECK_ID = re.compile(r"^(VC-\d{3,})\b")
+_COMMAND_PREVIEW = 60
+
+
+def _validation_card(row: dict) -> dict:
+    # checkId 가 없는 진행 중 task 는 writer 가 outputTail 머리에 붙인 VC id 를 보여 준다(표시 전용).
+    check_id = row.get("checkId")
+    if not check_id:
+        match = _LEADING_CHECK_ID.match(row["outputTail"])
+        check_id = match.group(1) if match else None
+    command = row["command"]
+    preview = command if len(command) <= _COMMAND_PREVIEW else command[: _COMMAND_PREVIEW - 1] + "…"
+    if not row["exitCode"]:
+        tone = "neutral"
+    elif row.get("advisory"):
+        tone = "medium"
+    else:
+        tone = "important"
+    return {**row, "checkId": check_id, "commandPreview": preview, "tone": tone}
 
 
 def build_implementation_view(data: dict) -> HumanReportView:
     implementation = data["implementation"]
-    figure = change_map_figure(
-        nodes=_change_nodes(implementation), title="Delivered change areas"
-    )
     context = {
         "humanSummary": data["humanSummary"],
         "implementation": implementation,
         "narrative": implementation["userNarrative"],
-        "changeFigure": figure,
+        # 진행 중인 task 의 data.json 에는 파일별 summary 가 없다. 빈 열을 그리지 않는다.
+        "diffHasSummary": any(
+            row.get("summary") for row in implementation["diffSummary"]["files"]
+        ),
+        "validationCards": [
+            _validation_card(row) for row in implementation["validationEvidence"]
+        ],
+        "carry": _carry_view(implementation.get("stageSidecarEvidence")),
         "evidenceIndex": evidence_index(data, ANCHORED_FIELDS),
     }
     return HumanReportView(
         "implementation",
         "html/tasks/implementation.template.html",
         context,
-        (figure,),
+        (),
         anchored_fields=ANCHORED_FIELDS,
     )

package/runtime/python/okstra_ctl/phases/implementation/report_assets/implementation.template.html

@@ -1,6 +1,5 @@
 {% extends "html/base.template.html" %}
 {% from "html/macros/layout.html" import narrative as render_narrative, summary_card, row_key, file_paths %}
-{% from "html/macros/visualizations.html" import figure %}
 
 {% block human_content %}
 <section data-report-section="delivered-outcome">
@@ -12,19 +11,19 @@
 <section data-report-section="change-map" data-report-field="implementation.diffSummary">
   <h2>{{ t('tasks.implementation.what-changed') }}</h2>
   {{ render_narrative(narrative.changeExplanation, "implementation.userNarrative.changeExplanation") }}
-  {{ figure(changeFigure) }}
+  <table><thead><tr><th>{{ t('tasks.implementation.file') }}</th><th>{{ t('tasks.implementation.change') }}</th>{% if diffHasSummary %}<th>{{ t('tasks.implementation.what-it-does') }}</th>{% endif %}<th class="figure">{{ t('tasks.implementation.lines') }}</th><th>{{ t('tasks.implementation.plan-step') }}</th></tr></thead><tbody>{% for row in implementation.diffSummary.files %}<tr><td><code>{{ row.file }}</code></td><td>{{ t('tasks.implementation.action-' ~ row.action) }}</td>{% if diffHasSummary %}<td>{{ row.get('summary', '') | inline_code }}</td>{% endif %}<td class="figure">{{ row.lines }}</td><td>{{ row.planStep | inline_code }}</td></tr>{% endfor %}</tbody></table>
 </section>
 
 <section data-report-section="requirement-coverage">
   <h2>{{ t('tasks.implementation.requirement-coverage') }}</h2>
-  <table data-report-field="implementation.requirementCoverage"><thead><tr><th>{{ t('tasks.implementation.requirement') }}</th><th>{{ t('tasks.implementation.body') }}</th><th>{{ t('tasks.implementation.implemented-by') }}</th></tr></thead><tbody>{% for row in implementation.requirementCoverage %}<tr id="id-{{ row.id }}">{{ row_key(pairs=[(t('macros.layout.id'), row.id)], status_name=t('macros.layout.status'), status_raw=row.status, status_text=row.status) }}<td>{{ row.requirement | inline_code }}</td><td>{{ row.coveredBy | inline_code }}</td></tr>{% endfor %}</tbody></table>
+  <table data-report-field="implementation.requirementCoverage"><thead><tr><th>{{ t('tasks.implementation.requirement') }}</th><th>{{ t('tasks.implementation.body') }}</th><th>{{ t('tasks.implementation.implemented-by') }}</th></tr></thead><tbody>{% for row in implementation.requirementCoverage %}<tr id="id-{{ row.id }}">{{ row_key(pairs=[(t('macros.layout.id'), row.id)], status_name=t('macros.layout.status'), status_raw=row.status, status_text=(row.status.split(' ')[0] | enum_label('requirementStatus')) ~ ((' ' ~ row.status.split(' ', 1)[1]) if ' ' in row.status else '')) }}<td>{{ row.requirement | inline_code }}</td><td>{{ row.coveredBy | inline_code }}</td></tr>{% endfor %}</tbody></table>
 </section>
 
 <section data-report-section="validation" data-report-field="implementation.validationEvidence">
   <h2>{{ t('tasks.implementation.verification-result') }}</h2>
   {{ render_narrative(narrative.validationExplanation, "implementation.userNarrative.validationExplanation") }}
-  <div class="summary-grid">{% for row in implementation.validationEvidence %}{{ summary_card(row.phase ~ " · " ~ t('tasks.implementation.exit-code') ~ " " ~ row.exitCode, row.outputTail, "important" if row.exitCode else "neutral") }}{% endfor %}</div>
-  {% for row in implementation.verifierResults %}<article class="summary-card tone-{{ row.verdict | lower }}"><p class="eyebrow">{{ row.verifier | inline_code }} · <span class="status status-{{ row.verdict | lower }}">{{ row.verdict }}</span></p>{% if row.get("independentValidationRerun") %}<p><strong>{{ t('tasks.implementation.independent-rerun') }}</strong> {{ row.independentValidationRerun | inline_code }}</p>{% endif %}{% if row.get("readOnlyCommandLog") %}<p><strong>{{ t('tasks.implementation.command-log') }}</strong> {{ row.readOnlyCommandLog | inline_code }}</p>{% endif %}{% if row.get("discrepancy") %}<p class="evidence-refs">{{ t('tasks.implementation.discrepancy') }} {{ row.discrepancy | inline_code }}</p>{% endif %}{% if row.get("declinedFixRecommendations") %}<p>{{ row.declinedFixRecommendations | inline_code }}</p>{% endif %}</article>{% endfor %}
+  <div class="summary-grid">{% for row in validationCards %}<article class="summary-card tone-{{ row.tone }}"><h3>{% if row.checkId %}{{ row.checkId }} · {% endif %}{{ row.phase }} · {{ t('tasks.implementation.exit-code') }} {{ row.exitCode }}{% if row.get("advisory") %} · {{ t('tasks.implementation.advisory') }}{% endif %}</h3><p><code title="{{ row.command }}">{{ row.commandPreview }}</code></p><p>{{ row.outputTail | inline_code }}</p></article>{% endfor %}</div>
+  {% for row in implementation.verifierResults %}<article class="summary-card tone-{{ row.verdict | lower }}"><p class="eyebrow">{{ row.verifier | inline_code }} · <span class="status status-{{ row.verdict | lower }}">{{ row.verdict }}</span></p>{% for label, text in ((t('tasks.implementation.independent-rerun'), row.get("independentValidationRerun")), (t('tasks.implementation.command-log'), row.get("readOnlyCommandLog"))) if text %}<details><summary><strong>{{ label }}</strong> {{ t('tasks.implementation.entry-count') | replace('{count}', text.strip().splitlines() | select | list | length | string) }}</summary><pre>{{ text }}</pre></details>{% endfor %}{% if row.get("discrepancy") %}<p class="evidence-refs">{{ t('tasks.implementation.discrepancy') }} {{ row.discrepancy | inline_code }}</p>{% endif %}{% if row.get("declinedFixRecommendations") %}<p>{{ row.declinedFixRecommendations | inline_code }}</p>{% endif %}</article>{% endfor %}
 </section>
 
 <section data-report-section="remaining-issues">
@@ -42,8 +41,10 @@
 
 <section data-report-section="rollback" data-report-field="implementation.rollbackVerification">
   <h2>{{ t('tasks.implementation.can-this-be-rolled-back') }}</h2>
-  <table><thead><tr><th>{{ t('tasks.implementation.subject') }}</th><th>{{ t('tasks.implementation.rollback-command') }}</th><th>{{ t('tasks.implementation.how-to-verify') }}</th><th>{{ t('tasks.implementation.result') }}</th></tr></thead><tbody>{% for row in implementation.rollbackVerification %}<tr><td>{{ row.category | inline_code }}</td><td><code>{{ row.rollbackCommand }}</code></td><td>{{ row.verification | inline_code }}</td><td>{{ row.result | inline_code }}</td></tr>{% else %}<tr><td colspan="4">{{ t('tasks.implementation.no-rollback-check-was-recorded') }}</td></tr>{% endfor %}</tbody></table>
-  {% if implementation.stageSidecarEvidence %}<p data-report-field="implementation.stageSidecarEvidence"><strong>{{ t('tasks.implementation.stage-carry-over') }}</strong> — Stage {{ implementation.stageSidecarEvidence.stageNumber }} {{ implementation.stageSidecarEvidence.stageTitle | inline_code }} · <code>{{ implementation.stageSidecarEvidence.carryJson }}</code></p>{% endif %}
+  <table><thead><tr><th>{{ t('tasks.implementation.subject') }}</th><th>{{ t('tasks.implementation.rollback-command') }}</th><th>{{ t('tasks.implementation.how-to-verify') }}</th><th>{{ t('tasks.implementation.result') }}</th></tr></thead><tbody>{% for row in implementation.rollbackVerification %}<tr><td>{{ row.category | enum_label('rollbackCategory') }}</td><td><code>{{ row.rollbackCommand }}</code></td><td>{{ row.verification | inline_code }}</td><td>{{ row.result | enum_label('rollbackResult') }}</td></tr>{% else %}<tr><td colspan="4">{{ t('tasks.implementation.no-rollback-check-was-recorded') }}</td></tr>{% endfor %}</tbody></table>
+  {% if implementation.stageSidecarEvidence %}<div data-report-field="implementation.stageSidecarEvidence"><p><strong>{{ t('tasks.implementation.stage-carry-over') }}</strong> — Stage {{ implementation.stageSidecarEvidence.stageNumber }} {{ implementation.stageSidecarEvidence.stageTitle | inline_code }}</p>
+  {% if carry.get("text") %}<p>{{ carry.text | inline_code }}</p>{% else %}<table><tbody><tr><th>{{ t('tasks.implementation.carry-sidecar') }}</th><td><code>{{ carry.path }}</code></td></tr>{% if carry.commitRange %}<tr><th>{{ t('tasks.implementation.carry-commit-range') }}</th><td><code>{{ carry.commitRange }}</code></td></tr>{% endif %}{% if carry.steps %}<tr><th>{{ t('tasks.implementation.carry-steps') }}</th><td>{{ carry.steps }}</td></tr>{% endif %}{% if carry.filesChanged is not none %}<tr><th>{{ t('tasks.implementation.carry-files-changed') }}</th><td>{{ carry.filesChanged }}</td></tr>{% endif %}</tbody></table>
+  <details><summary>{{ t('tasks.implementation.carry-raw') }}</summary><pre>{{ carry.raw }}</pre></details>{% endif %}</div>{% endif %}
 </section>
 
 <section data-report-section="manual-test" data-report-field="implementation.manualUserTest">

package/runtime/python/okstra_ctl/phases/implementation_planning/authoring.py

@@ -1645,6 +1645,8 @@ def _replace_item_verdicts(
 ) -> None:
     item["verdicts"] = _stamped_verdicts(incoming, round_number, project_root)
     _remember_verified_hash(item)
+    # 이번 run 의 표로 바뀌었으니 더는 직전 run 에서 이월된 항목이 아니다.
+    item.pop("carriedForwardFromSeq", None)
 
 
 def _append_item_verdicts(
@@ -1769,11 +1771,13 @@ def _reject_uncompleted_round_loss(
     for item in recorded:
         if not isinstance(item, Mapping) or item.get("id") not in rows:
             continue
+        # `seed --prior-state` 는 이월 표시를 항목에 찍는다. 이번 run 이 항목을
+        # 다시 판정하면 그 표시는 지워지므로, 표시가 남은 항목의 표는 모두 직전 run 것이다.
+        if str(item.get("carriedForwardFromSeq") or "").strip():
+            continue
         for row in item.get("verdicts") or []:
             if not isinstance(row, Mapping):
                 continue
-            if str(row.get("carriedForwardFromSeq") or "").strip():
-                continue
             recorded_round = row.get("round")
             if (
                 isinstance(recorded_round, int)

package/runtime/python/okstra_ctl/report_html/run_usage.py

@@ -37,6 +37,10 @@ def _agent_row(row: dict) -> dict[str, str]:
     there would read as a missing measurement instead of an absent charge.
     """
     cli_tokens = _number(row.get("cliTotalTokens")) or 0
+    if cli_tokens == _number(row.get("totalTokens")):
+        # A CLI-only agent's raw figure is its CLI figure; a second line would
+        # print the same number twice.
+        cli_tokens = 0
     cli_cost = _number(row.get("cliCostUsd")) or 0
     cost = _number(row.get("costUsd"))
     if cost is None and cli_cost:
@@ -124,10 +128,15 @@ def run_usage(data: dict) -> dict[str, object] | None:
     if not measured:
         return None
     cli_cost = _number((usage.get("cli") or {}).get("costUsd")) or 0
+    grand_cost = _number((usage.get("grand") or {}).get("costUsd")) or 0
+    # The total holds API spend only, while a CLI-only agent's charge sits in
+    # its row's cost cell; this line is what the cost column adds up to.
+    grand_with_cli = grand_cost + cli_cost if cli_cost else 0
     return {
         "rows": [_agent_row(row) for row in rows],
         "unaccounted": _unaccounted(rows, usage.get("grand") or {}),
         **totals,
         "taskCumulative": _task_cumulative(usage.get("taskCumulative")),
         "cliCost": format_usd(cli_cost) if cli_cost else "",
+        "grandWithCli": format_usd(grand_with_cli) if grand_with_cli else "",
     }

package/runtime/python/okstra_ctl/report_html/visualizations.py

@@ -342,14 +342,6 @@ def stage_map_figure(*, nodes: Sequence[VisualNode], edges: Sequence[VisualEdge]
     )
 
 
-def change_map_figure(*, nodes: Sequence[VisualNode], title: str) -> FigureModel:
-    return replace(
-        dependency_figure(nodes=nodes, edges=(), title=title),
-        kind="change-map",
-        figure_id="change-map",
-    )
-
-
 def matrix_figure(*, items: Iterable[VisualNode], title: str, x_label: str, y_label: str) -> FigureModel:
     nodes = tuple(items)
     summary = f"{len(nodes)} items compared by {x_label} and {y_label}"

package/runtime/python/okstra_ctl/report_projections.py

@@ -33,6 +33,22 @@ _STATUS = {
 }
 
 
+def _report_workers(team_state: Mapping[str, Any]) -> list[dict]:
+    """리드 자신의 워커 항목을 뺀 워커 행.
+
+    team-state 는 리드를 `workerId: lead` 워커로도 적는다(agent 없음, 상태
+    `dispatched`). 리드 행은 `lead`·`leadUsage` 에서 따로 만들므로 이 항목을
+    표에 올리면 "Codex · lead · unknown · 미실행" 행이 하나 더 생긴다.
+    """
+    return [
+        row for row in accounting_workers(team_state)
+        if "lead" not in {
+            str(row.get("workerId") or "").strip().lower(),
+            str(row.get("role") or "").strip().lower(),
+        }
+    ]
+
+
 def _text(value: object, fallback: str) -> str:
     text = str(value or "").strip()
     return text or fallback
@@ -148,7 +164,7 @@ def project_execution(
         "role": "Okstra lead",
     }
     lead_usage = team_state.get("leadUsage")
-    worker_rows = accounting_workers(team_state)
+    worker_rows = _report_workers(team_state)
     result: dict[str, Any] = {
         "executionStatus": [
             _execution_row(
@@ -180,7 +196,7 @@ def _usage_row(summary: Mapping[str, Any], prefix: str, cost: object) -> dict[st
 
 def _worker_details(team_state: Mapping[str, Any]) -> list[dict[str, Any]]:
     result = []
-    for worker in accounting_workers(team_state):
+    for worker in _report_workers(team_state):
         if not isinstance(worker, Mapping):
             continue
         usage = worker.get("usage") if isinstance(worker.get("usage"), Mapping) else {}

package/runtime/python/okstra_ctl/report_synthesis_packet.py

@@ -295,6 +295,7 @@ class ReportSynthesisPacket:
                     "Do not invent a value when a source is missing or contradictory.",
                     "Write only the narrative, pointer, and audit artifacts named by the dispatch.",
                     *_INTERNAL_IDENTIFIER_INSTRUCTION,
+                    *_READER_PROSE_INSTRUCTION,
                     *self._schema_instructions(),
                     *self._task_instructions(),
                     *self._carry_instructions(),
@@ -335,6 +336,7 @@ class ReportSynthesisPacket:
         # 작성자가 실제로 읽는 것은 마크다운이다. JSON 정본에만 실으면 지시가
         # 도달하지 않는다.
         lines.extend(f"- {text}" for text in _INTERNAL_IDENTIFIER_INSTRUCTION)
+        lines.extend(f"- {text}" for text in _READER_PROSE_INSTRUCTION)
         lines.extend(f"- {text}" for text in self._schema_instructions())
         lines.extend(f"- {text}" for text in self._task_instructions())
         lines.extend(f"- {text}" for text in self._carry_instructions())
@@ -573,6 +575,23 @@ _INTERNAL_IDENTIFIER_INSTRUCTION = (
 )
 
 
+# 리포트를 읽는 사람은 run 을 보지 않았다. 아래 규칙도 집행 코드가 없고(서사는
+# 자유 서술이다) 저자 지시로만 전달한다 — dev-11126 #003 서사가 어긴 네 가지.
+_READER_PROSE_INSTRUCTION = (
+    "Write every reader-facing field for a reader who did not watch the run: "
+    "each sentence must make sense without the worker results, the plan, or "
+    "the lead's notes.",
+    "Explain a plan- or run-internal id (`VC-`, `OOP-`, `P-Step-`, `OF-`, "
+    "`IO-`, `C-`) in words the first time a field uses it, or leave it out; "
+    "never let a bare id carry the meaning of a sentence.",
+    "Keep commit hashes and file paths out of narrative sentences; put them "
+    "only in evidence lines (`evidence`, `evidenceRefs` and other citation "
+    "fields).",
+    "Name a term by what it does (\"the function that decides whether the "
+    "server is local\") rather than by jargon (\"predicate\").",
+)
+
+
 CARRIED_STAGES_LABEL = "Carried plan stages"
 
 

package/runtime/python/okstra_ctl/report_translation.py

@@ -14,7 +14,9 @@ reader merely reads is offered, and the translator decides.
 
 When a key name carries load-bearing values in even one place, it counts as
 structural everywhere. Missing a translation leaves English on the page;
-translating an anchor id breaks the link.
+translating an anchor id breaks the link. ``PROSE_FIELDS`` is the one
+exception: a field named by its enclosing keys, where that key holds prose
+even though the same name is an id or a path elsewhere.
 """
 from __future__ import annotations
 
@@ -328,6 +330,23 @@ STRUCTURAL_KEYS = frozenset({
 })
 
 
+# Fields whose key is structural by name but holds a sentence at this position.
+# Each tuple matches the tail of the key path with array indices dropped;
+# `endStateCoverage[].coveredBy` is absent because there it is a linked id.
+PROSE_FIELDS = frozenset({
+    ("requirementCoverage", "coveredBy"),
+    ("commitList", "files"),
+    ("manualUserTest", "items", "target"),
+    ("manualUserTest", "items", "steps"),
+})
+
+
+def _is_prose_field(keys: tuple[str, ...]) -> bool:
+    if keys and keys[-1] in PROSE_KEYS:
+        return True
+    return any(keys[-len(field):] == field for field in PROSE_FIELDS)
+
+
 # A key name says what a field is *for*; these say what one value actually is.
 # `evidence` is the largest prose bucket in a real report and also holds bare
 # `src/server.ts:33` citations — the key cannot separate them, the value can.
@@ -367,16 +386,18 @@ def unescape_token(token: str) -> str:
     return token.replace("~1", "/").replace("~0", "~")
 
 
-def _walk(node: Any, pointer: str, key: str) -> Iterator[tuple[str, str]]:
+def _walk(node: Any, pointer: str, keys: tuple[str, ...]) -> Iterator[tuple[str, str]]:
     if isinstance(node, Mapping):
         for child_key, value in node.items():
-            yield from _walk(value, f"{pointer}/{escape_token(str(child_key))}", str(child_key))
+            yield from _walk(
+                value, f"{pointer}/{escape_token(str(child_key))}", (*keys, str(child_key))
+            )
     elif isinstance(node, (list, tuple)):
         for index, value in enumerate(node):
             # An array element inherits the key that named the array, so
             # `evidence: [...]` translates each entry.
-            yield from _walk(value, f"{pointer}/{index}", key)
-    elif isinstance(node, str) and key in PROSE_KEYS and is_translatable_value(node):
+            yield from _walk(value, f"{pointer}/{index}", keys)
+    elif isinstance(node, str) and _is_prose_field(keys) and is_translatable_value(node):
         yield pointer, node
 
 
@@ -386,7 +407,7 @@ def extract(data: Mapping[str, Any]) -> dict[str, str]:
     The translator fills in this map rather than authoring pointers, so a
     sidecar cannot cite a path the document does not have.
     """
-    return dict(_walk(data, "", ""))
+    return dict(_walk(data, "", ()))
 
 
 def group_translation_pointers(

package/runtime/python/okstra_ctl/wizard/state.py

@@ -377,6 +377,25 @@ def _initial_cross_verification_requirement(
     ), None)
 
 
+def _assigned_models_by_role(payload: dict[str, Any]) -> dict[str, list[tuple[str, str]]]:
+    """run-inputs 의 `workerAssignments` 를 역할별 (provider, model) 로.
+
+    지금 run-inputs 의 `workers` 는 provider 가 아니라 worker id(`claude-planner`)를
+    적는다. 그 값으로 `<provider>Model` 을 찾으면 아무 모델도 복원되지 않는다.
+    """
+    rows = payload.get("workerAssignments")
+    assigned: dict[str, list[tuple[str, str]]] = {}
+    for row in rows if isinstance(rows, list) else ():
+        if not isinstance(row, dict):
+            continue
+        role, provider, model = row.get("role"), row.get("provider"), row.get("model")
+        if isinstance(role, str) and isinstance(provider, str) and provider:
+            assigned.setdefault(role, []).append(
+                (provider, model if isinstance(model, str) else "")
+            )
+    return assigned
+
+
 def _role_selections_from_run_inputs(
     state: WizardState,
     payload: dict[str, Any],
@@ -385,7 +404,10 @@ def _role_selections_from_run_inputs(
     profile = _load_role_profile_for_state(state)
     pool = ModelPool.from_registry(default_provider_registry())
     cross_requirement = _initial_cross_verification_requirement(profile)
+    assigned = _assigned_models_by_role(payload)
     providers = _legacy_worker_providers(payload)
+    if cross_requirement is not None and cross_requirement.role in assigned:
+        providers = [provider for provider, _ in assigned[cross_requirement.role]]
     if cross_requirement is not None:
         selected_count = cross_requirement.recommended_count
         if providers and cross_requirement.min_count < cross_requirement.max_count:
@@ -400,8 +422,13 @@ def _role_selections_from_run_inputs(
                 model.provider_id
                 for model in pool.default_candidates(cross_requirement.role)
             ]
+        assigned_models = [model for _, model in assigned.get(cross_requirement.role, ())]
         for ordinal, provider in enumerate(providers[:selected_count], start=1):
-            raw_model = payload.get(f"{provider}Model", "")
+            raw_model = (
+                assigned_models[ordinal - 1]
+                if ordinal <= len(assigned_models)
+                else payload.get(f"{provider}Model", "")
+            )
             model_ref = _legacy_model_ref(
                 pool,
                 provider,
@@ -433,6 +460,8 @@ def _role_selections_from_run_inputs(
         if not requirement.dynamic and requirement.min_count > 0
     }
     for role, provider, raw_model in provider_rows:
+        if assigned.get(role):
+            provider, raw_model = assigned[role][0]
         if role not in static_roles or not isinstance(provider, str) or not provider:
             continue
         model_ref = _legacy_model_ref(pool, provider, role, raw_model)

package/runtime/python/okstra_ctl/wizard/steps_options.py

@@ -2,10 +2,12 @@
 from __future__ import annotations
 
 from dataclasses import dataclass
+from datetime import datetime
 from pathlib import Path
 from typing import Callable, Optional
 
 from okstra_ctl.clarification_items import user_response_sidecars
+from okstra_ctl.manager_paths import MANAGER_CONTEXT_DIRECTIVE_PREFIX
 from okstra_ctl.json_boundary import JsonBoundaryError, load_owned_object, write_owned_object_atomic
 from okstra_ctl.report_language import is_language_tag
 from okstra_ctl.pr_template import PrTemplateError, resolve_pr_template_path
@@ -169,12 +171,29 @@ def _submit_optional_cached_pick(
     )
 
 
+def _directive_context_note(state: WizardState, directive: str) -> str:
+    """manager directive 는 파일을 가리킬 뿐이라, 그 파일이 언제 쓰였는지 보여 준다.
+
+    직전 run 이후 정한 결정은 그 파일에 없다. 날짜가 없으면 사용자는 재사용할
+    directive 가 새 범위를 담는지 판단할 수 없었다(fontsninja dev-11127 re-plan).
+    """
+    if not directive.startswith(MANAGER_CONTEXT_DIRECTIVE_PREFIX):
+        return ""
+    path = Path(directive[len(MANAGER_CONTEXT_DIRECTIVE_PREFIX):].strip()).expanduser()
+    labels = _p(state.workspace_root, "directive_pick")["labels"]
+    if not path.is_file():
+        return labels["context_missing"].format(path=path)
+    written = datetime.fromtimestamp(path.stat().st_mtime).strftime("%Y-%m-%d %H:%M")
+    return labels["context_file"].format(path=path, date=written)
+
+
 _DIRECTIVE_PICK_SPEC = _OptionalCachedPickSpec(
     step=S_DIRECTIVE_PICK, prompt_key="directive_pick",
     recommend_token=_REUSE_LAST_TOKEN, label_key="reuse_last", echo_suffix_key="reuse",
     suggest=_suggest_last_directive, snippet_style="prefix",
     cache_attr="last_directive_cached", target_attr="directive",
     pending_attr="directive_pending_text",
+    recommend_note=_directive_context_note,
 )
 
 

package/runtime/python/okstra_ctl/wizard/steps_roles.py

@@ -63,7 +63,13 @@ def _assignment_model(inputs: dict, worker_id: str, provider: str) -> str:
 
 
 def _build_reuse_previous(state: WizardState) -> Prompt:
-    t = _p(state.workspace_root, "reuse_previous")
+    directive = _latest_run_inputs(
+        state, phase_segment=slugify_task_segment(state.task_type)
+    ).get("directive")
+    t = _p(
+        state.workspace_root, "reuse_previous",
+        directive=directive if isinstance(directive, str) and directive else "(없음)",
+    )
     return Prompt(
         step=S_REUSE_PREVIOUS, kind="pick",
         label=t["label"],

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

@@ -9949,6 +9949,10 @@
         "planStep": {
           "type": "string",
           "minLength": 1
+        },
+        "summary": {
+          "type": "string",
+          "minLength": 1
         }
       }
     },
@@ -10009,6 +10013,13 @@
         },
         "tddEvidence": {
           "type": "string"
+        },
+        "checkId": {
+          "type": "string",
+          "pattern": "^VC-\\d{3,}$"
+        },
+        "advisory": {
+          "type": "boolean"
         }
       }
     },

package/runtime/templates/reports/html/assets/base.css

@@ -12,7 +12,8 @@ body { margin: 0; background: Canvas; color: CanvasText; }
 .report-meta dd { margin: 0; }
 .lede { max-width: 70ch; font-size: clamp(1.05rem, 2vw, 1.35rem); line-height: 1.4; margin: 0 0 1rem; }
 .eyebrow { text-transform: uppercase; letter-spacing: .08em; font-size: .78rem; color: GrayText; }
-main { display: grid; gap: 1rem; padding-bottom: 3rem; }
+/* minmax(0, 1fr): auto 열은 가장 넓은 자식만큼 커져서 긴 토큰 하나가 모든 section 을 넓혔다. */
+main { display: grid; grid-template-columns: minmax(0, 1fr); gap: 1rem; padding-bottom: 3rem; }
 section { padding: 1.4rem; border: 1px solid color-mix(in srgb, CanvasText 14%, transparent); border-radius: 16px; background: color-mix(in srgb, Canvas 94%, CanvasText 6%); }
 h2 { margin-top: 0; font-size: 1.45rem; }
 .report-section-toggle > summary { cursor: pointer; }
@@ -188,4 +189,5 @@ button[data-action="export-user-response"]:hover { background: color-mix(in srgb
 /* A seven-column table needs 42em of floor, more than a phone can give. */
 @media (max-width: 640px) { section { padding: 1rem; } .visualization { display: none; } th, td { min-width: 4.5em; } nav.report-index ol { columns: 1; } }
 @media print { .skip-link, .back-to-top-wrap, script { display: none !important; } body { color: #000; background: #fff; } section { break-inside: avoid; border-color: #bbb; } .visualization-fallback { display: table; } }
-code { font-family: ui-monospace, SFMono-Regular, Menlo, monospace; font-size: .9em; padding: .1em .3em; border-radius: 4px; background: color-mix(in srgb, CanvasText 8%, Canvas); }
+code { font-family: ui-monospace, SFMono-Regular, Menlo, monospace; font-size: .9em; padding: .1em .3em; border-radius: 4px; background: color-mix(in srgb, CanvasText 8%, Canvas); overflow-wrap: anywhere; }
+pre { white-space: pre-wrap; overflow-wrap: anywhere; }

package/runtime/templates/reports/html/base.template.html

@@ -27,14 +27,12 @@
         <thead><tr>
           <th scope="col">{{ t('base.role') }}</th>
           <th scope="col">{{ t('base.execution-label') }}</th>
-          <th scope="col">{{ t('base.status') }}</th>
         </tr></thead>
         <tbody>
           {% for row in executionRoles %}
           <tr>
-            <td>{{ row.role }}</td>
+            <td>{{ row.role | enum_label('executionRole') }}</td>
             <td><code>{{ row.executionLabel }}</code></td>
-            <td>{{ row.status }}</td>
           </tr>
           {% endfor %}
         </tbody>
@@ -45,14 +43,20 @@
   <main id="main-content" data-report-role="human-main">
     {% block human_content %}{% endblock %}
     {% if businessFlow | default([]) %}
+    {% set flow_failed = businessFlow | selectattr('status', 'equalto', 'failed') | list %}
     <section data-report-section="business-flow">
-      <h2>Business Flow Explanations</h2>
-      {% for row in businessFlow %}
-      <p>{{ row.mode }}: {{ row.status }}. {{ row.summary }}</p>
-      <ul>{% for kind, path in row.reports.items() %}<li><a href="{{ path }}">{{ kind }}</a></li>{% endfor %}</ul>
-      {% if row.error %}<p>Explanation error: {{ row.error }}</p>{% endif %}
-      {% if row.id %}<p>Retry: <code>okstra explain-flow rerun --execution {{ row.id }}</code></p>{% endif %}
+      <h2>{{ t('base.business-flow') }}</h2>
+      {% for row in businessFlow if row.status != 'failed' %}
+      <p>{{ row.mode | enum_label('businessFlowMode') }} · {{ row.status | enum_label('businessFlowStatus') }}. {{ row.summary }}</p>
+      {% if row.reports %}<ul>{% for kind, path in row.reports.items() %}<li><a href="{{ path }}">{{ kind }}</a></li>{% endfor %}</ul>{% endif %}
       {% endfor %}
+      {% if flow_failed %}
+      {# 실패 행의 오류·재실행 명령은 운영자용이라 접어 둔다. #}
+      <p>{{ t('base.business-flow-failed-count') | replace('{count}', flow_failed | length) }}</p>
+      <details><summary>{{ t('base.business-flow-failure-details') }}</summary>
+        <ul>{% for row in flow_failed %}<li>{{ row.mode | enum_label('businessFlowMode') }}{% if row.error %} · {{ t('base.business-flow-error') }} {{ row.error }}{% endif %}{% if row.id %} · {{ t('base.business-flow-rerun') }} <code>okstra explain-flow rerun --execution {{ row.id }}</code>{% endif %}</li>{% endfor %}</ul>
+      </details>
+      {% endif %}
     </section>
     {% endif %}
     {% if endStates %}
@@ -146,6 +150,7 @@
           <tr><th scope="row">{{ t('runUsage.row-workers') }}</th><td class="figure">{{ runUsage.worker.rawTokens }}</td><td class="figure">{{ runUsage.worker.cacheReadTokens }}</td><td class="figure">{{ runUsage.worker.billableTokens }}</td><td class="figure">{{ runUsage.worker.cost }}</td><td class="figure"></td></tr>
           <tr class="grand-total"><th scope="row">{{ t('runUsage.row-total') }}</th><td class="figure">{{ runUsage.grand.rawTokens }}</td><td class="figure">{{ runUsage.grand.cacheReadTokens }}</td><td class="figure">{{ runUsage.grand.billableTokens }}</td><td class="figure">{{ runUsage.grand.cost }}</td><td class="figure"></td></tr>
           {% if runUsage.cliCost %}<tr><th scope="row">{{ t('runUsage.row-cli') }}</th><td class="figure"></td><td class="figure"></td><td class="figure"></td><td class="figure">{{ runUsage.cliCost }}</td><td class="figure"></td></tr>{% endif %}
+          {% if runUsage.grandWithCli %}<tr class="grand-total"><th scope="row">{{ t('runUsage.row-total-with-cli') }}</th><td class="figure"></td><td class="figure"></td><td class="figure"></td><td class="figure">{{ runUsage.grandWithCli }}</td><td class="figure"></td></tr>{% endif %}
           {% if runUsage.taskCumulative %}<tr class="task-cumulative"><th scope="row">{{ t('runUsage.row-task-cumulative') | replace('{runs}', runUsage.taskCumulative.runCount) }}</th><td class="figure">{{ runUsage.taskCumulative.rawTokens }}</td><td class="figure">{{ runUsage.taskCumulative.cacheReadTokens }}</td><td class="figure">{{ runUsage.taskCumulative.billableTokens }}</td><td class="figure">{{ runUsage.taskCumulative.cost }}</td><td class="figure"></td></tr>{% endif %}
         </tfoot>
       </table>

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

@@ -147,6 +147,74 @@
       "deferred": "Deferred",
       "not-applicable": "Not applicable",
       "blocked": "Blocked"
+    },
+    "clarificationKind": {
+      "material": "Missing information",
+      "decision": "Your decision",
+      "data-point": "A fact to confirm"
+    },
+    "clarificationStatus": {
+      "open": "Open",
+      "answered": "Answered",
+      "resolved": "Resolved",
+      "obsolete": "No longer relevant"
+    },
+    "approvalDisposition": {
+      "select": "Choose this option",
+      "accept-risk": "Accept the risk",
+      "request-revision": "Request a revision",
+      "reject": "Reject"
+    },
+    "approvalClassification": {
+      "user-decision": "Needs your decision",
+      "noncritical-dissent": "Non-critical disagreement",
+      "correctness-critical": "Affects correctness"
+    },
+    "clarificationScope": {
+      "in-repo": "This repository only",
+      "cross-repo": "Other repositories too",
+      "new-schema": "New schema",
+      "deferrable": "Can be deferred"
+    },
+    "executionRole": {
+      "leader": "Lead",
+      "analyser": "Analyser",
+      "critic": "Critic",
+      "designer": "Designer",
+      "implementer": "Implementer",
+      "planner": "Planner",
+      "report-writer": "Report writer",
+      "translator": "Translator",
+      "verifier": "Verifier"
+    },
+    "requirementStatus": {
+      "covered": "Covered",
+      "gap": "Not covered",
+      "documented-deviation": "Approved deviation",
+      "blocked": "Blocked"
+    },
+    "rollbackCategory": {
+      "Pure code": "Code only",
+      "Feature-flag-gated": "Behind a feature flag",
+      "Schema/config/stateful": "Schema, config or stored state"
+    },
+    "rollbackResult": {
+      "ok": "Passed",
+      "not-applicable": "Not applicable",
+      "advisory — human-run": "Advisory: a person runs it"
+    },
+    "businessFlowMode": {
+      "pre": "Before the change",
+      "contribute": "This phase's contribution",
+      "post": "After the change",
+      "unknown": "Unknown phase"
+    },
+    "businessFlowStatus": {
+      "prepared": "Prepared",
+      "running": "Running",
+      "failed": "Failed",
+      "partial": "Partly explained",
+      "complete": "Explained"
     }
   },
   "enumHint": {
@@ -194,7 +262,12 @@
     "agent-activity": "Agent activity",
     "agent-activity-intro": "What each agent was asked to do in this run and how it ended. Decision cards and prose cite these rows by id.",
     "agent": "Agent",
-    "activity": "Activity"
+    "activity": "Activity",
+    "business-flow": "Business flow explanations",
+    "business-flow-failed-count": "{count} business flow explanations failed",
+    "business-flow-failure-details": "Failure details and rerun commands",
+    "business-flow-error": "Error:",
+    "business-flow-rerun": "Rerun:"
   },
   "runUsage": {
     "heading": "What this run cost",
@@ -214,7 +287,8 @@
     "row-total": "Total",
     "row-cli": "CLI calls (billed separately)",
     "cache-read-tokens": "Cache re-reads",
-    "row-task-cumulative": "This task so far ({runs} runs)"
+    "row-task-cumulative": "This task so far ({runs} runs)",
+    "row-total-with-cli": "Total including CLI calls"
   },
   "macros": {
     "forms": {
@@ -585,6 +659,21 @@
       "result": "Result",
       "no-rollback-check-was-recorded": "No rollback check was recorded.",
       "stage-carry-over": "Stage carry-over",
+      "carry-sidecar": "Sidecar",
+      "carry-commit-range": "Commit range",
+      "carry-steps": "Steps",
+      "carry-files-changed": "Files changed",
+      "carry-raw": "Sidecar JSON as written",
+      "file": "File",
+      "change": "Change",
+      "lines": "Lines",
+      "plan-step": "Plan step",
+      "action-created": "Created",
+      "action-modified": "Modified",
+      "action-deleted": "Deleted",
+      "what-it-does": "What it does",
+      "advisory": "advisory",
+      "entry-count": "{count} entries",
       "manual-user-test": "Manual user test",
       "environment": "Environment:",
       "expected": "Expected:",

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

@@ -147,6 +147,74 @@
       "deferred": "보류",
       "not-applicable": "해당 없음",
       "blocked": "차단"
+    },
+    "clarificationKind": {
+      "material": "빠진 정보",
+      "decision": "결정 필요",
+      "data-point": "확인할 사실"
+    },
+    "clarificationStatus": {
+      "open": "답변 대기",
+      "answered": "답변함",
+      "resolved": "해결됨",
+      "obsolete": "더 이상 해당 없음"
+    },
+    "approvalDisposition": {
+      "select": "이 선택지 채택",
+      "accept-risk": "위험 감수",
+      "request-revision": "수정 요청",
+      "reject": "반려"
+    },
+    "approvalClassification": {
+      "user-decision": "사용자 결정 필요",
+      "noncritical-dissent": "치명적이지 않은 이견",
+      "correctness-critical": "정확성에 영향"
+    },
+    "clarificationScope": {
+      "in-repo": "이 저장소 안",
+      "cross-repo": "다른 저장소까지",
+      "new-schema": "새 스키마",
+      "deferrable": "미룰 수 있음"
+    },
+    "executionRole": {
+      "leader": "리드",
+      "analyser": "분석",
+      "critic": "비평",
+      "designer": "설계",
+      "implementer": "구현",
+      "planner": "계획",
+      "report-writer": "리포트 작성",
+      "translator": "번역",
+      "verifier": "검증"
+    },
+    "requirementStatus": {
+      "covered": "충족",
+      "gap": "미충족",
+      "documented-deviation": "승인된 이탈",
+      "blocked": "차단"
+    },
+    "rollbackCategory": {
+      "Pure code": "코드만",
+      "Feature-flag-gated": "기능 플래그로 제어",
+      "Schema/config/stateful": "스키마·설정·저장 상태"
+    },
+    "rollbackResult": {
+      "ok": "통과",
+      "not-applicable": "해당 없음",
+      "advisory — human-run": "권고: 사람이 직접 실행"
+    },
+    "businessFlowMode": {
+      "pre": "변경 전",
+      "contribute": "이번 단계 기여",
+      "post": "변경 후",
+      "unknown": "알 수 없는 단계"
+    },
+    "businessFlowStatus": {
+      "prepared": "준비됨",
+      "running": "실행 중",
+      "failed": "실패",
+      "partial": "일부 설명",
+      "complete": "설명 완료"
     }
   },
   "enumHint": {
@@ -194,7 +262,12 @@
     "agent-activity": "에이전트 활동",
     "agent-activity-intro": "이번 run 에서 각 에이전트가 맡은 일과 그 결과입니다. 결정 카드와 본문이 이 행을 아이디로 인용합니다.",
     "agent": "에이전트",
-    "activity": "활동"
+    "activity": "활동",
+    "business-flow": "업무 흐름 설명",
+    "business-flow-failed-count": "업무 흐름 설명 생성 실패 {count}건",
+    "business-flow-failure-details": "실패 내역과 재실행 명령",
+    "business-flow-error": "오류:",
+    "business-flow-rerun": "재실행:"
   },
   "runUsage": {
     "heading": "이번 실행에 든 비용",
@@ -214,7 +287,8 @@
     "row-total": "합계",
     "row-cli": "CLI 호출 (별도 청구)",
     "cache-read-tokens": "캐시 재읽기",
-    "row-task-cumulative": "이 태스크 누적 (run {runs}회)"
+    "row-task-cumulative": "이 태스크 누적 (run {runs}회)",
+    "row-total-with-cli": "CLI 호출 포함 합계"
   },
   "macros": {
     "forms": {
@@ -585,6 +659,21 @@
       "result": "결과",
       "no-rollback-check-was-recorded": "롤백 확인 기록이 없습니다.",
       "stage-carry-over": "stage 인계",
+      "carry-sidecar": "인계 파일",
+      "carry-commit-range": "commit 범위",
+      "carry-steps": "단계",
+      "carry-files-changed": "바뀐 파일 수",
+      "carry-raw": "인계 JSON 원문",
+      "file": "파일",
+      "change": "변경",
+      "lines": "줄 수",
+      "plan-step": "계획 단계",
+      "action-created": "추가",
+      "action-modified": "수정",
+      "action-deleted": "삭제",
+      "what-it-does": "하는 일",
+      "advisory": "권고",
+      "entry-count": "{count}개 항목",
       "manual-user-test": "수동 사용자 테스트",
       "environment": "환경:",
       "expected": "기대 결과:",

package/runtime/templates/reports/html/macros/forms.html

@@ -57,18 +57,18 @@
 {%- endmacro %}
 
 {% macro clarification_article(row, compact=false) -%}
-{% set is_closed = row.status in ['resolved', 'obsolete'] %}
+{% set is_closed = compact or row.status in ['resolved', 'obsolete'] %}
 {% set approval_context = row.approvalContext | default(None) %}
 {% set resolution = row.resolution | default(None) %}
 {% set options = row.options | default([]) %}
 <article class="clarification-item{% if compact %} is-closed{% endif %}" id="id-{{ row.id }}" data-response-id="{{ row.id }}" data-kind="{{ row.kind }}" data-status="{{ row.status }}">
-  {% if compact %}<details><summary>{{ row.id | inline_code }} · {{ row.status }}</summary>{% endif %}
-  <p class="eyebrow">{{ row.id | inline_code }} · {{ row.kind }}</p>
+  {% if compact %}<details><summary>{{ row.id | inline_code }} · {{ row.status | enum_label('clarificationStatus') }}</summary>{% endif %}
+  <p class="eyebrow">{{ row.id | inline_code }} · {{ row.kind | enum_label('clarificationKind') }}</p>
   {{ row.statement | paragraphs }}
   <dl class="clarification-expected"><dt>{{ t('macros.forms.answer-as') }}</dt><dd>{{ row.expectedForm | inline_code }}</dd></dl>
   {% if approval_context %}
   <div class="approval-context" data-approval-classification="{{ approval_context.classification }}">
-    <p class="eyebrow">{{ approval_context.classification }}</p>
+    <p class="eyebrow">{{ approval_context.classification | enum_label('approvalClassification') }}</p>
     <p><strong>{{ t('tasks.implementation-planning.unblock-condition') }}</strong> {{ approval_context.unblockCondition | inline_code }}</p>
     {% set check_refs = resolution.checkRefs if resolution else approval_context.activityIds | default([]) %}
     {% if check_refs %}<p><strong>{{ t('tasks.implementation-planning.agent-evidence') }}</strong>
@@ -81,10 +81,10 @@
     {% for option in options %}
     <li class="clarification-option{% if option.role == 'recommended' %} is-recommended{% endif %}" data-option-value="{{ option.answer }}">
       <p class="clarification-option-answer">{{ option.answer | inline_code }}{% if option.role == 'recommended' %} <span class="badge">{{ t('macros.forms.recommended') }}</span>{% endif %}</p>
-      {% if option.disposition | default(None) %}<p class="clarification-option-disposition"><code>{{ option.disposition }}</code></p>{% endif %}
+      {% if option.disposition | default(None) %}<p class="clarification-option-disposition">{{ option.disposition | enum_label('approvalDisposition') }}</p>{% endif %}
       <p class="clarification-option-rationale">{{ option.rationale | inline_code }}</p>
       <dl class="clarification-option-impact">
-        <dt>{{ t('macros.forms.scope-impact') }}</dt><dd>{% if option.reach | default(None) %}{{ option.reach }}{% if option.scopeEffects | default([]) %}, {{ option.scopeEffects | join(', ') }}{% endif %}{% else %}{{ option.scopeImpact | join(', ') }}{% endif %}</dd>
+        <dt>{{ t('macros.forms.scope-impact') }}</dt><dd>{% if option.reach | default(None) %}{{ option.reach | enum_label('clarificationScope') }}{% if option.scopeEffects | default([]) %}, {{ option.scopeEffects | map('enum_label', 'clarificationScope') | join(', ') }}{% endif %}{% else %}{{ option.scopeImpact | map('enum_label', 'clarificationScope') | join(', ') }}{% endif %}</dd>
         <dt>{{ t('macros.forms.added-work') }}</dt><dd>{{ option.addedWork | inline_code }}</dd>
         <dt>{{ t('macros.forms.direction-change') }}</dt><dd>{{ option.directionChange | inline_code }}</dd>
       </dl>
@@ -114,7 +114,8 @@
 {% if items %}
 {% set ns = namespace(open=[], closed=[]) %}
 {% for row in items %}
-  {% if row.status in ['open', 'answered'] %}
+  {# 답이 실린 answered 행은 기다리는 질문이 아니다 — 닫힌 목록으로 간다. #}
+  {% if row.status == 'open' or (row.status == 'answered' and not row.userInput | default('')) %}
     {% set ns.open = ns.open + [row] %}
   {% else %}
     {% set ns.closed = ns.closed + [row] %}