okstra 0.148.1 → 0.150.0

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

@@ -1,64 +1,75 @@
 """Common data transformations that carry no task-specific section order."""
 from __future__ import annotations
 
-
-def audit_context(data: dict) -> dict[str, object]:
+import re
+
+
+# Every block whose rows prose cites but no section of its own renders, with
+# the keys each one names its content and its provenance by. A key hunt across
+# all of them would misread `crossVerification.consensus`, whose `evidence` key
+# holds provenance while `evidence.primary` uses the same word for content —
+# so the block a row came from is named here rather than guessed.
+_LEDGER_BLOCKS = (
+    (("evidence", "primary"), "evidence", "source", "unclassified"),
+    (("evidence", "secondary"), "hypothesis", "confidence", "hypothesis"),
+    (("analysisCommon", "confirmedFacts"), "statement", "", "confirmed fact"),
+    (("analysisCommon", "inferences"), "statement", "confidence", "inference"),
+    (("analysisCommon", "unknowns"), "question", "reason", "unknown"),
+    (("crossVerification", "consensus"), "statement", "evidence", "cross-check consensus"),
+    (("crossVerification", "differences"), "disagreement", "workersPosition", "cross-check dissent"),
+    (("missingInformation",), "item", "risk", "missing information"),
+    (("endStateCoverage",), "coveredBy", "evidence", "exit contract"),
+    (("followUpTasks",), "title", "reason", "follow-up"),
+)
+
+
+def _dig(data: dict, path: tuple[str, ...]) -> list:
+    node: object = data
+    for key in path:
+        if not isinstance(node, dict):
+            return []
+        node = node.get(key)
+    return node if isinstance(node, list) else []
+
+
+def _ledger_row(row: dict, text_key: str, source_key: str, kind: str) -> dict[str, object]:
     return {
-        "crossVerification": data.get("crossVerification", {}),
-        "executionStatus": data.get("executionStatus", []),
-        "tokenUsage": data.get("tokenUsage", {}),
+        "id": row.get("id", ""),
+        "kind": kind,
+        "text": str(row.get(text_key) or ""),
+        "codeEvidence": row.get("currentCodeEvidence") or [],
+        "source": str(row.get(source_key) or "") if source_key else "",
     }
 
 
-_LEDGER_TEXT_KEYS = ("statement", "evidence", "hypothesis", "question")
-_LEDGER_SOURCE_KEYS = ("source", "confidence", "reason")
-
-
-def _first_filled(row: dict, keys: tuple[str, ...]) -> str:
-    for key in keys:
-        value = row.get(key)
-        if value:
-            return str(value)
-    return ""
-
-
-def _ledger_row(row: dict) -> dict[str, object]:
-    """Flatten one evidence row into the single shape the ledger renders.
+def _own_section_ids(data: dict) -> set[str]:
+    """Ids a section of the report already renders and anchors.
 
-    Every row type that reaches the ledger is ``additionalProperties: false``
-    and names its content and source differently, so no row carries another
-    row type's keys:
-
-    - ``evidence.primary`` — ``evidence`` / ``source``
-    - ``evidence.secondary`` — ``hypothesis`` / ``confidence``
-    - ``analysisCommon.confirmedFacts`` — ``statement`` / ``currentCodeEvidence``
-    - ``analysisCommon.inferences`` — ``statement`` / ``confidence``
-    - ``analysisCommon.unknowns`` — ``question`` / ``reason``
-
-    Only this function knows which block a row came from, so the key hunt
-    belongs here rather than in the template.
+    The ledger is the fallback home for a cited row, so it must not claim an id
+    that has one — two elements with the same anchor send half the links to the
+    wrong place. `crossVerification.consensus` numbers its rows `C-001` in some
+    runs, exactly where a clarification lives.
     """
-    return {
-        "id": row.get("id", ""),
-        "text": _first_filled(row, _LEDGER_TEXT_KEYS),
-        "codeEvidence": row.get("currentCodeEvidence") or [],
-        "source": _first_filled(row, _LEDGER_SOURCE_KEYS),
-    }
+    from ..report_contract import TASK_TYPE_DATA_PROPERTY
+
+    found: set[str] = set()
+    _collect_ids(data.get("clarificationItems", []), found)
+    property_name = TASK_TYPE_DATA_PROPERTY.get(data.get("header", {}).get("taskType", ""))
+    if property_name:
+        _collect_ids(data.get(property_name, {}), found)
+    return found
 
 
 def evidence_index(data: dict) -> dict[str, object]:
+    owned = _own_section_ids(data)
     rows: dict[str, object] = {}
-    for section in ("primary", "secondary"):
-        for row in data.get("evidence", {}).get(section, []):
-            row_id = row.get("id")
-            if row_id:
-                rows[row_id] = _ledger_row(row)
-    analysis = data.get("analysisCommon", {})
-    for collection in ("confirmedFacts", "inferences", "unknowns"):
-        for row in analysis.get(collection, []):
+    for path, text_key, source_key, kind in _LEDGER_BLOCKS:
+        for row in _dig(data, path):
+            if not isinstance(row, dict):
+                continue
             row_id = row.get("id")
-            if row_id:
-                rows[row_id] = _ledger_row(row)
+            if row_id and row_id not in owned and row_id not in rows:
+                rows[row_id] = _ledger_row(row, text_key, source_key, kind)
     return rows
 
 
@@ -74,6 +85,25 @@ def _collect_ids(value: object, found: set[str]) -> None:
             _collect_ids(nested, found)
 
 
+_ROW_ID = re.compile(r"[A-Z]{1,3}-\d+")
+
+
+def anchor_index(data: dict) -> dict[str, str]:
+    """Map every row a reader can reach to the anchor name that lands on it.
+
+    Prose cites ids across section boundaries — a hotspot names a
+    cross-verification finding, a quality row names a difference — so the
+    target set spans the whole reader-facing report: the task's own sections,
+    the clarifications, and every block the ledger takes in.
+
+    It stops there. `summary` is the AI-facing digest and
+    `analysisCommon.scope` describes the analysis target rather than listing
+    rows; neither renders, so a link to one would land nowhere.
+    """
+    found = _own_section_ids(data) | set(evidence_index(data))
+    return {row_id: f"id-{row_id}" for row_id in sorted(found) if _ROW_ID.fullmatch(row_id)}
+
+
 def analysis_review_ids(data: dict) -> tuple[str, ...]:
     found: set[str] = set()
     _collect_ids(data.get("analysisCommon", {}), found)

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

@@ -1,8 +1,6 @@
 """Jinja filters for the task-specific HTML report."""
 from __future__ import annotations
 
-import html
-import json
 import re
 
 import okstra_vendor  # noqa: F401  # registers vendored dependency aliases
@@ -11,35 +9,43 @@ 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")
 
 
-def audit_json(value: object) -> Markup:
-    """Serialize an audit payload for reading inside a ``<pre>`` text node.
+def _link_ids(escaped: str, anchors: dict) -> str:
+    """Anchor the row ids inside text that is already escaped.
 
-    Jinja's ``tojson`` guards a ``<script>`` context, so it escapes quotes and
-    angle brackets as ``\\uXXXX`` and leaves shell commands and non-ASCII
-    evidence unreadable. A text node only needs ``&``, ``<`` and ``>`` escaped,
-    hence ``quote=False`` — quotes carry no meaning outside an attribute value.
+    Running after the escape keeps this anchor the only markup in the result.
+    Only ids the document defines become links — an id with no row would point
+    at a missing anchor, and a ticket number like ``DEV-10339`` has the same
+    shape as a row id without being one.
     """
-    rendered = json.dumps(value, indent=2, ensure_ascii=False, sort_keys=True)
-    return Markup(html.escape(rendered, quote=False))
+    if not anchors:
+        return escaped
 
+    def swap(match: re.Match) -> str:
+        name = anchors.get(match.group(0))
+        return f'<a href="#{name}">{match.group(0)}</a>' if name else match.group(0)
 
-def inline_code(value: object) -> Markup:
+    return _ID_TOKEN.sub(swap, escaped)
+
+
+def inline_code(value: object, anchors: dict | None = None) -> Markup:
     """Convert paired backticks to ``<code>``, escaping everything else.
 
     Workers author report prose with Markdown conventions, so an identifier
-    arrives wrapped in backticks. ``escape`` also covers quotes, unlike
-    ``audit_json`` above, which is text-node only.
+    arrives wrapped in backticks. ``anchors`` links the row ids cited in the
+    prose, inside backticks and out.
     """
+    index = anchors or {}
     text = "" if value is None else str(value)
     out: list[str] = []
     cursor = 0
     for match in _INLINE_CODE.finditer(text):
-        out.append(str(escape(text[cursor:match.start()])))
-        out.append(f"<code>{escape(match.group(1))}</code>")
+        out.append(_link_ids(str(escape(text[cursor:match.start()])), index))
+        out.append(f"<code>{_link_ids(str(escape(match.group(1))), index)}</code>")
         cursor = match.end()
-    out.append(str(escape(text[cursor:])))
+    out.append(_link_ids(str(escape(text[cursor:])), index))
     return Markup("".join(out))
 
 
@@ -56,7 +62,7 @@ def _grouped_paragraphs(text: str) -> list[str]:
     ]
 
 
-def paragraphs(value: object) -> Markup:
+def paragraphs(value: object, anchors: dict | None = None) -> Markup:
     """Split prose into ``<p>`` blocks, converting inline code inside each.
 
     ``userNarrative`` prose arrives as one unbroken run of sentences, so the
@@ -64,30 +70,57 @@ def paragraphs(value: object) -> Markup:
     did supply blank lines keeps their own boundaries.
     """
     text = "" if value is None else str(value)
-    return Markup("".join(f"<p>{inline_code(block)}</p>" for block in _grouped_paragraphs(text)))
+    return Markup(
+        "".join(f"<p>{inline_code(block, anchors)}</p>" for block in _grouped_paragraphs(text))
+    )
 
 
-def evidence_refs(refs: object, index: object) -> Markup:
-    """Render evidence ids as anchors when the ledger defines them.
+def evidence_refs(refs: object, anchors: object) -> Markup:
+    """Render a citation list, anchoring the entries the document defines.
 
-    A citation whose id has no ledger row would link to a missing anchor, so it
-    stays text. No schema behind this filter constrains that text to an id —
-    most of it is prose citing a ``path:line``, so it takes ``inline_code`` like
-    every other prose cell. An anchor's own text is the id it links to and gets
-    no ``<code>`` wrapper.
+    The same index the prose links against decides here too — a citation and a
+    mid-sentence mention of the same id must land in the same place. No schema
+    behind this filter constrains an entry to an id: most of it is prose citing
+    a ``path:line``, which takes ``inline_code`` like every other prose cell.
     """
-    rows = index if isinstance(index, dict) else {}
+    index = anchors if isinstance(anchors, dict) else {}
     items = refs if isinstance(refs, (list, tuple)) else []
     out: list[str] = []
     for ref in items:
-        if str(ref) not in rows:
-            out.append(str(inline_code(ref)))
+        name = index.get(str(ref))
+        if name is None:
+            out.append(str(inline_code(ref, index)))
             continue
-        text = escape(str(ref))
-        out.append(f'<a href="#ev-{text}">{text}</a>')
+        out.append(f'<a href="#{name}">{escape(str(ref))}</a>')
     return Markup(", ".join(out))
 
 
+# Schema enums a reader has to decode. Each vocabulary is named so a value can
+# mean different things in different fields without one table flattening them.
+# The tables live in `templates/reports/html/i18n/<lang>.json` beside the rest
+# of the page's fixed strings — a label is chrome, not data, so it follows the
+# reader's language rather than the SSOT's. A value with no entry renders as
+# itself: a new enum member shows up raw rather than silently reading as
+# something it is not.
+def enum_label(value: object, vocabulary: str, chrome: dict) -> str:
+    """Render a schema enum as the words it stands for."""
+    raw = "" if value is None else str(value)
+    return (chrome.get("enum") or {}).get(vocabulary, {}).get(raw, raw)
+
+
+def enum_legend(vocabulary: str, chrome: dict) -> list[tuple[str, str]]:
+    """Pair each label with what it claims, for a legend beside the table.
+
+    A two-word label fits a table cell but cannot carry a definition, and a
+    reader meeting "Passes without proving" for the first time has nowhere to
+    look it up. Built from the same dictionary the cells render from, so a
+    legend cannot drift from the labels it explains.
+    """
+    labels = (chrome.get("enum") or {}).get(vocabulary, {})
+    hints = (chrome.get("enumHint") or {}).get(vocabulary, {})
+    return [(labels.get(value, value), hint) for value, hint in hints.items()]
+
+
 def code_evidence(rows: object) -> Markup:
     """Render ``currentCodeEvidence`` entries as ``path:line`` code spans."""
     items = rows if isinstance(rows, (list, tuple)) else []

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

@@ -11,15 +11,30 @@ class HtmlRunMeta:
     task_type: str
     seq: str
     source_report: str
+    # Wall-clock milliseconds for the run, or None when the team-state
+    # carried no timestamps to measure between.
+    elapsed_ms: int | None = None
 
 
 @dataclass(frozen=True)
 class VisualNode:
     id: str
     label: str
+    # Which column the figure puts this node in, and which fill it draws it
+    # with. Both are drawing instructions: `group` is often a path prefix and
+    # `status` is often a constant. The text table printed them raw under the
+    # headings "group" and "status", so in a single-root project every
+    # component read "src · stable" — a layout key and a literal, neither a
+    # fact about the project. Anything the reader should see goes in `note`.
     group: str
     status: str
     detail: str
+    # Files the node stands for. The figure's text alternative is the only
+    # place a reader can look them up, so they travel with the node.
+    paths: tuple[str, ...] = ()
+    # What this node is, in the reader's words. Empty when the figure has
+    # nothing to say beyond the label.
+    note: str = ""
 
 
 @dataclass(frozen=True)

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

@@ -3,14 +3,26 @@ from __future__ import annotations
 
 import hashlib
 import json
+import sys
 from pathlib import Path
 
 import okstra_vendor  # noqa: F401  # registers vendored dependency aliases
 from jinja2 import Environment, FileSystemLoader, StrictUndefined, select_autoescape
 
+from ..final_report_paths import translation_sidecar_path
 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 .filters import audit_json, code_evidence, evidence_refs, inline_code, paragraphs
+from .common import anchor_index
+from .filters import (
+    code_evidence,
+    enum_label,
+    enum_legend,
+    evidence_refs,
+    inline_code,
+    paragraphs,
+)
 from .models import HtmlRunMeta
 from .router import HtmlRenderError, resolve_html_route
 
@@ -30,6 +42,65 @@ def _templates_root(start: Path | None = None) -> Path:
     raise HtmlRenderError("could not locate templates/reports")
 
 
+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.
+    """
+    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"
+
+
+def _report_meta(data: dict, run_meta: HtmlRunMeta) -> dict[str, object]:
+    return {
+        "createdAt": data.get("header", {}).get("createdAt", ""),
+        "taskTitle": data.get("frontmatter", {}).get("title", ""),
+        "taskKey": run_meta.task_key,
+        "elapsed": _elapsed_text(run_meta.elapsed_ms),
+    }
+
+
+def _localize(data: dict, data_path: Path) -> tuple[dict, str]:
+    """Apply the translation sidecar for this report's language, if there is one.
+
+    The data.json is the English SSOT and is never rewritten — the sidecar is
+    read here and overlaid onto an in-memory copy, so only this HTML document
+    speaks the reader's language. A pointer the sidecar left untranslated
+    renders in English; that keeps a half-finished translation readable, and
+    the counts are printed because a silently half-empty sidecar otherwise
+    ships looking finished.
+    """
+    lang = str((data.get("meta") or {}).get("reportLanguage") or "en")
+    if lang == "en":
+        return data, lang
+    sidecar_file = translation_sidecar_path(data_path, lang)
+    if not sidecar_file.is_file():
+        sys.stdout.write(
+            f"note: no {lang} translation sidecar at {sidecar_file.name}; "
+            "rendering the English source\n"
+        )
+        return data, lang
+    payload = json.loads(sidecar_file.read_text(encoding="utf-8"))
+    strings = payload.get("strings")
+    if not isinstance(strings, dict):
+        raise HtmlRenderError(f"translation sidecar has no 'strings' object: {sidecar_file}")
+    localized, report = overlay(data, strings)
+    sys.stdout.write(
+        f"translated {report.applied} string(s) into {lang}"
+        f" ({len(report.untranslated)} left in English"
+        f", {len(report.unresolved)} unresolved)\n"
+    )
+    return localized, lang
+
+
 def _html_path(data_path: Path) -> Path:
     suffix = ".data.json"
     if not data_path.name.endswith(suffix):
@@ -50,21 +121,31 @@ def render_v2_html_view(
         raise HtmlRenderError("invalid v2 final-report data: " + "; ".join(errors[:5]))
     if not markdown_path.is_file():
         raise HtmlRenderError(f"v2 markdown sibling not found: {markdown_path}")
+    # Validate the SSOT, then localize — the sidecar carries presentation and
+    # has no say in whether the report is well-formed.
+    data, lang = _localize(data, data_path)
     route = resolve_html_route(run_meta.task_type)
     view = route.view_builder(data)
     root = _templates_root(templates_root)
     env = Environment(loader=FileSystemLoader(str(root)), autoescape=select_autoescape(("html",)), undefined=StrictUndefined)
     env.policies["json.dumps_kwargs"] = {"sort_keys": True, "ensure_ascii": False}
-    env.filters["audit_json"] = audit_json
+    # Binding the index here is what lets a template cite an id without
+    # threading the index through every macro and call site.
+    anchors = anchor_index(data)
+    chrome = load_dictionary(lang, HTML_DICTIONARY_REL)
+    env.globals["t"] = make_jinja_global(chrome)
     env.filters["code_evidence"] = code_evidence
-    env.filters["evidence_refs"] = evidence_refs
-    env.filters["inline_code"] = inline_code
-    env.filters["paragraphs"] = paragraphs
+    env.filters["enum_label"] = lambda value, vocabulary: enum_label(value, vocabulary, chrome)
+    env.filters["enum_legend"] = lambda vocabulary: enum_legend(vocabulary, chrome)
+    env.filters["evidence_refs"] = lambda refs: evidence_refs(refs, anchors)
+    env.filters["inline_code"] = lambda value: inline_code(value, anchors)
+    env.filters["paragraphs"] = lambda value: paragraphs(value, anchors)
     response_js = (root / "report.js").read_text(encoding="utf-8")
     base_js = (root / "html/assets/base.js").read_text(encoding="utf-8")
     context = {
         **view.context,
         "runMeta": run_meta,
+        "reportMeta": _report_meta(data, run_meta),
         "taskType": view.task_type,
         "dataSha256": _sha256(data_path),
         "markdownSha256": _sha256(markdown_path),

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

@@ -1,20 +1,31 @@
 """Human-first change-impact-analysis view model."""
 from __future__ import annotations
 
-from ..common import analysis_review_ids, audit_context, evidence_index
+from ..common import analysis_review_ids, evidence_index
 from ..models import HumanReportView, VisualEdge, VisualNode
 from ..visualizations import flow_figure
 
 
 def _impact_figure(change: dict):
     nodes = [
-        VisualNode(row["id"], row["target"], "affected", row["level"], row["impactKind"])
+        VisualNode(
+            row["id"],
+            row["target"],
+            "affected",
+            row["level"],
+            row["impactKind"],
+            note=f'Impact {row["level"]}',
+        )
         for row in change.get("impactItems", [])
     ]
     edges: list[VisualEdge] = []
     for index, row in enumerate(change.get("dependencyBlastRadius", []), start=1):
         target_id = f"BR-{index:03d}"
-        nodes.append(VisualNode(target_id, row["affectedTarget"], "downstream", "risk", row["direction"]))
+        nodes.append(
+            VisualNode(
+                target_id, row["affectedTarget"], "downstream", "risk", row["direction"], note="Downstream"
+            )
+        )
         edges.append(VisualEdge(row["sourceImpactId"], target_id, row["direction"], "impact"))
     return flow_figure(nodes=tuple(nodes), edges=tuple(edges), title="Change blast radius")
 
@@ -29,7 +40,6 @@ def build_change_impact_analysis_view(data: dict) -> HumanReportView:
         "blastRadiusFigure": figure,
         "analysisReviewIds": analysis_review_ids(data),
         "evidenceIndex": evidence_index(data),
-        "audit": audit_context(data),
     }
     return HumanReportView(
         task_type="change-impact-analysis",

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

@@ -1,14 +1,14 @@
 """Human-first error-analysis view model."""
 from __future__ import annotations
 
-from ..common import audit_context, evidence_index
+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"]
+        "symptom", "Observed failure", "effect", "risk", error["observableFailure"], note="Observed failure"
     )
     causes = tuple(
         VisualNode(
@@ -17,6 +17,7 @@ def _cause_figure(error: dict):
             "candidate",
             row["confidence"],
             row["disproveWith"],
+            note=f'Confidence {row["confidence"]}',
         )
         for row in error.get("causeCandidates", [])
     )
@@ -39,7 +40,6 @@ def build_error_analysis_view(data: dict) -> HumanReportView:
         "narrative": error["userNarrative"],
         "causeFigure": figure,
         "evidenceIndex": evidence_index(data),
-        "audit": audit_context(data),
     }
     return HumanReportView(
         "error-analysis",

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

@@ -1,16 +1,19 @@
 """Human-first feature-analysis view model."""
 from __future__ import annotations
 
-from ..common import analysis_review_ids, audit_context, evidence_index
+from ..common import analysis_review_ids, evidence_index
 from ..models import HumanReportView, VisualNode
 from ..visualizations import flow_figure
 
 
+_FLOW_KINDS = {"normal": "Normal path", "alternative": "Alternative path", "failure": "Failure path"}
+
+
 def _flow_nodes(feature: dict) -> tuple[VisualNode, ...]:
     return tuple(
         VisualNode(
             id=row["id"],
-            label=row["kind"].title(),
+            label=_FLOW_KINDS.get(row["kind"], row["kind"]),
             group=row["kind"],
             status="risk" if row["kind"] == "failure" else "stable",
             detail=" → ".join(step["action"] for step in row.get("steps", [])),
@@ -29,7 +32,6 @@ def build_feature_analysis_view(data: dict) -> HumanReportView:
         "flowFigure": figure,
         "analysisReviewIds": analysis_review_ids(data),
         "evidenceIndex": evidence_index(data),
-        "audit": audit_context(data),
     }
     return HumanReportView(
         task_type="feature-analysis",

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

@@ -1,7 +1,7 @@
 """Human-first final-verification view model."""
 from __future__ import annotations
 
-from ..common import audit_context, evidence_index
+from ..common import evidence_index
 from ..models import HumanReportView, VisualNode
 from ..visualizations import coverage_figure
 
@@ -14,6 +14,7 @@ def _coverage_nodes(final: dict) -> tuple[VisualNode, ...]:
             "requirement",
             row["status"],
             row["artifact"],
+            note=row["status"],
         )
         for row in final["validationEvidence"]
     )
@@ -24,11 +25,6 @@ def build_final_verification_view(data: dict) -> HumanReportView:
     figure = coverage_figure(
         rows=_coverage_nodes(final), title="Requirement verification coverage"
     )
-    audit = audit_context(data)
-    audit["deliveryEvidence"] = {
-        "sourceImplementation": final["sourceImplementationReport"],
-        "readonlyCommandLog": final["readonlyCommandLog"],
-    }
     context = {
         "humanSummary": data["humanSummary"],
         "verdict": data["verdictCard"],
@@ -37,7 +33,6 @@ def build_final_verification_view(data: dict) -> HumanReportView:
         "coverageFigure": figure,
         "releaseAllowed": data["verdictCard"]["verdictToken"] == "accepted",
         "evidenceIndex": evidence_index(data),
-        "audit": audit,
     }
     return HumanReportView(
         "final-verification",

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

@@ -1,11 +1,14 @@
 """Human-first implementation delivery view model."""
 from __future__ import annotations
 
-from ..common import audit_context, evidence_index
+from ..common import evidence_index
 from ..models import HumanReportView, VisualNode
 from ..visualizations import change_map_figure
 
 
+_FILE_ACTIONS = {"created": "Created", "modified": "Modified", "deleted": "Deleted"}
+
+
 def _change_nodes(implementation: dict) -> tuple[VisualNode, ...]:
     return tuple(
         VisualNode(
@@ -14,6 +17,7 @@ def _change_nodes(implementation: dict) -> tuple[VisualNode, ...]:
             row["planStep"],
             row["action"],
             row["lines"],
+            note=f'{_FILE_ACTIONS.get(row["action"], row["action"])} · plan step {row["planStep"]}',
         )
         for row in implementation["diffSummary"]["files"]
     )
@@ -24,20 +28,12 @@ def build_implementation_view(data: dict) -> HumanReportView:
     figure = change_map_figure(
         nodes=_change_nodes(implementation), title="Delivered change areas"
     )
-    audit = audit_context(data)
-    audit["deliveryEvidence"] = {
-        "commits": implementation["commitList"],
-        "rawDiffStat": implementation["diffSummary"]["rawStat"],
-        "verifiers": implementation["verifierResults"],
-        "validationCommands": implementation["validationEvidence"],
-    }
     context = {
         "humanSummary": data["humanSummary"],
         "implementation": implementation,
         "narrative": implementation["userNarrative"],
         "changeFigure": figure,
         "evidenceIndex": evidence_index(data),
-        "audit": audit,
     }
     return HumanReportView(
         "implementation",