okstra 0.158.1 → 0.159.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "okstra",
-  "version": "0.158.1",
+  "version": "0.159.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.158.1",
-  "builtAt": "2026-08-07T11:17:24.955Z",
+  "package": "0.159.0",
+  "builtAt": "2026-08-07T17:07:46.245Z",
   "repoRoot": "/home/runner/work/okstra/okstra"
 }

package/runtime/agents/workers/report-writer-worker.md

@@ -102,7 +102,7 @@ Rules (the schema enforces most of these — they are listed here so you know *w
 - Read the exact permitted header values from the task bundle schema excerpt. In the current v2 contract, `header.reportOwner` is `"Okstra lead"` and `header.reportAuthor` is `"Report writer worker"`. Set author to `"Okstra lead"` only for `release-handoff` runs (single-lead by design) or a recorded report-writer dispatch failure fallback. A legacy v1 excerpt may retain its historical compatibility values; follow that excerpt rather than inferring ownership from the provider.
 - **Source items (worker:item) preservation.** Every `consensus[].sourceItems`, `differences[].workersPosition[].itemId`, and `evidence.primary[].sourceItems` entry MUST carry the worker:item-id pair (e.g. `claude:F-001`, `codex:1.1`, `antigravity:F-3`, or `lead:mcp-1` for lead-only evidence). The schema enforces this via the `SourceItem` regex; bare worker-name lists no longer parse.
 - **Verdict Card consistency.** `verdictCard.verdictToken` and `verdictCard.direction` MUST byte-match `finalVerdict.verdictToken` / `.direction`; `validators/validate-run.py` diffs both and fails the run on divergence. `verdictCard.nextStep` names the same action as `finalVerdict.nextStep` and `recommendedNextSteps[0].text` but is written as the actionable command the reader runs (e.g. `/okstra-run task-key=… task-type=release-handoff`) where the other two are prose — it is deliberately not a byte copy. Duplicating the compared values across `verdictCard` and `finalVerdict` is intentional so the validator can diff them.
-- **Error-analysis diagnosis and routing.** When `header.taskType` is `error-analysis`, populate the required `errorAnalysis` object. Copy `errorAnalysis.symptomVerbatim` byte-for-byte from the symptom stated in the brief's `Source Material`; do not paraphrase it. Every `causeCandidates[]` row includes the full `supportingEvidence`, `falsifyingEvidenceChecked`, `confidence`, and `disproveWith` fields. Route `errorAnalysis.routing.nextTaskType=implementation-planning` with `direction=begin-planning`, or route `errorAnalysis.routing.nextTaskType=error-analysis` with `direction=continue-investigation`; no other pairing is valid. `verdictCard.nextStep`, `finalVerdict.nextStep`, the first `recommendedNextSteps` action and command, and the unique `followUpTasks` row whose `origin` is `phase-continuation` MUST all point to the same `errorAnalysis.routing.nextTaskType` target. The schema enforces only the presence of a `phase-continuation` row. Phase validation MUST enforce exact target agreement and uniqueness through `validators/validate-run.py::_validate_error_analysis_consistency`; until that check is implemented and executed, those semantics are contract requirements rather than enforced guarantees.
+- **Error-analysis diagnosis and routing.** When `header.taskType` is `error-analysis`, populate the required `errorAnalysis` object. Copy `errorAnalysis.symptomVerbatim` byte-for-byte from the symptom stated in the brief's `Source Material`; do not paraphrase it. Every `causeCandidates[]` row includes the full `supportingEvidence`, `falsifyingEvidenceChecked`, `confidence`, and `disproveWith` fields. When a candidate is a step in a propagation chain rather than a competing explanation — the analysis calls it a downstream step, a second stage, or a consequence of another candidate — set its `downstreamOf` to the ids of the candidates immediately upstream of it; leave the field absent for a candidate that stands on its own. Every id listed MUST be another candidate in the same report, no row may name itself, and the links MUST NOT form a cycle; `validators/validate-run.py::_validate_cause_chain` rejects all three. This is the only place the chain is machine-readable — prose calling a candidate "the second step of the chain" while `downstreamOf` is absent leaves the report's figure claiming the candidates are alternatives. Route `errorAnalysis.routing.nextTaskType=implementation-planning` with `direction=begin-planning`, or route `errorAnalysis.routing.nextTaskType=error-analysis` with `direction=continue-investigation`; no other pairing is valid. `verdictCard.nextStep`, `finalVerdict.nextStep`, the first `recommendedNextSteps` action and command, and the unique `followUpTasks` row whose `origin` is `phase-continuation` MUST all point to the same `errorAnalysis.routing.nextTaskType` target. The schema enforces only the presence of a `phase-continuation` row. Phase validation MUST enforce exact target agreement and uniqueness through `validators/validate-run.py::_validate_error_analysis_consistency`; until that check is implemented and executed, those semantics are contract requirements rather than enforced guarantees.
 - **Human narrative.** Populate required `humanSummary` and the selected task block's `userNarrative`. Human-visible analysis facts must not exist only in Markdown; HTML is derived independently and can use only data.json. Keep worker discussion and audit details in `crossVerification`, `executionStatus`, and `tokenUsage`, outside the human narrative fields.
 - **External QA advisory.** A Tier 3 entry requiring `db`, `http`, or
   `external` may be non-PASS without changing approval or final verdict. Render

package/runtime/prompts/lead/report-writer.md

@@ -330,7 +330,7 @@ Every field MUST anchor its claim with at least one evidence reference — a `pa
 0. **Clarification Response Carried In** — render this `## 0.` heading ONLY when `{{CLARIFICATION_RESPONSE_RELATIVE_PATH}}` is non-empty. Walk every `C-*` row of the prior report's `## 1. Clarification Items` table, reconcile against new evidence, and record the outcome (`resolved` / `obsolete`) with citation before drafting the verdict. When no carry-in path was provided, OMIT the `## 0.` heading entirely — the validator fails an empty Section 0 stub. The lead calls `okstra incremental-scope` exactly once, combining answered-clarification stage impacts (`--impacted`) and changed PREP IDs (`--prep-items`); selected-option, Stage Map, or recommended-approach changes pass both CSVs empty to force full mode. Record that single decision JSON verbatim into `implementationPlanning.incrementalDecision` (`mode`, `reverifyStages`, `carryStages`, `reason`); the renderer emits the `### 0.1 Incremental Re-Verification Scope` audit block from it, and the validator fails an `incremental`-mode run whose Section 0 omits that block. In `incremental` mode this run's `planItems` MUST carry every plan-item id from the re-verified stages forward with its updated verdict; if re-verification concludes a plan item should be REMOVED, that is a signal the answer's blast radius is not local — do not drop it here, tell the lead to abandon incremental and re-route to a FULL re-verification, because the carry merge only adds prior items and would resurrect the removed item's stale verdict. After authoring the current data.json, call `okstra incremental-carry`, passing the decision's `carryStages` CSV to `--carry-stages` and its `reverifyStages` CSV to `--reverify-stages`. A `CarryError` means the stage/PREP ownership contract is unsafe: discard the partial merged output and route the run through full re-verification; never publish a partially merged report.
 1. **Clarification Items** — single unified `C-*` table; column schema (4 columns with the short fields stacked in one record-meta cell), ID convention, and rerun behaviour are owned by `_common-contract.md §Clarification request policy` (SSOT). The deprecated `5.5.9 Open Questions` / `1.1 Additional Material Request` / `1.2 User Confirmation Questions` sub-sections are removed; the validator fails reports that reintroduce them.
 2. **Evidence and Detailed Analysis** — primary evidence rows (file path, line, snippet); secondary evidence / alternate interpretations. If `reference-expectations.md` lists explicit expected values, record match/gap per row.
-   - **Error-analysis diagnosis and routing.** When `header.taskType` is `error-analysis`, populate the required `errorAnalysis` object. Copy `errorAnalysis.symptomVerbatim` byte-for-byte from the symptom stated in the brief's `Source Material`; do not paraphrase it. Every `causeCandidates[]` row includes the full `supportingEvidence`, `falsifyingEvidenceChecked`, `confidence`, and `disproveWith` fields. Route `errorAnalysis.routing.nextTaskType=implementation-planning` with `direction=begin-planning`, or route `errorAnalysis.routing.nextTaskType=error-analysis` with `direction=continue-investigation`; no other pairing is valid. `verdictCard.nextStep`, `finalVerdict.nextStep`, the first `recommendedNextSteps` action and command, and the unique `followUpTasks` row whose `origin` is `phase-continuation` MUST all point to the same `errorAnalysis.routing.nextTaskType` target. The schema enforces only the presence of a `phase-continuation` row. Phase validation MUST enforce exact target agreement and uniqueness through `validators/validate-run.py::_validate_error_analysis_consistency`; until that check is implemented and executed, those semantics are contract requirements rather than enforced guarantees.
+   - **Error-analysis diagnosis and routing.** When `header.taskType` is `error-analysis`, populate the required `errorAnalysis` object. Copy `errorAnalysis.symptomVerbatim` byte-for-byte from the symptom stated in the brief's `Source Material`; do not paraphrase it. Every `causeCandidates[]` row includes the full `supportingEvidence`, `falsifyingEvidenceChecked`, `confidence`, and `disproveWith` fields. When a candidate is a step in a propagation chain rather than a competing explanation — the analysis calls it a downstream step, a second stage, or a consequence of another candidate — set its `downstreamOf` to the ids of the candidates immediately upstream of it; leave the field absent for a candidate that stands on its own. Every id listed MUST be another candidate in the same report, no row may name itself, and the links MUST NOT form a cycle; `validators/validate-run.py::_validate_cause_chain` rejects all three. This is the only place the chain is machine-readable — prose calling a candidate "the second step of the chain" while `downstreamOf` is absent leaves the report's figure claiming the candidates are alternatives. Route `errorAnalysis.routing.nextTaskType=implementation-planning` with `direction=begin-planning`, or route `errorAnalysis.routing.nextTaskType=error-analysis` with `direction=continue-investigation`; no other pairing is valid. `verdictCard.nextStep`, `finalVerdict.nextStep`, the first `recommendedNextSteps` action and command, and the unique `followUpTasks` row whose `origin` is `phase-continuation` MUST all point to the same `errorAnalysis.routing.nextTaskType` target. The schema enforces only the presence of a `phase-continuation` row. Phase validation MUST enforce exact target agreement and uniqueness through `validators/validate-run.py::_validate_error_analysis_consistency`; until that check is implemented and executed, those semantics are contract requirements rather than enforced guarantees.
 3. **Recommended Next Steps** — prioritized actions. After Phase 7's follow-up spawner runs, append a row per newly created task-key (see "Phase 6 → Phase 7 execution sequence" above). **Approval-gate consistency:** when §1 carries any `Blocks: approval` row with `Status` ∈ {open, answered}, the Verdict Card `Next Step` and the first recommended step MUST point to the clarification rerun (`resume-clarification` of the SAME task-type) — never to "flip frontmatter `approved: true` → jump straight to `implementation`". Run-prep enforces this gate (`run.py _validate_approved_plan` fail-closes on those rows and on a blocking data.json `gateResult`), so a direct-implementation next-step is an instruction the reader cannot actually follow. **Cross-project pointer rule:** for cross-project dependencies (another repo / a different top-level deployment module / a published package), `crossProjectDependencies` (§5.4 Cross-Project Dependencies) is authoritative — do NOT duplicate that substance (prerequisite work / verification signals / handoff) into `recommendedNextSteps`; put only a one-line pointer to that section (no double-recording).
 4. **Follow-up Tasks** — auto-spawn-eligible table. Each row drives `okstra-spawn-followups.py`; see template §4 for the row schema.
 5. **Missing Information and Risks** — uncertain / "I don't know" items. `implementation-planning` adds §5.5 (see heading contract below); `release-handoff` adds §5.6.

package/runtime/python/okstra_ctl/render_final_report.py

@@ -56,6 +56,7 @@ from okstra_ctl.report_contract import TASK_TYPE_DATA_PROPERTY, markdown_templat
 from okstra_ctl.report_markdown import ReportSections
 from okstra_ctl.schema_excerpt import excerpt_cut_from_version
 from okstra_ctl.seeding import installed_version
+from okstra_ctl.usage_cells import format_duration_ms, format_int, format_usd
 
 
 TEMPLATE_BY_SCHEMA_VERSION = {
@@ -84,43 +85,6 @@ class FinalReportRenderError(RuntimeError):
     """
 
 
-def _format_int(value: Any) -> str:
-    if value is None or not isinstance(value, (str, int, float)):
-        return "--"
-    try:
-        return f"{int(value):,}"
-    except (TypeError, ValueError):
-        return "--"
-
-
-def _format_usd(value: Any) -> str:
-    if value is None or not isinstance(value, (str, int, float)):
-        return "--"
-    try:
-        return f"${float(value):.2f}"
-    except (TypeError, ValueError):
-        return "--"
-
-
-def _format_duration_ms(value: Any) -> str:
-    if value is None or not isinstance(value, (str, int, float)):
-        return "--"
-    try:
-        ms = int(value)
-    except (TypeError, ValueError):
-        return "--"
-    # A negative elapsed time is nonsensical (clock skew between start/end
-    # timestamps); divmod would otherwise produce a malformed "-1m 59s".
-    if ms < 0:
-        return "--"
-    total_seconds = ms // 1000
-    hours, remainder = divmod(total_seconds, 3600)
-    minutes, seconds = divmod(remainder, 60)
-    if hours:
-        return f"{hours}h {minutes:02d}m {seconds:02d}s"
-    return f"{minutes}m {seconds:02d}s"
-
-
 def _yaml_scalar(value: Any) -> str:
     """Serialize a scalar for the YAML frontmatter block.
 
@@ -555,9 +519,9 @@ def _build_environment(template_dir: Path) -> Environment:
         lstrip_blocks=True,
         keep_trailing_newline=True,
     )
-    env.filters["format_int"] = _format_int
-    env.filters["format_usd"] = _format_usd
-    env.filters["format_duration_ms"] = _format_duration_ms
+    env.filters["format_int"] = format_int
+    env.filters["format_usd"] = format_usd
+    env.filters["format_duration_ms"] = format_duration_ms
     env.filters["yaml_scalar"] = _yaml_scalar
     env.filters["yaml_inline_list"] = _yaml_inline_list
     env.filters["model_detail"] = _model_detail

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

@@ -9,7 +9,12 @@ from markupsafe import Markup, escape
 _INLINE_CODE = re.compile(r"`([^`]+)`")
 _SENTENCE_END = re.compile(r"(?<=[.!?])\s+")
 _SENTENCES_PER_PARAGRAPH = 2
-_ID_TOKEN = re.compile(r"\b[A-Z]{1,3}-\d+\b")
+# `\b` after the digits would end the token only where the next character is
+# non-word, and a Korean particle is a word character — `EA-001에` matched
+# nothing, so every id a translated report cites mid-sentence lost its link
+# while the English source kept it. The boundary a row id actually needs is
+# "not part of a longer alphanumeric run", which is what these assertions say.
+_ID_TOKEN = re.compile(r"(?<![A-Za-z0-9])[A-Z]{1,3}-\d+(?!\d)")
 
 
 def _link_ids(escaped: str, anchors: dict) -> str:

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

@@ -14,6 +14,7 @@ from ..final_report_schema import load_schema_for_data, validate
 from ..i18n import HTML_DICTIONARY_REL, load_dictionary, make_jinja_global
 from ..report_translation import overlay
 from ..report_view_artifacts import user_responses_dir_for_report
+from ..usage_cells import format_duration_ms
 from .common import anchor_index
 from .filters import (
     code_evidence,
@@ -26,6 +27,7 @@ from .filters import (
 from .models import HtmlRunMeta
 from .report_index import inject_report_index
 from .router import HtmlRenderError, resolve_html_route
+from .run_usage import run_usage
 
 
 def _sha256(path: Path) -> str:
@@ -47,17 +49,13 @@ def _elapsed_text(elapsed_ms: int | None) -> str | None:
     """Render a run duration, or nothing when there is none to render.
 
     A run whose team-state never recorded timestamps has no measured duration;
-    printing "0m" would claim it finished instantly.
+    printing "0m" would claim it finished instantly. Measured durations go
+    through the same formatter as the per-agent cells below, so the header and
+    the run-cost table do not spell one quantity two ways.
     """
     if not elapsed_ms or elapsed_ms < 0:
         return None
-    minutes, seconds = divmod(round(elapsed_ms / 1000), 60)
-    hours, minutes = divmod(minutes, 60)
-    if hours:
-        return f"{hours}h {minutes}m"
-    if minutes:
-        return f"{minutes}m {seconds}s"
-    return f"{seconds}s"
+    return format_duration_ms(elapsed_ms)
 
 
 def _report_meta(data: dict, run_meta: HtmlRunMeta) -> dict[str, object]:
@@ -152,6 +150,9 @@ def render_v2_html_view(
         "dataSha256": _sha256(data_path),
         "markdownSha256": _sha256(markdown_path),
         "clarificationItems": data.get("clarificationItems", []),
+        # Every task type ends with the same run-cost section, so it is bound
+        # here rather than in ten view models that would each rebuild it.
+        "runUsage": run_usage(data),
         "css": (root / "html/assets/base.css").read_text(encoding="utf-8"),
         "js": response_js + "\n" + base_js,
     }

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

@@ -0,0 +1,110 @@
+"""What the run cost, per agent — the Phase 7 usage cells as reader-facing text.
+
+`executionStatus` is the only block that holds a duration per agent, so the
+table is built from it rather than from `tokenUsage.workerDetails`, which
+repeats the same token figures without saying how long each agent ran.
+
+The formatting happens here rather than in the template because a null cell has
+to read as "not measured" everywhere it appears, and `usage_cells` is where both
+report views agree on how that looks.
+"""
+from __future__ import annotations
+
+from ..usage_cells import format_duration_ms, format_int, format_usd
+
+
+def _number(value: object) -> int | float | None:
+    if isinstance(value, bool) or not isinstance(value, (int, float)):
+        return None
+    return value
+
+
+def _totals_row(row: object) -> dict[str, str]:
+    values = row if isinstance(row, dict) else {}
+    return {
+        "rawTokens": format_int(values.get("totalTokens")),
+        "billableTokens": format_int(values.get("billableTokens")),
+        "cost": format_usd(values.get("costUsd")),
+    }
+
+
+def _agent_row(row: dict) -> dict[str, str]:
+    """One agent's identity and what it spent.
+
+    The CLI cells stay empty rather than `--` when the agent made no CLI call:
+    they render as a second line inside the token and cost cells, and a `--`
+    there would read as a missing measurement instead of an absent charge.
+    """
+    cli_tokens = _number(row.get("cliTotalTokens")) or 0
+    cli_cost = _number(row.get("cliCostUsd")) or 0
+    return {
+        "agent": str(row.get("agent") or ""),
+        "role": str(row.get("role") or ""),
+        "model": str(row.get("model") or ""),
+        "status": str(row.get("status") or ""),
+        "rawTokens": format_int(row.get("totalTokens")),
+        "billableTokens": format_int(row.get("billableTokens")),
+        "cost": format_usd(row.get("costUsd")),
+        "duration": format_duration_ms(row.get("durationMs")),
+        "cliTokens": format_int(cli_tokens) if cli_tokens else "",
+        "cliCost": format_usd(cli_cost) if cli_cost else "",
+    }
+
+
+def _sum(rows: list[dict], key: str) -> int | float:
+    return sum(_number(row.get(key)) or 0 for row in rows)
+
+
+def _unaccounted(rows: list[dict], grand: dict) -> dict[str, str] | None:
+    """The part of the total that no row above carries, when there is one.
+
+    Two documented paths leave a gap. Sessions that match no worker are summed
+    into `unattributedWorkerUsage`, and where two report rows share one
+    team-state aggregate only the first is attributed, leaving the second's
+    cells null. Both land in the total, so without this row the column adds up
+    to less than the figure beneath it and neither number can be trusted.
+    """
+    grand_tokens = _number(grand.get("totalTokens"))
+    if grand_tokens is None:
+        return None
+    gap = grand_tokens - _sum(rows, "totalTokens")
+    if gap <= 0:
+        return None
+    billable_gap = (_number(grand.get("billableTokens")) or 0) - _sum(rows, "billableTokens")
+    cost_gap = (_number(grand.get("costUsd")) or 0) - _sum(rows, "costUsd")
+    return {
+        "rawTokens": format_int(gap),
+        "billableTokens": format_int(max(0, billable_gap)),
+        "cost": format_usd(max(0.0, cost_gap)),
+    }
+
+
+_MEASURED_KEYS = ("totalTokens", "billableTokens", "costUsd", "durationMs")
+
+
+def run_usage(data: dict) -> dict[str, object] | None:
+    """The run-cost table, or nothing when the run has no measured figure.
+
+    Phase 7 fills these cells before the HTML is rendered, so an all-null table
+    means the collector found no session to read. A grid of `--` states nothing
+    the reader can act on, so the section stays out of the document entirely.
+    """
+    rows = [row for row in (data.get("executionStatus") or []) if isinstance(row, dict)]
+    usage = data.get("tokenUsage") or {}
+    totals = {name: _totals_row(usage.get(name)) for name in ("lead", "worker", "grand")}
+    measured = any(
+        _number(row.get(key)) is not None for row in rows for key in _MEASURED_KEYS
+    ) or any(
+        _number((usage.get(name) or {}).get(key)) is not None
+        for name in ("lead", "worker", "grand")
+        for key in _MEASURED_KEYS
+    )
+    if not measured:
+        return None
+    cli_cost = _number((usage.get("cli") or {}).get("costUsd")) or 0
+    return {
+        "rows": [_agent_row(row) for row in rows],
+        "unaccounted": _unaccounted(rows, usage.get("grand") or {}),
+        **totals,
+        "cliCost": format_usd(cli_cost) if cli_cost else "",
+    }

package/runtime/python/okstra_ctl/report_html/view_models/error_analysis.py

@@ -1,32 +1,85 @@
 """Human-first error-analysis view model."""
 from __future__ import annotations
 
+import re
+
 from ..common import evidence_index
 from ..models import HumanReportView, VisualEdge, VisualNode
 from ..visualizations import cause_graph_figure
 
 
-def _cause_figure(error: dict):
-    symptom = VisualNode(
-        "symptom", "Observed failure", "effect", "risk", error["observableFailure"], note="Observed failure"
+_LEAD_CLAUSE = re.compile(r"\s[—–-]\s|(?<=[.。!?])\s")
+_MAX_LABEL_CHARS = 44
+
+
+def _short_label(statement: str) -> str:
+    """The candidate's name, taken from the opening clause of its statement.
+
+    `causeCandidates` carries no title field: `statement` is the full claim,
+    routinely several sentences long. Passed through whole it filled the
+    figure's name cell with prose and ran the node text out of the drawing, so
+    the figure takes the lead clause and leaves the claim to the cards below.
+    """
+    head = _LEAD_CLAUSE.split(statement.strip(), maxsplit=1)[0].strip()
+    if len(head) <= _MAX_LABEL_CHARS:
+        return head
+    return head[:_MAX_LABEL_CHARS].rstrip() + "…"
+
+
+def _cause_node(row: dict, leading_cause_id: str) -> VisualNode:
+    # The figure names its nodes and nothing more. Both the failure sentence
+    # and each candidate's disproof already have a section of their own, and
+    # repeating them here printed every one of them twice.
+    leading = row["id"] == leading_cause_id
+    return VisualNode(
+        row["id"],
+        _short_label(row["statement"]),
+        "candidate",
+        "leading" if leading else row["confidence"],
+        "",
+        note="Leading cause" if leading else f'Confidence {row["confidence"]}',
     )
-    causes = tuple(
-        VisualNode(
-            row["id"],
-            row["statement"],
-            "candidate",
-            row["confidence"],
-            row["disproveWith"],
-            note=f'Confidence {row["confidence"]}',
-        )
-        for row in error.get("causeCandidates", [])
+
+
+def _cause_edges(rows: list[dict], symptom_id: str) -> tuple[VisualEdge, ...]:
+    """The chain between candidates, then the symptom each chain ends at.
+
+    Candidates are not always competing guesses for one spot. A propagation
+    chain — the extraction breaks, the error is swallowed, the empty result is
+    stamped a success — needs every link to hold for the symptom to appear, and
+    `downstreamOf` is where the diagnosis says so. Drawing every candidate
+    straight at the symptom instead claimed they were alternatives.
+
+    Only a candidate nothing else is downstream of reaches the symptom: an
+    upstream link would otherwise be drawn as its own explanation of the
+    symptom as well as a step on the way there.
+    """
+    known = {row["id"] for row in rows}
+    upstream = {
+        row["id"]: [step for step in row.get("downstreamOf", []) if step in known]
+        for row in rows
+    }
+    has_downstream = {step for steps in upstream.values() for step in steps}
+    chain = tuple(
+        VisualEdge(step, row["id"], "then", "chain")
+        for row in rows
+        for step in upstream[row["id"]]
     )
-    edges = tuple(
-        VisualEdge(row.id, symptom.id, "may cause", "hypothesis") for row in causes
+    return chain + tuple(
+        VisualEdge(row["id"], symptom_id, "may cause", "hypothesis")
+        for row in rows
+        if row["id"] not in has_downstream
     )
+
+
+def _cause_figure(error: dict):
+    symptom = VisualNode("symptom", "Observed failure", "effect", "risk", "", note="Symptom")
+    rows = error.get("causeCandidates", [])
+    leading_cause_id = (error.get("routing") or {}).get("leadingCauseId") or ""
+    causes = tuple(_cause_node(row, leading_cause_id) for row in rows)
     return cause_graph_figure(
         nodes=(symptom, *causes),
-        edges=edges,
+        edges=_cause_edges(rows, symptom.id),
         title="Cause hypotheses and observed symptom",
     )
 

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

@@ -2,6 +2,7 @@
 from __future__ import annotations
 
 import html
+import unicodedata
 from dataclasses import replace
 from typing import Iterable, Sequence
 
@@ -11,6 +12,11 @@ from .models import FigureModel, VisualEdge, VisualNode
 _ROWS_PER_COLUMN = 8
 _COLUMN_WIDTH = 260
 _ROW_HEIGHT = 100
+_NODE_WIDTH = 180
+_NODE_MIN_HEIGHT = 50
+_LABEL_PADDING = 12
+_LINE_HEIGHT = 16
+_MAX_LABEL_LINES = 3
 
 
 def _group_columns(nodes: Sequence[VisualNode]) -> list[list[str]]:
@@ -141,10 +147,103 @@ _ARROW_MARKER = (
 )
 
 
+def _drawable_text(value: str) -> str:
+    """Strip the markdown code fences a drawing cannot render.
+
+    Labels carry backticks around identifiers because every other text surface
+    turns them into `<code>`. Drawn literally they are stray characters inside
+    the box, and they consume width the label needs.
+    """
+    return value.replace("`", "")
+
+
+def _text_width(text: str) -> float:
+    """Approximate the advance width of the 13px label font.
+
+    An SVG carries no font metrics, so wrapping has to estimate. East-Asian
+    characters occupy a full em; the rest average a little over half of one.
+    """
+    return sum(13.0 if unicodedata.east_asian_width(c) in ("W", "F") else 6.8 for c in text)
+
+
+def _split_oversized_word(word: str, limit: float) -> list[str]:
+    """Cut a word wider than the box into box-width pieces.
+
+    Korean and Japanese labels arrive as long unbroken runs, and a path or an
+    identifier can be wider than the box on its own.
+    """
+    pieces: list[str] = []
+    current = ""
+    for char in word:
+        if current and _text_width(current + char) > limit:
+            pieces.append(current)
+            current = char
+        else:
+            current += char
+    return pieces + [current] if current else pieces
+
+
+def _ellipsize(line: str, limit: float) -> str:
+    while line and _text_width(line + "…") > limit:
+        line = line[:-1]
+    return line + "…"
+
+
+def _wrap_label(label: str) -> list[str]:
+    """Break a label into the lines that fit inside one node box.
+
+    The label used to be drawn as a single line whatever its length, so a node
+    carrying a sentence painted it straight out of the box and off the canvas.
+    Text past the last line is cut here rather than drawn, because the
+    figure's fallback table prints the label in full.
+    """
+    limit = _NODE_WIDTH - 2 * _LABEL_PADDING
+    lines: list[str] = []
+    current = ""
+    for word in label.split():
+        pieces = _split_oversized_word(word, limit) if _text_width(word) > limit else [word]
+        for piece in pieces:
+            candidate = f"{current} {piece}".strip()
+            if current and _text_width(candidate) > limit:
+                lines.append(current)
+                current = piece
+            else:
+                current = candidate
+    if current:
+        lines.append(current)
+    if len(lines) > _MAX_LABEL_LINES:
+        lines = lines[:_MAX_LABEL_LINES]
+        lines[-1] = _ellipsize(lines[-1], limit)
+    return lines or [""]
+
+
+def _node_group(node: VisualNode, x: int, y: int, lines: Sequence[str], box_height: int) -> str:
+    baseline = y + (box_height - len(lines) * _LINE_HEIGHT) // 2 + _LINE_HEIGHT - 4
+    spans = "".join(
+        f'<tspan x="{x + _LABEL_PADDING}" y="{baseline + index * _LINE_HEIGHT}">'
+        f"{html.escape(line)}</tspan>"
+        for index, line in enumerate(lines)
+    )
+    status = html.escape(node.status)
+    detail = _drawable_text(node.detail)
+    tooltip = f"{_drawable_text(node.label)}: {node.status}." + (f" {detail}" if detail else "")
+    return (
+        f'<g data-node-id="{html.escape(node.id)}" class="node node-{status}">'
+        f"<title>{html.escape(tooltip)}</title>"
+        f'<rect x="{x}" y="{y}" width="{_NODE_WIDTH}" height="{box_height}" rx="8"/>'
+        f"<text>{spans}</text></g>"
+    )
+
+
 def _svg_document(nodes: Sequence[VisualNode], edges: Sequence[VisualEdge]) -> str:
     positions = _node_positions(nodes, edges)
-    width = max((x for x, _ in positions.values()), default=50) + 230
-    height = max((y for _, y in positions.values()), default=55) + 90
+    wrapped = {node.id: _wrap_label(_drawable_text(node.label)) for node in nodes}
+    line_count = max((len(lines) for lines in wrapped.values()), default=1)
+    # One height for every box: a figure whose rows are all the same depth
+    # keeps the arrow between two columns horizontal.
+    box_height = max(_NODE_MIN_HEIGHT, line_count * _LINE_HEIGHT + 2 * _LABEL_PADDING)
+    width = max((x for x, _ in positions.values()), default=50) + _NODE_WIDTH + 50
+    height = max((y for _, y in positions.values()), default=55) + box_height + 40
     parts = [f'<svg viewBox="0 0 {width} {height}" role="img" xmlns="http://www.w3.org/2000/svg">']
     parts.append(_ARROW_MARKER)
     for edge in edges:
@@ -154,8 +253,11 @@ def _svg_document(nodes: Sequence[VisualNode], edges: Sequence[VisualEdge]) -> s
         x2, y2 = positions[edge.target]
         # Leave the source box on its right edge and arrive on the target's
         # left, so a left-to-right layering reads as one direction of travel.
-        start_x, end_x = (x1 + 180, x2) if x2 > x1 else ((x1, x2 + 180) if x2 < x1 else (x1 + 90, x2 + 90))
-        start_y, end_y = y1 + 25, y2 + 25
+        forward = (x1 + _NODE_WIDTH, x2)
+        backward = (x1, x2 + _NODE_WIDTH)
+        same_column = (x1 + _NODE_WIDTH // 2, x2 + _NODE_WIDTH // 2)
+        start_x, end_x = forward if x2 > x1 else (backward if x2 < x1 else same_column)
+        start_y, end_y = y1 + box_height // 2, y2 + box_height // 2
         span = abs(x2 - x1) // _COLUMN_WIDTH
         if span > 1:
             # An edge that skips a column would otherwise be drawn straight
@@ -177,16 +279,7 @@ def _svg_document(nodes: Sequence[VisualNode], edges: Sequence[VisualEdge]) -> s
         )
     for node in nodes:
         x, y = positions[node.id]
-        node_id = html.escape(node.id)
-        label = html.escape(node.label)
-        status = html.escape(node.status)
-        detail = html.escape(node.detail)
-        parts.append(
-            f'<g data-node-id="{node_id}" class="node node-{status}">'
-            f"<title>{label}: {status}. {detail}</title>"
-            f'<rect x="{x}" y="{y}" width="180" height="50" rx="8"/>'
-            f'<text x="{x + 12}" y="{y + 30}">{label}</text></g>'
-        )
+        parts.append(_node_group(node, x, y, wrapped[node.id], box_height))
     parts.append("</svg>")
     return "".join(parts)
 

package/runtime/python/okstra_ctl/usage_cells.py

@@ -0,0 +1,47 @@
+"""How a token, cost, or duration figure reads in a report cell.
+
+Phase 7 fills the same numbers into two views — the AI-handoff Markdown and
+the reader's HTML — so they format here once. A cell that is still null prints
+``--`` rather than a zero: ``0`` tokens and ``$0.00`` are what a run that spent
+nothing would look like, which is a different claim from "not measured".
+"""
+from __future__ import annotations
+
+from typing import Any
+
+
+def format_int(value: Any) -> str:
+    if value is None or not isinstance(value, (str, int, float)):
+        return "--"
+    try:
+        return f"{int(value):,}"
+    except (TypeError, ValueError):
+        return "--"
+
+
+def format_usd(value: Any) -> str:
+    if value is None or not isinstance(value, (str, int, float)):
+        return "--"
+    try:
+        return f"${float(value):.2f}"
+    except (TypeError, ValueError):
+        return "--"
+
+
+def format_duration_ms(value: Any) -> str:
+    if value is None or not isinstance(value, (str, int, float)):
+        return "--"
+    try:
+        ms = int(value)
+    except (TypeError, ValueError):
+        return "--"
+    # A negative elapsed time is nonsensical (clock skew between start/end
+    # timestamps); divmod would otherwise produce a malformed "-1m 59s".
+    if ms < 0:
+        return "--"
+    total_seconds = ms // 1000
+    hours, remainder = divmod(total_seconds, 3600)
+    minutes, seconds = divmod(remainder, 60)
+    if hours:
+        return f"{hours}h {minutes:02d}m {seconds:02d}s"
+    return f"{minutes}m {seconds:02d}s"

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

@@ -1637,7 +1637,11 @@
                 "items": { "type": "string" }
               },
               "confidence": { "enum": ["low", "medium", "high"] },
-              "disproveWith": { "type": "string", "minLength": 1 }
+              "disproveWith": { "type": "string", "minLength": 1 },
+              "downstreamOf": {
+                "type": "array",
+                "items": { "type": "string", "pattern": "^EA-\\d{3,}$" }
+              }
             }
           }
         },

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

@@ -38,6 +38,7 @@ svg { max-width: 100%; min-width: 520px; height: auto; }
 svg .edge { stroke: GrayText; stroke-width: 2; }
 svg .edge-arrow-head { fill: GrayText; }
 svg .node rect { fill: color-mix(in srgb, Highlight 14%, Canvas); stroke: Highlight; }
+svg .node-leading rect { fill: color-mix(in srgb, Highlight 32%, Canvas); stroke-width: 2; }
 svg .node text { fill: CanvasText; font-size: 13px; }
 table { width: 100%; border-collapse: collapse; margin-top: 1rem; font-size: .9rem; }
 /* Korean takes a line break between any two syllables, so an auto-layout
@@ -79,7 +80,19 @@ th, td { text-align: left; vertical-align: top; border-bottom: 1px solid color-m
 .ledger-source { font-size: .9rem; color: GrayText; }
 .ledger-source > span:first-child::after { content: ":"; }
 .status { display: inline-block; white-space: nowrap; border-radius: 999px; padding: .1rem .5rem; background: color-mix(in srgb, GrayText 15%, Canvas); }
-.status-gap, .status-risk { background: color-mix(in srgb, #d94b4b 18%, Canvas); }
+.status-gap, .status-risk, .status-error, .status-timeout { background: color-mix(in srgb, #d94b4b 18%, Canvas); }
+/* Figures are read by comparing them down the column, which only works when
+   the digits line up: tabular-nums stops a 1 from being narrower than a 7, and
+   the right edge is the one they share. */
+.run-usage-lede { max-width: 78ch; }
+.figure { text-align: right; font-variant-numeric: tabular-nums; white-space: nowrap; }
+/* Four nowrap number columns need almost none of the width, and the default
+   even split spent it on them while the agent names wrapped mid-word. */
+[data-report-section="run-usage"] .row-key { width: 45%; }
+.cli-extra { display: block; color: GrayText; font-size: .85em; }
+tfoot th { font-weight: 600; }
+tfoot tr:first-child > * { border-top: 2px solid color-mix(in srgb, CanvasText 30%, transparent); }
+tfoot .grand-total > * { font-weight: 700; }
 .human-report-footer { width: min(1120px, calc(100% - 2rem)); margin: 0 auto 2rem; display: flex; flex-wrap: wrap; gap: .6rem; }
 .human-report-footer pre { flex-basis: 100%; white-space: pre-wrap; max-height: 14em; overflow: auto; }
 fieldset, label { display: block; margin: .7rem 0; }

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

@@ -1,5 +1,6 @@
 <!DOCTYPE html>
 {% from "html/macros/forms.html" import clarification_responses %}
+{% from "html/macros/layout.html" import row_key %}
 <html lang="en" data-task-template="{{ taskType }}">
 <head>
   <meta charset="utf-8">
@@ -38,6 +39,47 @@
       </ol>
     </section>
     {% endif %}
+    {% if runUsage %}
+    <section data-report-section="run-usage" data-reader-kind="audit">
+      <h2>{{ t('runUsage.heading') }}</h2>
+      <p class="run-usage-lede">{{ t('runUsage.intro') }}</p>
+      <table>
+        <thead><tr>
+          <th scope="col">{{ t('runUsage.agent') }}</th>
+          <th scope="col" class="figure">{{ t('runUsage.raw-tokens') }}</th>
+          <th scope="col" class="figure">{{ t('runUsage.billable-tokens') }}</th>
+          <th scope="col" class="figure">{{ t('runUsage.cost') }}</th>
+          <th scope="col" class="figure">{{ t('runUsage.duration') }}</th>
+        </tr></thead>
+        <tbody>
+          {% for row in runUsage.rows %}
+          <tr>
+            {{ row_key(pairs=[(t('runUsage.agent'), row.agent), (t('runUsage.role'), row.role), (t('runUsage.model'), row.model)], status_name=t('runUsage.status'), status_raw=row.status, status_text=row.status | enum_label('workerStatus')) }}
+            <td class="figure">{{ row.rawTokens }}{% if row.cliTokens %}<span class="cli-extra">{{ t('runUsage.cli') }} {{ row.cliTokens }}</span>{% endif %}</td>
+            <td class="figure">{{ row.billableTokens }}</td>
+            <td class="figure">{{ row.cost }}{% if row.cliCost %}<span class="cli-extra">+ {{ t('runUsage.cli') }} {{ row.cliCost }}</span>{% endif %}</td>
+            <td class="figure">{{ row.duration }}</td>
+          </tr>
+          {% endfor %}
+          {% if runUsage.unaccounted %}
+          <tr>
+            <td class="row-key">{{ t('runUsage.unaccounted') }}</td>
+            <td class="figure">{{ runUsage.unaccounted.rawTokens }}</td>
+            <td class="figure">{{ runUsage.unaccounted.billableTokens }}</td>
+            <td class="figure">{{ runUsage.unaccounted.cost }}</td>
+            <td class="figure"></td>
+          </tr>
+          {% endif %}
+        </tbody>
+        <tfoot>
+          <tr><th scope="row">{{ t('runUsage.row-lead') }}</th><td class="figure">{{ runUsage.lead.rawTokens }}</td><td class="figure">{{ runUsage.lead.billableTokens }}</td><td class="figure">{{ runUsage.lead.cost }}</td><td class="figure"></td></tr>
+          <tr><th scope="row">{{ t('runUsage.row-workers') }}</th><td class="figure">{{ runUsage.worker.rawTokens }}</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.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">{{ runUsage.cliCost }}</td><td class="figure"></td></tr>{% endif %}
+        </tfoot>
+      </table>
+    </section>
+    {% endif %}
   </main>
   <footer class="human-report-footer">
     <button type="button" data-action="export-user-response">{{ t('base.export-my-answers') }}</button>

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

@@ -60,6 +60,13 @@
     "handoffMode": {
       "whole-task": "Whole task",
       "stage-group": "Selected stages"
+    },
+    "workerStatus": {
+      "completed": "Completed",
+      "error": "Failed",
+      "timeout": "Timed out",
+      "not-run": "Not run",
+      "synthesis-only": "Synthesis only"
     }
   },
   "enumHint": {
@@ -86,6 +93,24 @@
     "drop-that-file-into": ". Drop that file into",
     "and-the-next-run-picks-your-answers-up-on-it": "and the next run picks your answers up on its own."
   },
+  "runUsage": {
+    "heading": "What this run cost",
+    "intro": "Every agent this run dispatched, with what it spent and how long it was working. Agents run alongside each other, so their durations do not add up to the elapsed time in the header. Raw tokens are the volume processed; billable tokens are that same work restated in input-price units, which is what the cost is computed from.",
+    "agent": "Agent",
+    "role": "Role",
+    "model": "Model",
+    "status": "Status",
+    "raw-tokens": "Raw tokens",
+    "billable-tokens": "Billable tokens",
+    "cost": "Cost",
+    "duration": "Working time",
+    "cli": "CLI",
+    "unaccounted": "Not attributed to an agent above",
+    "row-lead": "Lead",
+    "row-workers": "Workers",
+    "row-total": "Total",
+    "row-cli": "CLI calls (billed separately)"
+  },
   "macros": {
     "forms": {
       "review-this-analysis": "Review this analysis",

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

@@ -60,6 +60,13 @@
     "handoffMode": {
       "whole-task": "태스크 전체",
       "stage-group": "선택한 stage"
+    },
+    "workerStatus": {
+      "completed": "완료",
+      "error": "실패",
+      "timeout": "시간 초과",
+      "not-run": "미실행",
+      "synthesis-only": "종합만 수행"
     }
   },
   "enumHint": {
@@ -86,6 +93,24 @@
     "drop-that-file-into": ". 그 파일을 여기에 두면",
     "and-the-next-run-picks-your-answers-up-on-it": "다음 run 이 알아서 답변을 읽어 갑니다."
   },
+  "runUsage": {
+    "heading": "이번 실행에 든 비용",
+    "intro": "이번 실행이 투입한 에이전트별로 얼마를 썼고 얼마나 오래 일했는지입니다. 에이전트는 서로 겹쳐서 돌기 때문에 각 작업 시간을 더해도 머리말의 소요 시간과 같지 않습니다. 원시 토큰은 처리한 분량이고, 과금 환산 토큰은 같은 작업을 입력 단가 기준으로 환산한 값으로 금액은 이 값에서 나옵니다.",
+    "agent": "에이전트",
+    "role": "역할",
+    "model": "모델",
+    "status": "상태",
+    "raw-tokens": "원시 토큰",
+    "billable-tokens": "과금 환산 토큰",
+    "cost": "금액",
+    "duration": "작업 시간",
+    "cli": "CLI",
+    "unaccounted": "위 행에 귀속되지 않은 사용량",
+    "row-lead": "리드",
+    "row-workers": "워커 합계",
+    "row-total": "합계",
+    "row-cli": "CLI 호출 (별도 청구)"
+  },
   "macros": {
     "forms": {
       "review-this-analysis": "이 분석 검토하기",

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

@@ -7,11 +7,12 @@
   </figcaption>
   <div class="visualization" aria-hidden="true">{{ model.svg | safe }}</div>
   {% set show_paths = model.nodes | selectattr("paths") | first is defined %}
+  {% set show_detail = model.nodes | selectattr("detail") | first is defined %}
   <table class="visualization-fallback">
-    <thead><tr><th>{{ t('macros.visualizations.component') }}</th><th>{{ t('macros.visualizations.what-it-does') }}</th>{% if show_paths %}<th>{{ t('macros.visualizations.paths') }}</th>{% endif %}</tr></thead>
+    <thead><tr><th>{{ t('macros.visualizations.component') }}</th>{% if show_detail %}<th>{{ t('macros.visualizations.what-it-does') }}</th>{% endif %}{% if show_paths %}<th>{{ t('macros.visualizations.paths') }}</th>{% endif %}</tr></thead>
     <tbody>
       {% for node in model.nodes %}
-      <tr{% if anchor_nodes %} id="id-{{ node.id }}"{% endif %} data-fallback-id="{{ node.id }}">{{ row_key(pairs=[("ID", node.id), ("Name", node.label), ("Kind", node.note)]) }}<td>{{ node.detail | inline_code }}</td>{% if show_paths %}<td>{% for path in node.paths %}<code>{{ path }}</code>{% if not loop.last %} {% endif %}{% endfor %}</td>{% endif %}</tr>
+      <tr{% if anchor_nodes %} id="id-{{ node.id }}"{% endif %} data-fallback-id="{{ node.id }}">{{ row_key(pairs=[("ID", node.id), ("Name", node.label), ("Kind", node.note)]) }}{% if show_detail %}<td>{{ node.detail | inline_code }}</td>{% endif %}{% if show_paths %}<td>{% for path in node.paths %}<code>{{ path }}</code>{% if not loop.last %} {% endif %}{% endfor %}</td>{% endif %}</tr>
       {% endfor %}
     </tbody>
   </table>

package/runtime/validators/validate-run.py

@@ -2972,6 +2972,68 @@ def _route_target_matches(value: Any, target: str, *, command: bool) -> bool:
     )
 
 
+def _upstream_by_candidate(candidates: list[Any]) -> dict[str, list[str]]:
+    upstream: dict[str, list[str]] = {}
+    for candidate in candidates:
+        if not isinstance(candidate, Mapping):
+            continue
+        candidate_id = candidate.get("id")
+        declared = candidate.get("downstreamOf")
+        if isinstance(candidate_id, str) and isinstance(declared, list):
+            upstream[candidate_id] = [row for row in declared if isinstance(row, str)]
+    return upstream
+
+
+def _chain_cycle(upstream: dict[str, list[str]]) -> list[str]:
+    """The first cycle reachable through `downstreamOf`, as the ids that form it.
+
+    A cycle is a diagnosis that says each step is caused by the next, so it
+    names no first cause. It also hangs the figure's layering, which relaxes
+    until depths settle.
+    """
+    settled: set[str] = set()
+    for start in sorted(upstream):
+        stack = [start]
+        on_path: list[str] = []
+        while stack:
+            current = stack.pop()
+            if current in on_path:
+                return on_path[on_path.index(current):] + [current]
+            if current in settled or current not in upstream:
+                continue
+            on_path.append(current)
+            stack.extend(upstream[current])
+        settled.update(on_path)
+    return []
+
+
+def _validate_cause_chain(
+    candidates: list[Any], candidate_ids: set[str], failures: list[str]
+) -> None:
+    """`downstreamOf` must name a sibling candidate, and never itself."""
+    upstream = _upstream_by_candidate(candidates)
+    for candidate_id in sorted(upstream):
+        unknown = sorted(set(upstream[candidate_id]) - candidate_ids)
+        if unknown:
+            failures.append(
+                f"final-report data.json: {candidate_id}.downstreamOf names "
+                "unknown cause candidate(s): " + ", ".join(unknown) + "."
+            )
+        if candidate_id in upstream[candidate_id]:
+            failures.append(
+                f"final-report data.json: {candidate_id}.downstreamOf names itself."
+            )
+    cycle = _chain_cycle(
+        {key: [row for row in value if row in candidate_ids] for key, value in upstream.items()}
+    )
+    if cycle:
+        failures.append(
+            "final-report data.json: cause candidates form a downstreamOf cycle: "
+            + " -> ".join(cycle)
+            + "."
+        )
+
+
 def _validate_error_analysis_consistency(
     data: Mapping[str, Any], failures: list[str]
 ) -> None:
@@ -3018,6 +3080,8 @@ def _validate_error_analysis_consistency(
             + "."
         )
 
+    _validate_cause_chain(candidates, set(candidate_ids), failures)
+
     routing_value = error_analysis.get("routing")
     routing = routing_value if isinstance(routing_value, Mapping) else {}
     target = routing.get("nextTaskType")