okstra 0.201.2 → 0.202.0

package/runtime/python/okstra_ctl/manager_store.py

@@ -96,6 +96,63 @@ def load_manager(home: Path, manager_id: str) -> dict:
     return _read_json(path)
 
 
+def _task_manifest_paths(home: Path, manager_id: str) -> list[Path]:
+    return sorted(manager_root(home, manager_id).glob("task-groups/*/*/manifest.json"))
+
+
+def list_managers(home: Path) -> list[dict]:
+    """이 홈의 manager 를 id 순으로, 소속 프로젝트 수와 manager task 수와 함께 돌려준다."""
+    base = Path(home) / "managers"
+    if not base.is_dir():
+        return []
+    items: list[dict] = []
+    for path in sorted(base.glob("*/manager.json")):
+        manager = _read_json(path)
+        manager_id = str(manager.get("managerId") or path.parent.name)
+        items.append(
+            {
+                "managerId": manager_id,
+                "createdAt": str(manager.get("createdAt") or ""),
+                "projectCount": len(_load_projects(home, manager_id).get("projects", [])),
+                "taskCount": len(_task_manifest_paths(home, manager_id)),
+            }
+        )
+    return items
+
+
+def list_projects(home: Path, manager_id: str) -> list[dict]:
+    """manager 에 등록된 프로젝트를 등록 파일(projects.json) 순서 그대로 돌려준다."""
+    load_manager(home, manager_id)
+    return [
+        project
+        for project in _load_projects(home, manager_id).get("projects", [])
+        if isinstance(project, dict)
+    ]
+
+
+def list_tasks(home: Path, manager_id: str) -> list[dict]:
+    """manager task 를 task-group, task-id 순으로 하위 task 수와 함께 돌려준다.
+
+    디렉터리 이름은 slug 라 원래 입력값과 다를 수 있으므로 식별자는 manifest 에서 읽는다.
+    """
+    load_manager(home, manager_id)
+    items: list[dict] = []
+    for path in _task_manifest_paths(home, manager_id):
+        manifest = _read_json(path)
+        children = _read_json_default(path.parent / "children.json", {"children": []})
+        items.append(
+            {
+                "taskGroup": str(manifest.get("taskGroup") or ""),
+                "taskId": str(manifest.get("taskId") or ""),
+                "objective": str(manifest.get("objective") or ""),
+                "progressMode": str(manifest.get("progressMode") or ""),
+                "createdAt": str(manifest.get("createdAt") or ""),
+                "childCount": len(children.get("children", [])),
+            }
+        )
+    return sorted(items, key=lambda item: (item["taskGroup"], item["taskId"]))
+
+
 def discover_projects(home: Path) -> list[dict]:
     base = Path(home) / "projects"
     if not base.is_dir():
@@ -174,6 +231,17 @@ def create_task_group(home: Path, manager_id: str, task_group: str, *, now: str
     return {"managerId": manager_id, "taskGroup": task_group, "createdAt": now or _now_iso()}
 
 
+def _merge_manifest(existing: dict, requested: dict) -> None:
+    """이미 있는 manager task 의 manifest 값을 `new task` 가 바꾸지 못하게 한다."""
+    for key, value in requested.items():
+        if value is None or value == "" or existing.get(key) == value:
+            continue
+        raise ManagerError(
+            f"manager task already exists with {key}={existing.get(key)!r}; "
+            f"refusing to change it to {value!r}"
+        )
+
+
 def create_task(
     home: Path,
     manager_id: str,
@@ -183,32 +251,56 @@ def create_task(
     *,
     objective: str = "",
     common_brief_path: str = "",
-    progress_mode: str = "manual",
+    progress_mode: str | None = None,
     now: str | None = None,
 ) -> dict:
+    """manager task 를 만들거나, 이미 있으면 새 하위 task 만 덧붙인다.
+
+    다시 실행해도 기존 하위 task 의 assignment·launch 상태는 지우지 않는다.
+    """
+    load_manager(home, manager_id)
     projects = _load_projects(home, manager_id)
     when = now or _now_iso()
-    manifest = {
-        "managerId": manager_id,
-        "taskGroup": task_group,
-        "taskId": task_id,
-        "progressMode": progress_mode,
-        "commonBriefPath": common_brief_path,
-        "objective": objective,
-        "createdAt": when,
-    }
-    children = []
+    manifest_path = task_manifest_path(home, manager_id, task_group, task_id)
+    existing = manifest_path.is_file()
+    if existing:
+        manifest = _read_json(manifest_path)
+        _merge_manifest(
+            manifest,
+            {
+                "objective": objective,
+                "commonBriefPath": common_brief_path,
+                "progressMode": progress_mode,
+            },
+        )
+    else:
+        manifest = {
+            "managerId": manager_id,
+            "taskGroup": task_group,
+            "taskId": task_id,
+            "progressMode": progress_mode or "manual",
+            "commonBriefPath": common_brief_path,
+            "objective": objective,
+            "createdAt": when,
+        }
+    children = _load_children(home, manager_id, task_group, task_id)
+    known_keys = {child.get("taskKey") for child in children["children"] if isinstance(child, dict)}
+    added = []
     for spec in child_specs:
         project_id = str(spec.get("projectId") or "")
         child_task_id = str(spec.get("taskId") or task_id)
         if _project_entry(projects, project_id) is None:
             raise ManagerError(f"unknown project membership: {project_id}")
-        children.append(
+        task_key = _child_task_key(project_id, task_group, child_task_id)
+        if task_key in known_keys:
+            continue
+        known_keys.add(task_key)
+        added.append(
             {
                 "projectId": project_id,
                 "taskGroup": task_group,
                 "taskId": child_task_id,
-                "taskKey": f"{project_id}:{task_group}:{child_task_id}",
+                "taskKey": task_key,
                 "role": "",
                 "tags": [],
                 "assignment": "",
@@ -219,14 +311,19 @@ def create_task(
                 },
             }
         )
-    payload = {"manifest": manifest, "children": {"children": children}}
-    _write_json(task_manifest_path(home, manager_id, task_group, task_id), manifest)
-    _write_json(children_json_path(home, manager_id, task_group, task_id), payload["children"])
+    children["children"].extend(added)
+    if not existing:
+        _write_json(manifest_path, manifest)
+    _write_json(children_json_path(home, manager_id, task_group, task_id), children)
     append_jsonl(
         events_jsonl_path(home, manager_id, task_group, task_id),
-        {"event": "task-created", "createdAt": when},
+        {
+            "event": "task-children-added" if existing else "task-created",
+            "createdAt": when,
+            "taskKeys": [child["taskKey"] for child in added],
+        },
     )
-    return payload
+    return {"manifest": manifest, "children": children}
 
 
 def _load_children(home: Path, manager_id: str, task_group: str, task_id: str) -> dict:
@@ -286,6 +383,7 @@ def assign_child(
     assignment: str,
     child_task_id: str | None = None,
 ) -> dict:
+    _read_json(task_manifest_path(home, manager_id, task_group, task_id))
     payload = _load_children(home, manager_id, task_group, task_id)
     child = _select_child_for_assignment(payload["children"], project_id, task_group, child_task_id)
     child["role"] = role
@@ -311,6 +409,11 @@ def append_directive(
         raise ManagerError("scope must be shared or project")
     if scope == "project" and not project_id:
         raise ManagerError("project directive requires project-id")
+    _read_json(task_manifest_path(home, manager_id, task_group, task_id))
+    if scope == "project":
+        children = _load_children(home, manager_id, task_group, task_id)["children"]
+        if not any(isinstance(child, dict) and child.get("projectId") == project_id for child in children):
+            raise ManagerError(f"project directive target has no child in this task: {project_id}")
     row = {
         "scope": scope,
         "projectId": project_id if scope == "project" else "",

package/runtime/python/okstra_ctl/manager_sync.py

@@ -6,6 +6,7 @@ from pathlib import Path
 from okstra_project import TASKS_RELATIVE, StateError, parse_task_key, read_task_catalog, read_task_manifest, slugify
 
 from . import next_phase
+from .next_phase import STATUS_BLOCKED, STATUS_TERMINAL
 from .manager_paths import children_json_path, projects_json_path, snapshots_json_path, task_manifest_path
 from .manager_store import _now_iso, _read_json, _read_json_default, _write_json
 
@@ -89,6 +90,7 @@ def _snapshot_child(project_root: Path, child: dict) -> dict:
             workflow.get("nextRecommendedPhase")
         ),
         "latestRunStatus": str(manifest.get("latestRunStatus") or manifest.get("currentStatus") or ""),
+        "workStatus": str(manifest.get("workStatus") or ""),
         "latestReportRecordPath": str(manifest.get("latestReportRecordPath") or ""),
         "finalVerdict": str(outcome.get("finalVerdict") or ""),
         "crossProjectDependencies": _list_field(outcome, "crossProjectDependencies"),
@@ -125,6 +127,34 @@ def sync_task(home: Path, manager_id: str, task_group: str, task_id: str, *, now
     return payload
 
 
+# 사용자가 `okstra set-work-status` 로 적은 값이 파생 포인터보다 우선한다.
+# 그룹 큐(group_context.catalog_progress)와 같은 순서다. `latestRunStatus` 는
+# phase 한 번의 실행 결과(`completed` / `contract-violated` / `in-progress` …)라
+# task 가 끝났는지 말해 주지 않으므로 요약 분류에 쓰지 않는다.
+_WORK_STATUS_BUCKETS = {
+    "done": "done",
+    "blocked": "blocked",
+    "in-progress": "running",
+    "todo": "planned",
+}
+_POINTER_STATUS_BUCKETS = {
+    STATUS_TERMINAL: "done",
+    STATUS_BLOCKED: "blocked",
+}
+
+
+def summary_bucket(row: dict) -> str:
+    """스냅샷이 있는 하위 task 한 줄을 요약 칸 하나로 분류한다."""
+    if not row.get("exists", False):
+        return "missing"
+    work_status = str(row.get("workStatus") or "")
+    if work_status in _WORK_STATUS_BUCKETS:
+        return _WORK_STATUS_BUCKETS[work_status]
+    pointer = row.get("nextRecommendedPhase")
+    pointer_status = pointer.get("status") if isinstance(pointer, dict) else ""
+    return _POINTER_STATUS_BUCKETS.get(pointer_status, "running")
+
+
 def status_task(home: Path, manager_id: str, task_group: str, task_id: str) -> dict:
     manifest = _read_json(task_manifest_path(home, manager_id, task_group, task_id))
     children = _read_json_default(children_json_path(home, manager_id, task_group, task_id), {"children": []})
@@ -135,21 +165,9 @@ def status_task(home: Path, manager_id: str, task_group: str, task_id: str) -> d
     for child in children.get("children", []):
         if not isinstance(child, dict):
             continue
-        key = child.get("taskKey")
-        snapshot_row = by_key.get(key)
+        snapshot_row = by_key.get(child.get("taskKey"))
         row = {**child, **(snapshot_row or {})}
-        status = str(row.get("latestRunStatus") or row.get("launch", {}).get("status") or "planned")
-        if snapshot_row is None:
-            summary["planned"] += 1
-        elif not row.get("exists", False):
-            summary["missing"] += 1
-        elif status == "done":
-            summary["done"] += 1
-        elif status in {"running", "started", "in-progress"}:
-            summary["running"] += 1
-        elif status == "blocked":
-            summary["blocked"] += 1
-        else:
-            summary["planned"] += 1
+        row["summaryBucket"] = "planned" if snapshot_row is None else summary_bucket(row)
+        summary[row["summaryBucket"]] += 1
         rows.append(row)
     return {"manifest": manifest, "summary": summary, "children": rows, "lastSnapshot": snapshot}

package/runtime/python/okstra_ctl/manager_view.py

@@ -0,0 +1,216 @@
+"""manager 상태를 한 장짜리 HTML 로 그린다.
+
+manager 가 이미 저장한 파일(projects / task manifest / children / snapshots /
+directives / events)만 읽는다. 하위 프로젝트는 읽지 않는다 — 최신 상태가 필요하면
+먼저 `okstra manager task sync` 를 돌리고, 페이지는 각 task 의 마지막 sync 시각을
+보여 준다.
+"""
+from __future__ import annotations
+
+import html
+import re
+import shlex
+from datetime import datetime, timezone
+from pathlib import Path
+
+from okstra_ctl.jsonl import read_jsonl
+
+from .manager_paths import directives_jsonl_path, events_jsonl_path, view_html_path
+from .manager_store import ManagerError, list_projects, list_tasks, load_manager
+from .manager_sync import status_task
+from .paths import find_asset_root
+
+TEMPLATE_RELATIVE = ("templates", "manager", "view.template.html")
+_MARKER = re.compile(r"\{\{([A-Z]+)\}\}")
+BUCKETS = ("planned", "missing", "running", "done", "blocked")
+
+
+def _now_iso() -> str:
+    return datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ")
+
+
+def _e(value: object) -> str:
+    return html.escape("" if value is None else str(value))
+
+
+def _chip(bucket: str) -> str:
+    return f'<span class="chip {_e(bucket)}">{_e(bucket)}</span>'
+
+
+def _table(headers: tuple[str, ...], rows: list[list[str]], empty: str) -> str:
+    if not rows:
+        return f'<p class="empty">{_e(empty)}</p>'
+    head = "".join(f"<th>{_e(header)}</th>" for header in headers)
+    body = "".join("<tr>" + "".join(f"<td>{cell}</td>" for cell in row) + "</tr>" for row in rows)
+    return f'<div class="scroll"><table><thead><tr>{head}</tr></thead><tbody>{body}</tbody></table></div>'
+
+
+def _file_link(project_root: str, path: str) -> str:
+    """하위 프로젝트 기준 상대 경로를 절대 file 링크로 바꾼다. 빈 값은 `-`."""
+    if not path:
+        return "-"
+    target = Path(path)
+    if not target.is_absolute() and project_root:
+        target = Path(project_root) / target
+    if not target.is_absolute():
+        return f"<code>{_e(path)}</code>"
+    return f'<a href="{_e(target.as_uri())}"><code>{_e(path)}</code></a>'
+
+
+def _command(*args: str) -> str:
+    return shlex.join(["okstra", "manager", *args])
+
+
+def _summary_tiles(totals: dict[str, int]) -> str:
+    tiles = "".join(
+        f'<div class="tile"><div class="count">{totals[bucket]}</div>'
+        f'<div class="label">{_e(bucket)}</div></div>'
+        for bucket in BUCKETS
+    )
+    return f'<div class="tiles">{tiles}</div>'
+
+
+def _projects_table(projects: list[dict]) -> str:
+    rows = [
+        [
+            f"<code class=\"id\">{_e(project.get('projectId'))}</code>",
+            f"<code>{_e(project.get('projectRoot'))}</code>",
+            _e(project.get("role") or "-"),
+            _e(", ".join(project.get("tags") or []) or "-"),
+            _e(project.get("linkedAt") or "-"),
+        ]
+        for project in projects
+    ]
+    return _table(("Project", "Root", "Role", "Tags", "Linked at"), rows, "No projects registered.")
+
+
+def _child_rows(children: list[dict], roots: dict[str, str]) -> list[list[str]]:
+    rows = []
+    for child in children:
+        launch = child.get("launch") if isinstance(child.get("launch"), dict) else {}
+        phase = child.get("currentPhase") or ""
+        phase_state = child.get("currentPhaseState") or ""
+        assignment = " — ".join(part for part in (child.get("role"), child.get("assignment")) if part)
+        # `task split` 하위 태스크는 assignment 대신 범위 목록을 가진다.
+        assignment = assignment or "; ".join(child.get("scope") or [])
+        rows.append(
+            [
+                f"<code>{_e(child.get('taskKey'))}</code>",
+                _e(child.get("ticketId") or "-"),
+                _chip(str(child.get("summaryBucket") or "planned")),
+                _e(child.get("workStatus") or "-"),
+                _e(f"{phase} ({phase_state})" if phase and phase_state else phase or "-"),
+                _e(child.get("finalVerdict") or "-"),
+                _e(launch.get("status") or "-"),
+                f'<span class="wrap">{_e(assignment or "-")}</span>',
+                _e(child.get("error") or "-"),
+                _file_link("", str(child.get("briefPath") or "")),
+                _file_link(
+                    roots.get(str(child.get("projectId") or ""), ""),
+                    str(child.get("latestReportRecordPath") or ""),
+                ),
+            ]
+        )
+    return rows
+
+
+def _directive_list(directives: list[dict]) -> str:
+    if not directives:
+        return '<p class="empty">No directives.</p>'
+    items = "".join(
+        f"<li><strong>{_e(row.get('scope'))}"
+        f"{' · ' + _e(row.get('projectId')) if row.get('projectId') else ''}</strong>: "
+        f"{_e(row.get('body'))} <span class=\"meta\">{_e(row.get('createdAt'))}</span></li>"
+        for row in directives
+    )
+    return f'<ul class="plain">{items}</ul>'
+
+
+def _event_list(events: list[dict]) -> str:
+    if not events:
+        return '<p class="empty">No events.</p>'
+    items = "".join(
+        f"<li><code>{_e(row.get('createdAt'))}</code> {_e(row.get('event'))}"
+        f"{' · ' + _e(row.get('taskKey')) if row.get('taskKey') else ''}</li>"
+        for row in events
+    )
+    return f'<ul class="plain">{items}</ul>'
+
+
+def _task_panel(home: Path, manager_id: str, task: dict, status: dict, roots: dict[str, str]) -> str:
+    group, task_id = task["taskGroup"], task["taskId"]
+    synced_at = status["lastSnapshot"].get("syncedAt") or ""
+    sync_command = _command(
+        "task", "sync", "--manager-id", manager_id, "--task-group", group, "--task-id", task_id
+    )
+    counts = "".join(
+        f"{_chip(bucket)} {status['summary'][bucket]}"
+        for bucket in BUCKETS
+        if status["summary"][bucket]
+    )
+    head = (
+        f'<div class="task-head"><h3><code>{_e(group)} / {_e(task_id)}</code></h3>'
+        f'<div class="counts">{counts or "<span class=empty>no children</span>"}</div></div>'
+    )
+    meta = (
+        f'<div class="meta">Objective: {_e(task["objective"] or "-")} · '
+        f'Common brief: {_e(status["manifest"].get("commonBriefPath") or "-")} · '
+        f'Progress mode: {_e(task["progressMode"] or "-")}</div>'
+        f'<p class="hint">Last sync: {_e(synced_at or "never")} — refresh with '
+        f"<code>{_e(sync_command)}</code>, then re-run the view command.</p>"
+    )
+    children = _table(
+        ("Child", "Ticket", "Summary", "Work status", "Phase", "Verdict", "Launch", "Assignment", "Error",
+         "Brief", "Latest report"),
+        _child_rows(status["children"], roots),
+        "No child tasks.",
+    )
+    directives = read_jsonl(directives_jsonl_path(home, manager_id, group, task_id))
+    events = read_jsonl(events_jsonl_path(home, manager_id, group, task_id))
+    details = (
+        f"<details><summary>Directives ({len(directives)})</summary>{_directive_list(directives)}</details>"
+        f"<details><summary>Events ({len(events)})</summary>{_event_list(events)}</details>"
+    )
+    return f'<div class="panel">{head}{meta}{children}{details}</div>'
+
+
+def render_view(home: Path, manager_id: str, *, now: str | None = None) -> str:
+    """manager 한 개의 HTML 페이지 본문을 돌려준다."""
+    manager = load_manager(home, manager_id)
+    root = find_asset_root(TEMPLATE_RELATIVE)
+    if root is None:
+        raise ManagerError("manager view template not found: " + "/".join(TEMPLATE_RELATIVE))
+    template = root.joinpath(*TEMPLATE_RELATIVE).read_text(encoding="utf-8")
+    projects = list_projects(home, manager_id)
+    roots = {str(project.get("projectId")): str(project.get("projectRoot") or "") for project in projects}
+    tasks = list_tasks(home, manager_id)
+    totals = dict.fromkeys(BUCKETS, 0)
+    panels = []
+    for task in tasks:
+        status = status_task(home, manager_id, task["taskGroup"], task["taskId"])
+        for bucket in BUCKETS:
+            totals[bucket] += status["summary"][bucket]
+        panels.append(_task_panel(home, manager_id, task, status, roots))
+    meta = (
+        f"Created {_e(manager.get('createdAt') or '-')} · Generated {_e(now or _now_iso())} · "
+        f"{len(projects)} projects · {len(tasks)} manager tasks"
+    )
+    replacements = {
+        "TITLE": _e(f"Okstra manager · {manager.get('managerId') or manager_id}"),
+        "META": meta,
+        "SUMMARY": _summary_tiles(totals),
+        "PROJECTS": _projects_table(projects),
+        "TASKS": "".join(panels) or '<p class="empty">No manager tasks.</p>',
+    }
+    # 한 번에 치환한다. 차례로 바꾸면 앞에서 넣은 사용자 값 속 `{{TASKS}}` 같은
+    # 문자열이 뒤 치환에 다시 걸린다.
+    return _MARKER.sub(lambda match: replacements[match.group(1)], template)
+
+
+def write_view(home: Path, manager_id: str, *, now: str | None = None) -> dict:
+    """페이지를 `managers/<id>/view/index.html` 에 쓰고 경로를 돌려준다."""
+    page = render_view(home, manager_id, now=now)
+    path = view_html_path(home, manager_id)
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text(page, encoding="utf-8")
+    return {"managerId": manager_id, "viewPath": str(path), "viewUrl": path.as_uri()}

package/runtime/python/okstra_ctl/plan_items_cli.py

@@ -26,6 +26,7 @@ from .convergence_store import write_json_atomic
 from .incremental_carry import sync_prepared_dispatch_queue
 from .json_boundary import JsonBoundaryError, load_owned_object
 from .report_finalize import task_manifest_path
+from .qa_commands import split_verification_command
 from .plan_derivations import extract_tokens, find_derivations
 from .plan_items import (
     NextDispatch,
@@ -577,7 +578,11 @@ def _render_scalar_or_list(key: str, value: object, indent: str = "") -> list[st
     if isinstance(value, Mapping):
         raise PlanItemContractError(f"plan item {key} must be scalar")
     if key in {"command", "commandOrObservation"} and isinstance(value, str):
-        return _render_literal(_label(key), value, indent)
+        command, annotation = split_verification_command(value)
+        rows = _render_literal(_label(key), command, indent)
+        if annotation is not None:
+            rows.append(indent + line("Command annotation (not executable)", annotation))
+        return rows
     return [indent + line(_label(key), value)]
 
 

package/runtime/python/okstra_ctl/qa_commands.py

@@ -98,6 +98,21 @@ def find_unfrozen_installs(cmd: str) -> list[str]:
     return found
 
 
+def split_verification_command(command: str) -> tuple[str, str | None]:
+    """기존 계획의 파일 인용 설명만 분리하며 일반 셸 구문은 보존한다."""
+    match = re.search(r";\s*(existing helper:\s*[^;&|<>$`\n]+:\d+(?:-\d+)?)\s*$", command)
+    if match is None:
+        return command, None
+    executable = command[:match.start()].rstrip()
+    try:
+        words = shlex.split(executable)
+    except ValueError:
+        return command, None
+    if not words:
+        return command, None
+    return executable, match.group(1).strip()
+
+
 def verification_command_defects(command: str) -> list[str]:
     """선언된 작업 폴더를 셸에서 다른 체크아웃으로 바꾸는 명령을 거부한다."""
     try:

package/runtime/python/okstra_ctl/report_finalize.py

@@ -737,6 +737,8 @@ def _closeout_report_paths(ctx: FinalizeContext) -> dict[str, Any]:
     답장을 마크다운으로 그리므로 괄호 안에 경로가 들어간 형태만 클릭되고,
     백틱으로 감싼 경로는 글자로만 남아 사용자가 직접 옮겨 적어야 한다. 리드가
     그 형태를 매번 다시 만들면 어긋날 자리가 생기므로 완성된 문자열을 준다.
+    링크 목적지는 절대 경로다 — 프로젝트 기준 상대 경로는 호스트 cwd 가 다르거나
+    외부 프로그램으로 열 때 해석되지 않는다. 공백이 든 경로는 `<...>` 로 감싼다.
     """
     def rel(path: Path) -> str:
         try:
@@ -744,17 +746,22 @@ def _closeout_report_paths(ctx: FinalizeContext) -> dict[str, Any]:
         except ValueError:
             return str(path)
 
-    paths = {
-        "humanReport": rel(html_view_path(ctx.data_path)),
-        "reportRecord": rel(ctx.data_path),
-        "teamState": rel(ctx.team_state_path),
+    def link_target(path: Path) -> str:
+        target = path.resolve().as_posix()
+        return f"<{target}>" if " " in target else target
+
+    sources = {
+        "humanReport": html_view_path(ctx.data_path),
+        "reportRecord": ctx.data_path,
+        "teamState": ctx.team_state_path,
     }
+    paths = {key: rel(path) for key, path in sources.items()}
     return {
         **paths,
         "renderFullCopy": f"okstra render-final-report {paths['reportRecord']}",
         "markdown": {
-            key: f"[{Path(value).name}]({value})"
-            for key, value in paths.items()
+            key: f"[{path.name}]({link_target(path)})"
+            for key, path in sources.items()
         },
     }
 

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

@@ -3,8 +3,7 @@ from __future__ import annotations
 
 from ...release_gate import release_handoff_allowed
 from ..common import evidence_index
-from ..models import HumanReportView, VisualNode
-from ..visualizations import coverage_figure
+from ..models import HumanReportView
 
 # Record fields this template anchors as `id-<row id>` (see
 # `HumanReportView.anchored_fields`); ids elsewhere land in the ledger.
@@ -17,25 +16,8 @@ ANCHORED_FIELDS = (
 )
 
 
-def _coverage_nodes(final: dict) -> tuple[VisualNode, ...]:
-    return tuple(
-        VisualNode(
-            row["id"],
-            row["requirement"],
-            "requirement",
-            row["status"],
-            row["artifact"],
-            note=row["status"],
-        )
-        for row in final["validationEvidence"]
-    )
-
-
 def build_final_verification_view(data: dict) -> HumanReportView:
     final = data["finalVerification"]
-    figure = coverage_figure(
-        rows=_coverage_nodes(final), title="Requirement verification coverage"
-    )
     verdict_token = data["finalVerdict"]["verdictToken"]
     context = {
         "humanSummary": data["humanSummary"],
@@ -44,7 +26,6 @@ def build_final_verification_view(data: dict) -> HumanReportView:
         "finalVerdict": data["finalVerdict"],
         "final": final,
         "narrative": final["userNarrative"],
-        "coverageFigure": figure,
         "releaseAllowed": release_handoff_allowed(data),
         "evidenceIndex": evidence_index(data, ANCHORED_FIELDS),
     }
@@ -52,6 +33,6 @@ def build_final_verification_view(data: dict) -> HumanReportView:
         "final-verification",
         "html/tasks/final-verification.template.html",
         context,
-        (figure,),
+        (),
         anchored_fields=ANCHORED_FIELDS,
     )

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

@@ -356,11 +356,6 @@ def matrix_figure(*, items: Iterable[VisualNode], title: str, x_label: str, y_la
     return replace(dependency_figure(nodes=nodes, edges=(), title=title), kind="matrix", figure_id="matrix", summary=summary)
 
 
-def coverage_figure(*, rows: Iterable[VisualNode], title: str) -> FigureModel:
-    nodes = tuple(rows)
-    return replace(dependency_figure(nodes=nodes, edges=(), title=title), kind="coverage", figure_id="coverage")
-
-
 def timeline_figure(*, events: Iterable[VisualNode], title: str) -> FigureModel:
     nodes = tuple(events)
     edges = tuple(VisualEdge(nodes[i].id, nodes[i + 1].id, "next", "sequence") for i in range(len(nodes) - 1))