okstra 0.210.0 → 0.212.0

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/python/okstra_ctl/worktree_lock_cli.py

@@ -0,0 +1,87 @@
+"""`okstra worktree-lock` — 선언된 검증 명령을 worktree 단위 배타 락 안에서 실행한다."""
+from __future__ import annotations
+
+import argparse
+import contextlib
+import os
+import subprocess
+import sys
+from pathlib import Path
+
+from okstra_project.dirs import okstra_home
+
+from .locks import worktree_exec_lock
+
+_CLI_EPILOG = r"""Every verifier of a stage runs in the same worktree at the same time, and each
+re-runs the plan's Tier 1 commands itself. A command that starts a server on a
+fixed port (a dev server on 3000, a fixture API on 8899) then collides with the
+same command from another verifier. This launcher runs the command unchanged,
+one invocation at a time per worktree:
+
+  okstra worktree-lock --worktree <target.cwd> --command '<target.command>'
+
+The command runs through $SHELL -c (or /bin/sh) with the worktree as its
+working directory. Its stdout and stderr pass through untouched and its exit
+code is this command's exit code; lock notices go to stderr only.
+
+The lock file is <okstra home>/.locks/worktree-exec/<hash of the worktree
+realpath>.lock, outside the worktree and the project's .okstra tree. When it
+cannot be created or locked, the command still runs, unlocked, after a warning
+on stderr.
+"""
+
+
+def _shell() -> str:
+    return os.environ.get("SHELL", "") or "/bin/sh"
+
+
+def _announce_wait(lockfile: Path) -> None:
+    sys.stderr.write(
+        f"okstra worktree-lock: another command holds {lockfile}; waiting\n"
+    )
+    sys.stderr.flush()
+
+
+def _run(command: str, worktree: Path) -> int:
+    code = subprocess.run([_shell(), "-c", command], cwd=worktree, check=False).returncode
+    # 시그널로 죽은 자식은 음수를 준다. 셸이 보고하는 128+N 으로 맞춘다.
+    return 128 - code if code < 0 else code
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = argparse.ArgumentParser(
+        prog="okstra worktree-lock",
+        description="Run one declared shell command in a worktree under that worktree's exclusive lock.",
+        epilog=_CLI_EPILOG,
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+    )
+    parser.add_argument(
+        "--worktree", type=Path, required=True,
+        help="worktree the command runs in; also the lock key (resolved to its realpath)",
+    )
+    parser.add_argument(
+        "--command", required=True,
+        help="the declared command, run verbatim through the shell",
+    )
+    args = parser.parse_args(argv)
+    worktree = args.worktree.resolve()
+    if not worktree.is_dir():
+        sys.stderr.write(f"okstra worktree-lock: not a directory: {worktree}\n")
+        return 2
+    with contextlib.ExitStack() as stack:
+        try:
+            stack.enter_context(
+                worktree_exec_lock(okstra_home(), worktree, on_wait=_announce_wait)
+            )
+        except OSError as exc:
+            # 잠그지 못해도 검증자의 재실행 자체를 막지 않는다. 동시 실행의 위험은
+            # 락 도입 전과 같고, 그 사실을 stderr 에 남긴다.
+            sys.stderr.write(
+                f"okstra worktree-lock: warning: cannot take the lock ({exc}); running unlocked\n"
+            )
+            sys.stderr.flush()
+        return _run(args.command, worktree)
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

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:",