okstra 0.170.3 → 0.172.0

package/runtime/python/okstra_ctl/cmux.py

@@ -30,17 +30,26 @@ LOGIN_SHELL_TIMEOUT_SECONDS = 15
 # re-enters cmux's own agent wrapper instead of the real CLI.
 SHIM_DIR_MARKER = "cmux-cli-shims"
 
-# Workers fill two columns and then grow downward. A third column would cost
-# width, and width is the dimension a horizontal split cannot give back.
-GRID_COLUMNS = 2
-
-# Measured against a Claude Code worker: 67 columns renders losslessly, 33 drops
-# content off the right edge. Below this floor okstra stacks a tab instead of
-# splitting, because an unreadable pane costs the lead its view of that worker.
-WORKER_MIN_COLUMNS = 60
-
-# What the lead keeps for itself once workers arrive.
-LEAD_TARGET_COLUMNS = 80
+# The workspace is split in fifths: two for the lead, three for the workers.
+# Every worker lands in that one column and the column divides downward, so all
+# workers hold the same width and only one border — the lead's — is ever
+# computed. Splitting sideways instead would make each worker's width a
+# function of how many rounds preceded it.
+LEAD_SHARE_WITH_WORKERS = 2 / 5
+
+# Three fifths is what a worker needs to be worth watching: measured against a
+# Claude Code worker, 67 columns renders losslessly and 33 drops content off the
+# right edge, and three fifths clears 67 on any window wide enough to hold two
+# panes at all.
+#
+# With no workers on screen the lead has nothing to share with, so it takes the
+# whole workspace back rather than sitting at its working width.
+LEAD_SHARE_ALONE = 1.0
+
+# A floor for the dimension the worker column actually divides. A pane
+# this short still shows a command and its first lines of output; below it the
+# pane stops being a window onto the worker and the next one stacks as a tab.
+WORKER_MIN_ROWS = 20
 
 # Sidebar entries are keyed by source so tools do not overwrite each other's.
 SIDEBAR_SOURCE = "okstra"
@@ -151,6 +160,7 @@ class PaneGeometry:
     x: int
     y: int
     cell_width_points: int
+    width_points: float = 0.0
     ref: str = ""
     selected_surface_id: str = ""
 
@@ -169,10 +179,16 @@ def plan_worker_placement(
     *,
     lead_pane_id: str,
     owned_surface_ids: Collection[str],
-    min_columns: int,
+    min_rows: int,
 ) -> Placement:
     """Pick the next worker slot from the workspace's current geometry.
 
+    One column for every worker: the first split takes it off the lead, and each
+    one after that divides the column downward. Width is therefore decided once,
+    by where the lead's border sits, and every worker inherits it — nothing here
+    computes a width, and no worker's width depends on how many rounds ran
+    before it.
+
     Stateless by design: okstra records surface UUIDs, never a layout, so a
     resumed or crashed run cannot carry a layout model that no longer matches
     the screen. Every dispatch re-reads the panes and derives the next slot.
@@ -180,9 +196,9 @@ def plan_worker_placement(
     Those same UUIDs say which panes okstra may place into. A workspace also
     holds panes okstra never opened — another agent session, a shell the user
     keeps around — and "not the lead" does not make a pane a worker slot. Taken
-    as one, a stranger's pane is split or, when it is too narrow to split,
-    stacked into: the workers land as background tabs in someone else's window,
-    so nothing appears on screen and that window grows tabs it did not ask for.
+    as one, a stranger's pane is split or stacked into: the workers land as
+    background tabs in someone else's window, so nothing appears on screen and
+    that window grows tabs it did not ask for.
     """
     workers = [
         pane
@@ -192,14 +208,48 @@ def plan_worker_placement(
     ]
     if not workers:
         return Placement(pane_id=lead_pane_id, direction="right", stack_as_tab=False)
+    return _extend_the_worker_column(workers, min_rows=min_rows)
 
-    columns = _panes_by_column(workers)
-    if len(columns) < GRID_COLUMNS:
-        return _widen_the_grid(workers, min_columns=min_columns)
-    return _extend_the_shortest_column(columns)
+
+def lead_target_width(
+    panes: Sequence[PaneGeometry],
+    *,
+    lead_pane_id: str,
+    owned_surface_ids: Collection[str],
+    container_width_points: float,
+) -> float:
+    """How wide the lead should be, in the points `pixel_frame` reports.
+
+    Two fifths while workers are on screen, all of it when they are gone. The
+    share is taken of what okstra may actually place into, not of the window:
+    a workspace can hold panes okstra never opened, and handing the lead the
+    whole container would shove those off their own width. Their width is
+    subtracted first and the share applies to the remainder.
+
+    Deriving the target from the container rather than from a fixed column count
+    is what keeps the split honest at any window size — a hardcoded 80 columns
+    is two fifths of one particular display and an arbitrary slice of every
+    other.
+    """
+    strangers = sum(
+        pane.width_points
+        for pane in panes
+        if pane.pane_id != lead_pane_id
+        and not _holds_an_okstra_surface(pane, owned_surface_ids)
+    )
+    usable = container_width_points - strangers
+    if usable <= 0:
+        return 0.0
+    workers_on_screen = any(
+        pane.pane_id != lead_pane_id
+        and _holds_an_okstra_surface(pane, owned_surface_ids)
+        for pane in panes
+    )
+    share = LEAD_SHARE_WITH_WORKERS if workers_on_screen else LEAD_SHARE_ALONE
+    return usable * share
 
 
-def lead_resize_points(lead: PaneGeometry, *, target_columns: int) -> int:
+def lead_resize_points(lead: PaneGeometry, *, target_width_points: float) -> int:
     """How far to move the lead's right border, in the points `pane.resize` takes.
 
     Signed: positive when the lead is too wide and the border comes in, negative
@@ -208,14 +258,14 @@ def lead_resize_points(lead: PaneGeometry, *, target_columns: int) -> int:
     Both directions are needed. A split halves whatever pane it lands on, and
     the first worker of every round lands on the lead — so a rule that only ever
     shrinks leaves that half permanent, and the round after it takes half of
-    what is left. Measured on this display: 215 columns becomes 80, then 40,
-    then 20, until neither the lead nor its workers can be read.
+    what is left. Measured on this display: 215 columns becomes 107, then 53,
+    then 26, until neither the lead nor its workers can be read.
 
-    The API's `amount` is points, not cells — measured at this pane's own
-    `cell_width_points`, so passing a column count moves the border by an eighth
-    of the intent on a typical display.
+    Measured in the same points `pixel_frame` reports, so no cell-size
+    conversion happens here at all. A column count would need one, and would
+    round the target to a whole cell before the border ever moved.
     """
-    return (lead.columns - target_columns) * lead.cell_width_points
+    return round(lead.width_points - target_width_points)
 
 
 def _holds_an_okstra_surface(
@@ -229,31 +279,22 @@ def _holds_an_okstra_surface(
     return any(surface_id in owned_surface_ids for surface_id in pane.surface_ids)
 
 
-def _widen_the_grid(
-    workers: Sequence[PaneGeometry], *, min_columns: int
-) -> Placement:
-    rightmost = max(workers, key=lambda pane: pane.x)
-    if rightmost.columns // GRID_COLUMNS >= min_columns:
-        return Placement(pane_id=rightmost.pane_id, direction="right", stack_as_tab=False)
-    roomiest = min(workers, key=lambda pane: (len(pane.surface_ids), pane.x))
-    return Placement(pane_id=roomiest.pane_id, direction="", stack_as_tab=True)
-
-
-def _extend_the_shortest_column(
-    columns: dict[int, list[PaneGeometry]]
+def _extend_the_worker_column(
+    workers: Sequence[PaneGeometry], *, min_rows: int
 ) -> Placement:
-    shortest = min(columns.values(), key=lambda group: (len(group), group[0].x))
-    bottom = max(shortest, key=lambda pane: pane.y)
-    return Placement(pane_id=bottom.pane_id, direction="down", stack_as_tab=False)
+    """Divide the bottom worker, or stack when the halves would be unreadable.
 
-
-def _panes_by_column(
-    workers: Sequence[PaneGeometry],
-) -> dict[int, list[PaneGeometry]]:
-    columns: dict[int, list[PaneGeometry]] = {}
-    for pane in workers:
-        columns.setdefault(pane.x, []).append(pane)
-    return columns
+    A split halves the pane it lands on, so the bottom pane's own height decides
+    whether the column can take another worker at all. Once it cannot, further
+    workers stack as tabs into the pane holding the fewest — a background tab is
+    worse than a visible pane, but better than two panes too short to show a
+    command and its first lines of output.
+    """
+    bottom = max(workers, key=lambda pane: pane.y)
+    if bottom.rows // 2 >= min_rows:
+        return Placement(pane_id=bottom.pane_id, direction="down", stack_as_tab=False)
+    roomiest = min(workers, key=lambda pane: (len(pane.surface_ids), pane.y))
+    return Placement(pane_id=roomiest.pane_id, direction="", stack_as_tab=True)
 
 
 def shim_free_login_path() -> str:
@@ -298,8 +339,7 @@ def worker_command_line(
 
 
 def list_panes(workspace: str) -> list[PaneGeometry]:
-    payload = rpc("pane.list", {"workspace_id": workspace})
-    return [_pane_geometry(entry) for entry in payload.get("panes", [])]
+    return _panes_from(_pane_list_payload(workspace))
 
 
 def spawn_worker_surface(
@@ -326,13 +366,13 @@ def spawn_worker_surface(
         panes,
         lead_pane_id=lead.pane_id,
         owned_surface_ids=owned_surface_ids,
-        min_columns=WORKER_MIN_COLUMNS,
+        min_rows=WORKER_MIN_ROWS,
     )
     target = _pane_by_id(panes, placement.pane_id)
     surface_uuid = _open_worker_surface(workspace, placement, target)
     run_cmux(["rename-tab", "--surface", surface_uuid, "--title", title])
     _exec_worker(surface_uuid, cwd=cwd, command=command)
-    _size_lead_pane(workspace)
+    _size_lead_pane(workspace, (*owned_surface_ids, surface_uuid))
     return surface_uuid
 
 
@@ -358,11 +398,17 @@ def restore_lead_width() -> None:
     holds a run manifest rather than the workspace UUID that `pane.resize`
     needs. An unresolvable workspace means cmux is gone or was never there, and
     there is no pane left to size.
+
+    Owning nothing is the point of the empty ledger. Teardown has just closed
+    every surface it opened, so no pane on screen is okstra's but the lead's —
+    which is what makes the lead's share the whole workspace. A pane teardown
+    failed to close counts as a stranger's and keeps its width, which is the
+    safe way to be wrong here.
     """
     workspace = resolve_lead_workspace()
     if not workspace:
         return
-    _size_lead_pane(workspace)
+    _size_lead_pane(workspace, ())
 
 
 def capture_surface(surface_uuid: str, *, last_lines: int = 200) -> str:
@@ -557,8 +603,12 @@ def _exec_worker(surface_uuid: str, *, cwd: Path, command: Sequence[str]) -> Non
         raise RuntimeError(started.stderr.strip() or "cmux could not start the worker")
 
 
-def _size_lead_pane(workspace: str) -> None:
-    """Put the lead back on its target width, leaving the rest to the workers.
+def _size_lead_pane(workspace: str, owned_surface_ids: Collection[str]) -> None:
+    """Move the lead's border to its share of the workspace.
+
+    This is the only border okstra places. Workers divide their column downward
+    and therefore all inherit whatever is left of it, so placing this one border
+    sizes every pane on screen.
 
     Which pane carries the request follows from what `pane.resize` does: it
     moves the named pane's own border in the direction given. The lead can push
@@ -568,11 +618,26 @@ def _size_lead_pane(workspace: str) -> None:
     and widening is the lead's.
 
     Run after every worker opens rather than once per round: the split that just
-    happened is what knocked the lead off its width, and no other event does.
+    happened is what knocked the lead off its share, and no other event does.
     """
-    panes = list_panes(workspace)
+    payload = _pane_list_payload(workspace)
+    container_width = _container_width_points(payload)
+    if container_width <= 0:
+        # Without the frame the shares are taken of, there is no target to move
+        # toward — and a guessed one would move the border to a wrong place
+        # rather than leave it where the user last saw it.
+        return
+    panes = _panes_from(payload)
     lead = _lead_pane(panes)
-    offset = lead_resize_points(lead, target_columns=LEAD_TARGET_COLUMNS)
+    offset = lead_resize_points(
+        lead,
+        target_width_points=lead_target_width(
+            panes,
+            lead_pane_id=lead.pane_id,
+            owned_surface_ids=owned_surface_ids,
+            container_width_points=container_width,
+        ),
+    )
     if offset == 0:
         return
     neighbours = [pane for pane in panes if pane.x > lead.x]
@@ -609,6 +674,25 @@ def _pane_by_id(panes: Sequence[PaneGeometry], pane_id: str) -> PaneGeometry:
     raise RuntimeError(f"cmux pane {pane_id} disappeared while placing a worker")
 
 
+def _pane_list_payload(workspace: str) -> dict[str, Any]:
+    return rpc("pane.list", {"workspace_id": workspace})
+
+
+def _panes_from(payload: dict[str, Any]) -> list[PaneGeometry]:
+    return [_pane_geometry(entry) for entry in payload.get("panes", [])]
+
+
+def _container_width_points(payload: dict[str, Any]) -> float:
+    """The workspace's own width, which every share here is taken of.
+
+    Reported once per `pane.list` reply rather than per pane, because it is the
+    frame the panes are laid out inside — summing the panes would instead give
+    whatever they currently happen to occupy.
+    """
+    frame = payload.get("container_frame") or {}
+    return float(frame.get("width") or 0)
+
+
 def _pane_geometry(entry: dict[str, Any]) -> PaneGeometry:
     frame = entry.get("pixel_frame") or {}
     return PaneGeometry(
@@ -619,6 +703,7 @@ def _pane_geometry(entry: dict[str, Any]) -> PaneGeometry:
         x=int(frame.get("x", 0)),
         y=int(frame.get("y", 0)),
         cell_width_points=int(entry.get("cell_width_points", 0)),
+        width_points=float(frame.get("width") or 0),
         ref=str(entry.get("ref", "")),
         selected_surface_id=str(entry.get("selected_surface_id", "")),
     )

package/runtime/python/okstra_ctl/lead_events.py

@@ -2,9 +2,13 @@
 from __future__ import annotations
 
 import json
-from dataclasses import dataclass, field
+import re
+from contextlib import contextmanager
+from dataclasses import dataclass, field, replace
 from pathlib import Path
-from typing import Any, Mapping
+from typing import Any, Iterator, Mapping
+
+from okstra_ctl.run_context import dir_flock
 
 
 REQUIRED_FIELDS = (
@@ -72,9 +76,48 @@ class LeadEvent:
 
 def append_lead_event(path: Path, event: LeadEvent) -> None:
     """Append one lead event as compact JSONL, creating parent directories."""
+    with _event_log_lock(path):
+        _append_unlocked(path, event)
+
+
+@contextmanager
+def _event_log_lock(path: Path) -> Iterator[None]:
+    with dir_flock(path.parent, f".{path.name}.lock"):
+        yield
+
+
+def _append_unlocked(path: Path, event: LeadEvent) -> None:
     path.parent.mkdir(parents=True, exist_ok=True)
-    with path.open("a", encoding="utf-8") as f:
-        f.write(_event_json(event) + "\n")
+    with path.open("a", encoding="utf-8") as handle:
+        handle.write(_event_json(event) + "\n")
+
+
+def _next_activity_id(events: list[LeadEvent]) -> str:
+    numbers = [
+        int(match.group(1))
+        for event in events
+        if event.event_type == "activity"
+        for match in [
+            re.fullmatch(
+                r"A-(\d{3,})", str(event.details.get("activityId", ""))
+            )
+        ]
+        if match is not None
+    ]
+    return f"A-{max(numbers, default=0) + 1:03d}"
+
+
+def append_activity_event(path: Path, event: LeadEvent) -> LeadEvent:
+    """Assign the next activity ID and append the event under one lock."""
+    if event.event_type != "activity":
+        raise ValueError("activity append requires eventType=activity")
+    with _event_log_lock(path):
+        details = dict(event.details)
+        details["activityVersion"] = 1
+        details["activityId"] = _next_activity_id(read_lead_events(path))
+        stored = replace(event, details=details)
+        _append_unlocked(path, stored)
+    return stored
 
 
 def read_lead_events(path: Path) -> list[LeadEvent]:

package/runtime/python/okstra_ctl/render.py

@@ -1501,7 +1501,7 @@ def _build_convergence_block(ctx: dict) -> dict:
       (forces `verificationMode` to "full-reanalysis"), False otherwise
     - `planBodyVerification` is implementation-planning specific; the key is
       always emitted (dead-letter on other phases) so the schema stays stable.
-      Its `selfFixMaxRounds` default 3 bounds the report-writer self-fix loop
+      Its `selfFixMaxRounds` default 1 bounds the report-writer self-fix loop
       that runs before a planner-fixable defect is promoted to the user.
 
     ctx knobs honoured:
@@ -1557,7 +1557,7 @@ def _build_convergence_block(ctx: dict) -> dict:
         "planBodyVerification": {
             "enabled": plan_verify_enabled,
             "maxRounds": 1,
-            "selfFixMaxRounds": 3,
+            "selfFixMaxRounds": 1,
             "gating": True,
         },
     }
@@ -1565,8 +1565,9 @@ def _build_convergence_block(ctx: dict) -> dict:
 
 def render_run_manifest(run_manifest_path: str, ctx: dict) -> None:
     run_manifest_file = Path(run_manifest_path)
+    run_manifest_exists = run_manifest_file.is_file()
     existing_run_manifest = {}
-    if run_manifest_file.is_file():
+    if run_manifest_exists:
         try:
             loaded_run_manifest = json.loads(
                 run_manifest_file.read_text(encoding="utf-8")
@@ -1767,6 +1768,13 @@ def render_run_manifest(run_manifest_path: str, ctx: dict) -> None:
         payload["analysisScopeConfirmation"] = scope_confirmation
     if ctx.get("FIX_CYCLE_ID"):
         payload["fixCycleId"] = ctx["FIX_CYCLE_ID"]
+    if ctx.get("TASK_TYPE") == "implementation-planning":
+        if not run_manifest_exists:
+            payload["activityContractVersion"] = 1
+        elif "activityContractVersion" in existing_run_manifest:
+            payload["activityContractVersion"] = existing_run_manifest[
+                "activityContractVersion"
+            ]
     payload["reportContracts"] = (
         ["implementation-design-prep-v1"]
         if ctx.get("TASK_TYPE") == "implementation-planning"

package/runtime/python/okstra_ctl/report_finalize.py

@@ -1,10 +1,10 @@
 """Phase 7 report post-processing — the single reference point.
 
 Phase 7 turns a Phase 6 final-report data.json into shippable artifacts through
-five ordered steps: English-SSOT verification, usage substitution, html view
-rendering, follow-up task spawning, and run validation. The order is
-load-bearing — rendering before substitution ships `--` token cells, and
-validating before rendering trips the report-views contract.
+six ordered steps: activity projection, English-SSOT verification, usage
+substitution, html view rendering, follow-up task spawning, and run validation.
+The order is load-bearing — rendering before substitution ships `--` token
+cells, and validating before rendering trips the report-views contract.
 
 The translation sidecar is NOT one of these steps. `render-views` overlays it,
 so a non-English run dispatches the translator before this sequence starts —
@@ -25,11 +25,13 @@ from dataclasses import dataclass
 from pathlib import Path
 from typing import Any, Callable, Mapping, Sequence
 
+from .agent_activity import ActivityProjectionError, project_agent_activity
+from .dispatch_state import DispatchError, link_agent_dispatch_result
 from .final_report_paths import final_report_data_path, final_report_markdown_path
 from .paths import task_dir, task_manifest_file
-from .dispatch_state import DispatchError, link_agent_dispatch_result
 
 
+STEP_PROJECT_ACTIVITY = "project-activity"
 STEP_CHECK_SOURCE = "check-source"
 STEP_TOKEN_USAGE = "token-usage"
 STEP_RENDER_VIEWS = "render-views"
@@ -37,6 +39,7 @@ STEP_SPAWN_FOLLOWUPS = "spawn-followups"
 STEP_VALIDATE_RUN = "validate-run"
 
 STEP_ORDER = (
+    STEP_PROJECT_ACTIVITY,
     # First, because everything after it derives from the data.json: rendering
     # a Korean SSOT into English chrome, spawning follow-ups from it, and
     # validating it all succeed on a record the next phase cannot read.
@@ -235,6 +238,16 @@ def build_commands(ctx: FinalizeContext) -> list[tuple[str, list[str]]]:
     """Assemble the ordered Phase 7 argv list. Order is contractual."""
     markdown_path = ctx.markdown_path
     return [
+        (
+            STEP_PROJECT_ACTIVITY,
+            [
+                "<in-process>",
+                "agent-activity",
+                "project",
+                str(ctx.manifest_path),
+                str(ctx.data_path),
+            ],
+        ),
         (
             STEP_CHECK_SOURCE,
             [
@@ -349,8 +362,8 @@ def run_finalize(
 
     ``only`` restricts the run to the named steps, preserving contractual
     order. The last step (`validate-run`) is the one that usually fails, and
-    re-running the whole sequence to retry it repeats three idempotent steps
-    at full token and wall-clock cost.
+    re-running the whole sequence to retry it repeats every preceding idempotent
+    step at full token and wall-clock cost.
     """
     steps: list[dict[str, Any]] = []
     try:
@@ -372,6 +385,29 @@ def run_finalize(
     for name, command in commands:
         if before_step is not None:
             before_step(name)
+        if name == STEP_PROJECT_ACTIVITY:
+            try:
+                rows = project_agent_activity(
+                    ctx.project_root,
+                    ctx.manifest_path,
+                    ctx.data_path,
+                )
+            except ActivityProjectionError as exc:
+                result = subprocess.CompletedProcess(
+                    command,
+                    1,
+                    "",
+                    str(exc),
+                )
+            else:
+                result = subprocess.CompletedProcess(
+                    command,
+                    0,
+                    json.dumps({"count": len(rows)}),
+                    "",
+                )
+        else:
+            result = None
         if name == STEP_VALIDATE_RUN:
             try:
                 _link_lead_result_for_validation(ctx)
@@ -381,12 +417,13 @@ def run_finalize(
                     "reason": f"lead result linkage failed: {exc}",
                     "steps": steps,
                 }
-        result = subprocess.run(
-            command,
-            cwd=ctx.project_root,
-            text=True,
-            capture_output=True,
-        )
+        if result is None:
+            result = subprocess.run(
+                command,
+                cwd=ctx.project_root,
+                text=True,
+                capture_output=True,
+            )
         steps.append(step_payload(name, command, result))
         if result.returncode != 0:
             return {
@@ -489,7 +526,7 @@ def _parser() -> argparse.ArgumentParser:
         help=(
             "run only these steps (repeatable, contractual order preserved). "
             "Use `--only validate-run` to retry the step that usually fails "
-            "without repeating the three idempotent ones before it."
+            "without repeating the preceding idempotent steps."
         ),
     )
     return parser

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

@@ -85,6 +85,7 @@ def _own_section_ids(data: dict, omitted_fields: tuple[str, ...] = ()) -> set[st
 
     found: set[str] = set()
     _collect_ids(data.get("clarificationItems", []), found)
+    _collect_ids(data.get("agentActivity", []), found)
     property_name = TASK_TYPE_DATA_PROPERTY.get(data.get("header", {}).get("taskType", ""))
     if property_name:
         block = data.get(property_name, {})
@@ -120,9 +121,10 @@ def evidence_index(data: dict) -> dict[str, object]:
 
 def _collect_ids(value: object, found: set[str]) -> None:
     if isinstance(value, dict):
-        row_id = value.get("id")
-        if isinstance(row_id, str) and row_id:
-            found.add(row_id)
+        for key in ("id", "activityId"):
+            row_id = value.get(key)
+            if isinstance(row_id, str) and row_id:
+                found.add(row_id)
         for nested in value.values():
             _collect_ids(nested, found)
     elif isinstance(value, list):

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

@@ -91,6 +91,16 @@ def build_implementation_planning_view(data: dict) -> HumanReportView:
     planning = data["implementationPlanning"]
     figure = _stage_figure(planning)
     approval = plan_approval_state(data)
+    activities = tuple(
+        row for row in data.get("agentActivity", []) if isinstance(row, dict)
+    )
+    decision_cards = tuple(
+        row
+        for row in data.get("clarificationItems", [])
+        if isinstance(row, dict)
+        and row.get("blocks") == "approval"
+        and isinstance(row.get("approvalContext"), dict)
+    )
     context = {
         "humanSummary": data["humanSummary"],
         "planning": planning,
@@ -100,9 +110,15 @@ def build_implementation_planning_view(data: dict) -> HumanReportView:
         "openDecisions": [
             row
             for row in data.get("clarificationItems", [])
-            if row.get("blocks") == "approval"
+            if isinstance(row, dict)
+            and row.get("blocks") == "approval"
             and row.get("status") in {"open", "answered"}
         ],
+        "agentActivities": activities,
+        "activityById": {
+            row["activityId"]: row for row in activities if row.get("activityId")
+        },
+        "decisionCards": decision_cards,
         "evidenceIndex": evidence_index(data),
     }
     return HumanReportView(