okstra 0.209.6 → 0.211.0

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

@@ -132,6 +132,16 @@ def close_stage(
             f"stage {stage} is not in this task's Stage Map (has {known or 'none'})",
             stage="stage-map",
         )
+    if any(
+        isinstance(row, dict) and row.get("stage_number") == stage
+        and row.get("cancelled")
+        for row in stage_map.stages
+    ):
+        raise StateError(
+            f"stage {stage} is cancelled in this task's latest plan — a cancelled "
+            "stage is never done; close the stage that replaces it instead",
+            stage="stage-map",
+        )
 
     recorded = last_lifecycle_status_by_stage(read_consumers(plan_run_root))
     if recorded.get(stage) in _SETTLED:
@@ -183,8 +193,9 @@ _CLI_EPILOG = r"""Usage:
 Records the `done` 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). 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.
+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.
 
 Output: JSON { ok, taskKey, taskRoot, stage, headCommit, conformance,
 consumersPath }. Exit 1 on a refusal (the reason names what to do), 2 when

package/runtime/python/okstra_ctl/stage_map.py

@@ -41,6 +41,7 @@ class StageMapStage:
     depends_on: tuple[int, ...]
     step_count: int
     exit_contract_summary: str
+    cancelled: bool = False
 
 
 @dataclass(frozen=True)
@@ -356,9 +357,27 @@ def _parse_data_stage_map_row(
         parse_stage_dependencies(depends_on, row_number, source_plan_path),
         step_count,
         exit_summary,
+        stage_row_is_cancelled(value, row_number, source_plan_path),
     )
 
 
+STAGE_STATUSES = ("active", "cancelled")
+
+
+def stage_row_is_cancelled(
+    value: dict[str, Any], row_number: int, source_plan_path: str = "",
+) -> bool:
+    """구조화 Stage Map 행의 `status`. 없으면 active 다."""
+    status = value.get("status", "active")
+    if status not in STAGE_STATUSES:
+        raise StageMapError(
+            "stage_map",
+            f"structured Stage Map row {row_number} has invalid status {status!r}",
+            source_plan_path,
+        )
+    return status == "cancelled"
+
+
 def _parse_schema_v2_stage_map(
     data: dict[str, Any], source_plan_path: str,
 ) -> list[StageMapStage]:
@@ -493,11 +512,17 @@ def stage_map_records(stages: Iterable[StageMapStage]) -> list[dict[str, Any]]:
             "depends_on": list(stage.depends_on),
             "step_count": stage.step_count,
             "exit_contract_summary": stage.exit_contract_summary,
+            "cancelled": stage.cancelled,
         }
         for stage in stages
     ]
 
 
+def active_stage_records(records: Iterable[dict[str, Any]]) -> list[dict[str, Any]]:
+    """취소되지 않은 stage 기록 — 통합·whole-task 게이트·handoff 가 순회하는 집합."""
+    return [record for record in records if not record.get("cancelled")]
+
+
 def _latest_plan_report(task_root: Path) -> Path | None:
     reports_dir = RunRef.from_task_root(
         task_root, "implementation-planning"

package/runtime/python/okstra_ctl/stage_map_cli.py

@@ -30,8 +30,9 @@ _CLI_EPILOG = r"""Usage:
 
 Output: default and --json emit JSON { ok, taskKey, taskRoot, state, sourcePlanPath,
 stages:[…], doneStages:[int], planning:{…} }; --text emits fixed count/name/value fields.
-Each stage row carries stage_number, title, depends_on, step_count and exit_contract_summary; a
-schema-v2 report adds that stage's sliceValue, acceptance and exitContract.
+Each stage row carries stage_number, title, depends_on, step_count, exit_contract_summary and
+cancelled (true for a row the plan marks `status: cancelled`); a schema-v2 report adds that
+stage's sliceValue, acceptance and exitContract.
 planning carries the report's task-level rows — rollbackStrategy, validationChecklist,
 crossProjectDependencies, dependencyMigrationRisk, recommendedOption — so a consumer renders the
 plan instead of re-summarising the report body. Both are absent for a schema-v1 report.

package/runtime/python/okstra_ctl/stage_targets.py

@@ -53,10 +53,12 @@ class StageLifecycle:
     step_count: int
     deps_satisfied: bool
     blocked_by: list[int]
+    cancelled: bool = False
 
     @property
     def status(self) -> str:
-        """Lifecycle state, in precedence order: done > active > ready > blocked.
+        """Lifecycle state, in precedence order:
+        done > cancelled > active > ready > blocked.
 
         ``started`` and ``reserved`` collapse into ``active`` because every
         caller that distinguishes them already words the two the same way (see
@@ -64,6 +66,8 @@ class StageLifecycle:
         """
         if self.done:
             return "done"
+        if self.cancelled:
+            return "cancelled"
         if self.started or self.reserved:
             return "active"
         return "ready" if self.deps_satisfied else "blocked"
@@ -171,6 +175,11 @@ class StageLifecycleSnapshot:
             raise StageTargetError(
                 f"--stage {n} already completed (consumers.jsonl status:done exists)"
             )
+        if lifecycle.status == "cancelled":
+            raise StageTargetError(
+                f"--stage {n} is cancelled in the approved plan's Stage Map; "
+                "it is never executed — run the stage that replaces it"
+            )
         if lifecycle.status == "active":
             # Wording is load-bearing: okstra-run's unattended chain matches it
             # to terminate normally instead of raising an exception gate.
@@ -183,8 +192,8 @@ class StageLifecycleSnapshot:
         blocked = [lc for lc in self.lifecycles if lc.status == "blocked"]
         if not blocked:
             return (
-                "no stage is ready: every stage is done or occupied by "
-                "another run"
+                "no stage is ready: every stage is done, cancelled, or "
+                "occupied by another run"
             )
         detail = "; ".join(
             f"stage {lc.stage} blocked by "
@@ -203,6 +212,7 @@ class StageLifecycleSnapshot:
         return [
             lifecycle.handoff_eligibility_record()
             for lifecycle in self.lifecycles
+            if lifecycle.status != "cancelled"
         ]
 
 
@@ -242,6 +252,7 @@ def stage_lifecycle_snapshot_from_state(
             pr_covered=stage_number in consumer_state.pr_covered_stages,
             head_commit=str(done_row.get("head_commit") or ""),
             report_path=str(done_row.get("report_path") or ""),
+            cancelled=bool(stage.get("cancelled")),
         ))
     return StageLifecycleSnapshot(
         stage_map=stage_map,
@@ -710,8 +721,11 @@ def _resolve_and_integrate_whole_task_unlocked(
     """Integrate and resolve a whole-task target while the caller owns the lock."""
     from .consumers import latest_done_by_stage
     from .stage_integrate import IntegrateError, integrate_stages
+    from .stage_map import active_stage_records
     from .worktree import _git, is_dirty_excluding_okstra
 
+    stage_map = active_stage_records(stage_map)
+
     # 끝나지 않은 stage 가 있으면 _resolve_whole_task_target 이 어차피 거부한다.
     # 그 전에 끝난 stage 를 머지해 두면 거부된 요청이 task worktree 에 머지를
     # 남긴다(되돌리지 않는다). 머지하기 전에 같은 조건으로 거부한다.

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

@@ -231,7 +231,8 @@ def _stage_lifecycle_snapshot(
     return read_stage_lifecycle_snapshot(
         [{"stage_number": s.stage_number,
           "depends_on": list(s.depends_on),
-          "step_count": s.step_count} for s in stages],
+          "step_count": s.step_count,
+          "cancelled": s.cancelled} for s in stages],
         Path(state.approved_plan_path).resolve().parents[1],
         recover_from_carry=False,
         reserved_stages=reserved_stages,

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_plan.py

@@ -249,7 +249,9 @@ def _whole_task_allowed(
     if done is None:
         done = _stage_lifecycle_snapshot(state, stages).done_stages
     return whole_task_verification_allowed(
-        stage_numbers=tuple(stage.stage_number for stage in stages),
+        stage_numbers=tuple(
+            stage.stage_number for stage in stages if not stage.cancelled
+        ),
         done_stages=done,
     )
 
@@ -468,7 +470,7 @@ def _submit_impl_stage_pick(state: WizardState, answer: str) -> Optional[str]:
         state, stages, reserved_stages=_reserved_stage_numbers(state))
     done = snapshot.done_stages
     occupied = {lc.stage for lc in snapshot.lifecycles
-                if lc.status in ("done", "active")}
+                if lc.status in ("done", "active", "cancelled")}
     chosen = _impl_chosen_stages(t, picks, answer, all_nums, occupied)
     ordered = order_stage_closure(
         [(s.stage_number, s.depends_on) for s in stages], chosen, done)

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

@@ -8158,6 +8158,13 @@
         "exitContractSummary": {
           "type": "string",
           "minLength": 1
+        },
+        "status": {
+          "enum": [
+            "active",
+            "cancelled"
+          ],
+          "description": "Absent means active. A cancelled stage keeps its row and number so the Stage Map still runs 1..N; execution, gates and handoff skip it. Only a stage that has not started may be cancelled."
         }
       }
     },
@@ -9942,6 +9949,10 @@
         "planStep": {
           "type": "string",
           "minLength": 1
+        },
+        "summary": {
+          "type": "string",
+          "minLength": 1
         }
       }
     },
@@ -10002,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>