okstra 0.147.0 → 0.148.1

package/runtime/python/okstra_ctl/path_hints.py

@@ -13,6 +13,7 @@ from okstra_project.dirs import (
 )
 
 from .paths import runs_dir_of, task_manifest_file, task_timeline_file
+from .worker_artifacts import artifacts_from_context
 
 RUN_CONTEXT_KIND = "run-context"
 RUN_CONTEXT_SCHEMA_VERSION = "2.0"
@@ -162,7 +163,7 @@ def _compact_active_workers(payload: Mapping[str, Any]) -> list[dict[str, Any]]:
 def _compact_active_worker(worker: Mapping[str, Any]) -> dict[str, Any]:
     keep = (
         "workerId", "role", "agent", "agentLabel", "model",
-        "modelExecutionValue", "attemptRequired",
+        "provider", "runner", "modelExecutionValue", "attemptRequired",
     )
     return {key: worker.get(key, "") for key in keep}
 
@@ -242,19 +243,19 @@ def _hydrate_active_worker(
 ) -> dict[str, Any]:
     worker_id = str(worker.get("workerId", ""))
     hydrated = dict(worker)
-    hydrated["promptPath"] = ctx.get(_worker_path_key(worker_id, "prompt"), "")
-    hydrated["resultPath"] = ctx.get(_worker_path_key(worker_id, "result"), "")
+    paths = artifacts_from_context(ctx, relative=True).get(worker_id, {})
+    hydrated["promptPath"] = paths.get("promptPath", "")
+    hydrated["resultPath"] = paths.get("resultPath", "")
     return hydrated
 
 
 def _hydrate_active_error_logs(ctx: Mapping[str, str]) -> dict[str, Any]:
+    artifacts = artifacts_from_context(ctx, relative=True)
     return {
         "runErrorsLogPath": ctx.get("RUN_ERRORS_LOG_RELATIVE_PATH", ""),
         "sidecarsByWorkerId": {
-            "claude": ctx.get("CLAUDE_WORKER_ERRORS_SIDECAR_RELATIVE_PATH", ""),
-            "codex": ctx.get("CODEX_WORKER_ERRORS_SIDECAR_RELATIVE_PATH", ""),
-            "antigravity": ctx.get("ANTIGRAVITY_WORKER_ERRORS_SIDECAR_RELATIVE_PATH", ""),
-            "report-writer": ctx.get("REPORT_WRITER_WORKER_ERRORS_SIDECAR_RELATIVE_PATH", ""),
+            worker_id: paths["errorsSidecarPath"]
+            for worker_id, paths in artifacts.items()
         },
     }
 
@@ -268,23 +269,6 @@ def _hydrate_active_source_artifacts(ctx: Mapping[str, str]) -> dict[str, str]:
     }
 
 
-def _worker_path_key(worker_id: str, kind: str) -> str:
-    by_worker = {
-        "claude": ("CLAUDE_WORKER_PROMPT_RELATIVE_PATH", "CLAUDE_WORKER_RESULT_RELATIVE_PATH"),
-        "codex": ("CODEX_WORKER_PROMPT_RELATIVE_PATH", "CODEX_WORKER_RESULT_RELATIVE_PATH"),
-        "antigravity": (
-            "ANTIGRAVITY_WORKER_PROMPT_RELATIVE_PATH",
-            "ANTIGRAVITY_WORKER_RESULT_RELATIVE_PATH",
-        ),
-        "report-writer": (
-            "REPORT_WRITER_WORKER_PROMPT_RELATIVE_PATH",
-            "REPORT_WRITER_WORKER_RESULT_RELATIVE_PATH",
-        ),
-    }
-    index = 0 if kind == "prompt" else 1
-    return by_worker.get(worker_id, ("", ""))[index]
-
-
 def _compact_run_hints(ctx: Mapping[str, Any]) -> dict[str, Any]:
     return {
         "runRoot": ctx.get("RUN_DIR_RELATIVE_PATH", ""),
@@ -421,7 +405,7 @@ def _run_files(
         "run_manifest_file": run_manifests / f"run-manifest{suffixes['manifests']}.json",
         "run_context_file": run_manifests / f"run-context-{task_type_segment}-{sequences['manifests']}.json",
         "run_inputs_file": run_manifests / f"run-inputs-{task_type_segment}-{sequences['manifests']}.json",
-        "run_prompt_snapshot": run_prompts / f"claude-execution-prompt{suffixes['prompts']}.md",
+        "run_prompt_snapshot": run_prompts / f"lead-execution-prompt{suffixes['prompts']}.md",
         "claude_worker_prompt": run_prompts / f"claude-worker-prompt{suffixes['prompts']}.md",
         "codex_worker_prompt": run_prompts / f"codex-worker-prompt{suffixes['prompts']}.md",
         "antigravity_worker_prompt": run_prompts / f"antigravity-worker-prompt{suffixes['prompts']}.md",

package/runtime/python/okstra_ctl/paths.py

@@ -485,7 +485,7 @@ def compute_run_paths(
     run_file_suffix = suffixes["reports"]
 
     run_manifest_file = run_manifests / f"run-manifest{suffixes['manifests']}.json"
-    run_prompt_snapshot = run_prompts / f"claude-execution-prompt{suffixes['prompts']}.md"
+    run_prompt_snapshot = run_prompts / f"lead-execution-prompt{suffixes['prompts']}.md"
     claude_worker_prompt = run_prompts / f"claude-worker-prompt{suffixes['prompts']}.md"
     codex_worker_prompt = run_prompts / f"codex-worker-prompt{suffixes['prompts']}.md"
     antigravity_worker_prompt = run_prompts / f"antigravity-worker-prompt{suffixes['prompts']}.md"

package/runtime/python/okstra_ctl/render.py

@@ -32,8 +32,11 @@ from . import fix_cycles
 from .analysis_inputs import ANALYSIS_TASK_TYPES
 from .paths import okstra_home
 from .lead_runtime import lead_runtime_info
+from .models import UnknownProviderError, provider_ids, provider_spec
+from .runner_resolution import native_provider_for_host
 from .path_hints import compact_active_run_context, hydrate_run_context
 from .paths import task_timeline_file
+from .worker_artifacts import artifacts_from_context
 from .workflow import DEFAULT_NEXT_PHASE, PHASE_SEQUENCE
 
 
@@ -250,51 +253,106 @@ def _resolve_workers(ctx: dict) -> list[str]:
     ]
 
 
-def _worker_catalog(ctx: dict) -> dict:
+def _assignment_runner_for_ctx(ctx: dict, provider: str) -> str:
+    native_provider = native_provider_for_host(_lead_runtime(ctx))
+    return "native-session" if provider == native_provider else "cli-wrapper"
+
+
+def _lead_assignment(ctx: dict) -> dict:
+    raw = ctx.get("LEAD_ASSIGNMENT_JSON", "")
+    if raw:
+        try:
+            parsed = json.loads(raw)
+            if isinstance(parsed, dict):
+                return parsed
+        except json.JSONDecodeError:
+            pass
+    provider = (
+        ctx.get("LEAD_PROVIDER", "")
+        or native_provider_for_host(_lead_runtime(ctx))
+        or "claude"
+    )
     return {
-        "claude": {
-            "workerId": "claude",
-            "role": "Claude worker",
-            "agent": "claude",
-            "agentLabel": "Claude Code",
-            "model": ctx.get("CLAUDE_WORKER_MODEL", ""),
-            "modelExecutionValue": ctx.get("CLAUDE_WORKER_MODEL_EXECUTION_VALUE", ""),
-            "resultPath": ctx.get("CLAUDE_WORKER_RESULT_RELATIVE_PATH", ""),
-            "promptPath": ctx.get("CLAUDE_WORKER_PROMPT_RELATIVE_PATH", ""),
-        },
-        "codex": {
-            "workerId": "codex",
-            "role": "Codex worker",
-            "agent": "codex",
-            "agentLabel": "Codex",
-            "model": ctx.get("CODEX_WORKER_MODEL", ""),
-            "modelExecutionValue": ctx.get("CODEX_WORKER_MODEL_EXECUTION_VALUE", ""),
-            "resultPath": ctx.get("CODEX_WORKER_RESULT_RELATIVE_PATH", ""),
-            "promptPath": ctx.get("CODEX_WORKER_PROMPT_RELATIVE_PATH", ""),
-        },
-        "antigravity": {
-            "workerId": "antigravity",
-            "role": "Antigravity worker",
-            "agent": "antigravity",
-            "agentLabel": "Antigravity",
-            "model": ctx.get("ANTIGRAVITY_WORKER_MODEL", ""),
-            "modelExecutionValue": ctx.get("ANTIGRAVITY_WORKER_MODEL_EXECUTION_VALUE", ""),
-            "resultPath": ctx.get("ANTIGRAVITY_WORKER_RESULT_RELATIVE_PATH", ""),
-            "promptPath": ctx.get("ANTIGRAVITY_WORKER_PROMPT_RELATIVE_PATH", ""),
-        },
-        "report-writer": {
-            "workerId": "report-writer",
-            "role": "Report writer worker",
-            "agent": "claude",
-            "agentLabel": "Claude Code",
-            "model": ctx.get("REPORT_WRITER_MODEL", ""),
-            "modelExecutionValue": ctx.get("REPORT_WRITER_MODEL_EXECUTION_VALUE", ""),
-            "resultPath": ctx.get("REPORT_WRITER_WORKER_RESULT_RELATIVE_PATH", ""),
-            "promptPath": ctx.get("REPORT_WRITER_WORKER_PROMPT_RELATIVE_PATH", ""),
-        },
+        "role": "lead",
+        "provider": provider,
+        "model": ctx.get("LEAD_MODEL", ""),
+        "modelExecutionValue": ctx.get("LEAD_MODEL_EXECUTION_VALUE", ""),
+        "runner": _assignment_runner_for_ctx(ctx, provider),
     }
 
 
+def _worker_assignments(ctx: dict) -> list[dict]:
+    raw = ctx.get("WORKER_ASSIGNMENTS_JSON", "")
+    if raw:
+        try:
+            parsed = json.loads(raw)
+            if isinstance(parsed, list) and all(isinstance(row, dict) for row in parsed):
+                return parsed
+        except json.JSONDecodeError:
+            pass
+    catalog = _worker_catalog(ctx, include_assignments=False)
+    return [
+        {
+            "workerId": worker_id,
+            "role": "report-writer" if worker_id == "report-writer" else "analyser",
+            "provider": catalog[worker_id]["agent"],
+            "model": catalog[worker_id]["model"],
+            "modelExecutionValue": catalog[worker_id]["modelExecutionValue"],
+            "runner": _assignment_runner_for_ctx(ctx, catalog[worker_id]["agent"]),
+        }
+        for worker_id in _resolve_workers(ctx)
+    ]
+
+
+def _worker_catalog(ctx: dict, *, include_assignments: bool = True) -> dict:
+    assignments = {} if not include_assignments else {
+        row.get("workerId"): row for row in _worker_assignments(ctx)
+        if row.get("workerId")
+    }
+    catalog = {}
+    for worker_id, paths in artifacts_from_context(ctx, relative=True).items():
+        assignment = assignments.get(worker_id, {})
+        provider = assignment.get("provider") or _fallback_worker_provider(ctx, worker_id)
+        provider_info = provider_spec(provider)
+        model, execution = _legacy_worker_model(ctx, worker_id)
+        catalog[worker_id] = {
+            "workerId": worker_id,
+            "role": (
+                "Report writer worker" if worker_id == "report-writer"
+                else f"{provider_spec(worker_id).display_label} worker"
+            ),
+            "agent": provider,
+            "agentLabel": provider_info.display_label,
+            "provider": provider,
+            "runner": assignment.get(
+                "runner", _assignment_runner_for_ctx(ctx, provider),
+            ),
+            "model": assignment.get("model", model),
+            "modelExecutionValue": assignment.get("modelExecutionValue", execution),
+            **paths,
+        }
+    return catalog
+
+
+def _fallback_worker_provider(ctx: dict, worker_id: str) -> str:
+    if worker_id == "report-writer":
+        return ctx.get("REPORT_WRITER_PROVIDER", "") or "claude"
+    return worker_id
+
+
+def _legacy_worker_model(ctx: dict, worker_id: str) -> tuple[str, str]:
+    token = "REPORT_WRITER" if worker_id == "report-writer" else (
+        worker_id.upper().replace("-", "_")
+    )
+    return (
+        ctx.get(f"{token}_WORKER_MODEL", ctx.get(f"{token}_MODEL", "")),
+        ctx.get(
+            f"{token}_WORKER_MODEL_EXECUTION_VALUE",
+            ctx.get(f"{token}_MODEL_EXECUTION_VALUE", ""),
+        ),
+    )
+
+
 def _active_workers(ctx: dict) -> list[dict]:
     catalog = _worker_catalog(ctx)
     workers = []
@@ -305,6 +363,8 @@ def _active_workers(ctx: dict) -> list[dict]:
             "role": item["role"],
             "agent": item["agent"],
             "agentLabel": item["agentLabel"],
+            "provider": item["provider"],
+            "runner": item["runner"],
             "model": item["model"],
             "modelExecutionValue": item["modelExecutionValue"],
             "promptPath": item["promptPath"],
@@ -378,13 +438,12 @@ def _active_instruction_set(ctx: dict) -> dict:
 
 
 def _active_error_logs(ctx: dict) -> dict:
+    artifacts = artifacts_from_context(ctx, relative=True)
     return {
         "runErrorsLogPath": ctx.get("RUN_ERRORS_LOG_RELATIVE_PATH", ""),
         "sidecarsByWorkerId": {
-            "claude": ctx.get("CLAUDE_WORKER_ERRORS_SIDECAR_RELATIVE_PATH", ""),
-            "codex": ctx.get("CODEX_WORKER_ERRORS_SIDECAR_RELATIVE_PATH", ""),
-            "antigravity": ctx.get("ANTIGRAVITY_WORKER_ERRORS_SIDECAR_RELATIVE_PATH", ""),
-            "report-writer": ctx.get("REPORT_WRITER_WORKER_ERRORS_SIDECAR_RELATIVE_PATH", ""),
+            worker_id: paths["errorsSidecarPath"]
+            for worker_id, paths in artifacts.items()
         },
     }
 
@@ -496,6 +555,8 @@ def render_team_state(team_state_path: str, ctx: dict) -> None:
                 "workerId": m["workerId"],
                 "role": m["role"],
                 "agent": m["agent"],
+                "provider": m["provider"],
+                "runner": m["runner"],
                 "model": m["model"],
                 "modelExecutionValue": m["modelExecutionValue"],
                 "status": "not-run",
@@ -508,7 +569,10 @@ def render_team_state(team_state_path: str, ctx: dict) -> None:
         "schemaVersion": "1.0",
         "taskKey": ctx.get("TASK_KEY", ""),
         "taskType": ctx.get("TASK_TYPE", ""),
+        "hostRuntime": ctx.get("HOST_RUNTIME", "") or _lead_runtime(ctx),
         "leadRuntime": _lead_runtime(ctx),
+        "leadAssignment": _lead_assignment(ctx),
+        "workerAssignments": _worker_assignments(ctx),
         "leadAdapter": _lead_adapter(ctx),
         "leadEventsPath": ctx.get("LEAD_EVENTS_RELATIVE_PATH", ""),
         "runDirectoryPath": ctx.get("RUN_DIR_RELATIVE_PATH", ""),
@@ -516,6 +580,8 @@ def render_team_state(team_state_path: str, ctx: dict) -> None:
         "lead": {
             "role": _lead_role(ctx),
             "agent": _lead_agent(ctx),
+            "provider": _lead_assignment(ctx).get("provider", ""),
+            "runner": _lead_assignment(ctx).get("runner", ""),
             "model": ctx.get("LEAD_MODEL", ""),
             "modelExecutionValue": ctx.get("LEAD_MODEL_EXECUTION_VALUE", ""),
             "status": ctx.get("CURRENT_RUN_STATUS", ""),
@@ -810,6 +876,7 @@ def migrate_legacy_run_artifacts(ctx: dict) -> None:
     legacy_targets = [
         ("run-manifest-", ".json", Path(ctx["RUN_MANIFESTS_DIR"])),
         ("team-state-", ".json", Path(ctx["RUN_STATE_DIR"])),
+        ("lead-execution-prompt-", ".md", Path(ctx["RUN_PROMPTS_DIR"])),
         ("claude-execution-prompt-", ".md", Path(ctx["RUN_PROMPTS_DIR"])),
         ("final-report-", ".md", Path(ctx["RUN_REPORTS_DIR"])),
         ("final-", ".status", Path(ctx["RUN_STATUS_DIR"])),
@@ -866,6 +933,8 @@ def _required_worker_roles(ctx: dict, reviewers: list[str]) -> list[dict]:
             "workerId": catalog[item]["workerId"],
             "role": catalog[item]["role"],
             "agent": catalog[item]["agent"],
+            "provider": catalog[item]["provider"],
+            "runner": catalog[item]["runner"],
             "model": catalog[item]["model"],
             "modelExecutionValue": catalog[item]["modelExecutionValue"],
             "resultPath": catalog[item]["resultPath"],
@@ -1093,7 +1162,10 @@ def render_task_manifest(manifest_path: str, ctx: dict) -> None:
         "taskIdPathSegment": ctx.get("TASK_ID_SEGMENT", ""),
         "projectRoot": ctx.get("PROJECT_ROOT", ""),
         "taskType": ctx.get("TASK_TYPE", ""),
+        "hostRuntime": ctx.get("HOST_RUNTIME", "") or _lead_runtime(ctx),
         "leadRuntime": _lead_runtime(ctx),
+        "leadAssignment": _lead_assignment(ctx),
+        "workerAssignments": _worker_assignments(ctx),
         "leadAdapter": _lead_adapter(ctx),
         "workCategory": work_category,
         # user-managed status (set-work-status CLI) — carried across re-renders
@@ -1151,6 +1223,8 @@ def render_task_manifest(manifest_path: str, ctx: dict) -> None:
             "referenceExpectationsPath": ctx.get(
                 "REFERENCE_EXPECTATIONS_RELATIVE_PATH", ""
             ),
+            "leadExecutionPromptPath": ctx.get("INSTRUCTION_SET_RELATIVE_PATH", "")
+            + "/lead-execution-prompt.md",
             "claudeExecutionPromptPath": ctx.get("INSTRUCTION_SET_RELATIVE_PATH", "")
             + "/claude-execution-prompt.md",
             "leadPromptSnapshotPath": ctx.get("RUN_PROMPT_SNAPSHOT_RELATIVE_PATH", ""),
@@ -1174,7 +1248,7 @@ def render_task_manifest(manifest_path: str, ctx: dict) -> None:
             "leadExecutionMode": "synthesis-only",
             "finalSynthesisOwner": lead_role,
             "artifactFirst": True,
-            "resultCollectionMode": "claude-managed",
+            "resultCollectionMode": "lead-managed",
             "finalReportFormat": "markdown",
             "finalReportFilename": ctx.get("FINAL_REPORT_FILENAME", ""),
             "finalStatusFilename": ctx.get("FINAL_STATUS_FILENAME", ""),
@@ -1182,7 +1256,7 @@ def render_task_manifest(manifest_path: str, ctx: dict) -> None:
             "requiredWorkerAttempts": reviewers,
             "requiredWorkerRoles": required_worker_roles,
             "requiredAgentStatusEntries": required_agent_status_entries,
-            "requireDistinctLeadFromClaudeWorker": True,
+            "requireDistinctLeadFromWorkerSession": True,
             "requireAllRequiredWorkerAttempts": True,
             "requireAntigravityWorkerAttempt": "antigravity" in reviewers,
             "requireCollectedWorkerStatusesBeforeFinalVerdict": True,
@@ -1227,14 +1301,20 @@ def render_task_manifest(manifest_path: str, ctx: dict) -> None:
             "teamStatePath": ctx.get("TEAM_STATE_RELATIVE_PATH", ""),
             "validatorScriptPath": ctx.get("RUN_VALIDATOR_RELATIVE_PATH", ""),
         },
-        "claudeSession": {
+        "leadSession": {
             "sessionId": ctx.get("CLAUDE_SESSION_ID", ""),
             "resumeCommandPath": ctx.get("CLAUDE_RESUME_COMMAND_RELATIVE_PATH", ""),
+            "accounting": _lead_info(ctx).session_accounting,
         },
         "convergence": convergence_block,
         "createdAt": existing.get("createdAt") or ctx.get("RUN_TIMESTAMP_ISO", ""),
         "updatedAt": ctx.get("RUN_TIMESTAMP_ISO", ""),
     }
+    if _lead_runtime(ctx) == "claude-code":
+        payload["claudeSession"] = {
+            "sessionId": ctx.get("CLAUDE_SESSION_ID", ""),
+            "resumeCommandPath": ctx.get("CLAUDE_RESUME_COMMAND_RELATIVE_PATH", ""),
+        }
     _write_json(path, payload)
 
 
@@ -1255,7 +1335,7 @@ def _build_convergence_block(ctx: dict) -> dict:
     ctx knobs honoured:
     - `OKSTRA_PLAN_VERIFICATION`: "true" | "false" | "" (empty → default True).
       Wired from CLI `--no-plan-verification` (sets "false").
-    - `CRITIC_CHOICE`: "" | "off" | "claude" | "codex" | "antigravity" — critic
+    - `CRITIC_CHOICE`: "" | "off" | a provider with the critic capability — critic
       backing provider (enabled only for requirements-discovery / error-analysis /
       implementation-planning / final-verification); model taken from that
       provider's execution value.
@@ -1277,16 +1357,24 @@ def _build_convergence_block(ctx: dict) -> dict:
     # Independent of `adversarial_phases` above (they answer different questions and
     # may diverge): the coverage critic is opt-in for the finding-producing phases.
     critic_phases = {"requirements-discovery", "error-analysis", "implementation-planning", "final-verification"}
-    critic_exec_key = {
-        "claude": "CLAUDE_WORKER_MODEL_EXECUTION_VALUE",
-        "codex": "CODEX_WORKER_MODEL_EXECUTION_VALUE",
-        "antigravity": "ANTIGRAVITY_WORKER_MODEL_EXECUTION_VALUE",
-    }
-    critic_enabled = critic_choice in critic_exec_key and task_type in critic_phases
+    critic_enabled = critic_choice in provider_ids("critic") and task_type in critic_phases
+    assignment = next(
+        (
+            row for row in _worker_assignments(ctx)
+            if row.get("provider") == critic_choice and row.get("role") != "report-writer"
+        ),
+        {},
+    )
+    _, legacy_execution = _legacy_worker_model(ctx, critic_choice)
     critic_block = {
         "enabled": critic_enabled,
         "provider": critic_choice if critic_enabled else None,
-        "modelExecutionValue": (ctx.get(critic_exec_key[critic_choice]) or None) if critic_enabled else None,
+        "modelExecutionValue": (
+            ctx.get("CRITIC_MODEL_EXECUTION_VALUE")
+            or assignment.get("modelExecutionValue")
+            or legacy_execution
+            or None
+        ) if critic_enabled else None,
     }
     return {
         "enabled": True,
@@ -1353,9 +1441,12 @@ def render_run_manifest(run_manifest_path: str, ctx: dict) -> None:
         "taskId": ctx.get("TASK_ID", ""),
         "taskKey": ctx.get("TASK_KEY", ""),
         "taskType": ctx.get("TASK_TYPE", ""),
+        "hostRuntime": ctx.get("HOST_RUNTIME", "") or _lead_runtime(ctx),
         "leadRuntime": _lead_runtime(ctx),
         "leadRuntimeRequest": ctx.get("LEAD_RUNTIME_REQUEST", "") or _lead_runtime(ctx),
         "runtimeResolution": _runtime_resolution(ctx),
+        "leadAssignment": _lead_assignment(ctx),
+        "workerAssignments": _worker_assignments(ctx),
         "leadAdapter": _lead_adapter(ctx),
         "workCategory": task_manifest.get(
             "workCategory", ctx.get("WORKFLOW_WORK_CATEGORY", "unknown")
@@ -1405,7 +1496,7 @@ def render_run_manifest(run_manifest_path: str, ctx: dict) -> None:
         "workerResultsDirectoryPath": ctx.get("WORKER_RESULTS_RELATIVE_PATH", ""),
         "reportTemplatePath": ctx.get("FINAL_REPORT_TEMPLATE_RELATIVE_PATH", ""),
         "validatorScriptPath": ctx.get("RUN_VALIDATOR_RELATIVE_PATH", ""),
-        "claudeSessionId": ctx.get("CLAUDE_SESSION_ID", ""),
+        "leadSessionId": ctx.get("CLAUDE_SESSION_ID", ""),
         "resumeCommandPath": ctx.get("CLAUDE_RESUME_COMMAND_RELATIVE_PATH", ""),
         "concurrentRun": {
             "detected": bool(concurrent_run_stages),
@@ -1446,7 +1537,7 @@ def render_run_manifest(run_manifest_path: str, ctx: dict) -> None:
             "requiredWorkerRoles": required_worker_roles,
             "requiredAgentStatusEntries": [lead_role]
             + [catalog[item]["role"] for item in reviewers],
-            "requireDistinctLeadFromClaudeWorker": True,
+            "requireDistinctLeadFromWorkerSession": True,
             "requireAllRequiredWorkerAttempts": True,
             "requireAntigravityWorkerAttempt": "antigravity" in reviewers,
             "requireCollectedWorkerStatusesBeforeFinalVerdict": True,
@@ -1485,6 +1576,8 @@ def render_run_manifest(run_manifest_path: str, ctx: dict) -> None:
         if ctx.get("TASK_TYPE") == "implementation-planning"
         else []
     )
+    if _lead_runtime(ctx) == "claude-code":
+        payload["claudeSessionId"] = ctx.get("CLAUDE_SESSION_ID", "")
     _write_json(Path(run_manifest_path), payload)
 
 
@@ -1497,12 +1590,7 @@ def render_timeline(timeline_path: str, ctx: dict) -> None:
         except Exception:
             task_manifest = {}
     reviewers = _resolve_workers(ctx)
-    worker_prompt_paths = {
-        "claude": ctx.get("CLAUDE_WORKER_PROMPT_RELATIVE_PATH", ""),
-        "codex": ctx.get("CODEX_WORKER_PROMPT_RELATIVE_PATH", ""),
-        "antigravity": ctx.get("ANTIGRAVITY_WORKER_PROMPT_RELATIVE_PATH", ""),
-        "report-writer": ctx.get("REPORT_WRITER_WORKER_PROMPT_RELATIVE_PATH", ""),
-    }
+    catalog = _worker_catalog(ctx)
     path = Path(timeline_path)
     existing = {}
     if path.exists():
@@ -1548,7 +1636,7 @@ def render_timeline(timeline_path: str, ctx: dict) -> None:
             "promptSnapshotPath": ctx.get("RUN_PROMPT_SNAPSHOT_RELATIVE_PATH", ""),
             "workerPromptDirectoryPath": ctx.get("RUN_PROMPTS_RELATIVE_PATH", ""),
             "workerPromptPathByWorkerId": {
-                item: worker_prompt_paths[item] for item in reviewers
+                item: catalog[item]["promptPath"] for item in reviewers
             },
             "reportPath": ctx.get("LATEST_REPORT_RELATIVE_PATH")
             or ctx.get("FINAL_REPORT_RELATIVE_PATH", ""),
@@ -1654,6 +1742,24 @@ def render_task_index(template_path: str, output_path: str, ctx: dict) -> None:
         or ctx.get("CLAUDE_RESUME_COMMAND_RELATIVE_PATH", "")
         or "--"
     )
+    model_assignment_lines = [
+        f"- `{lead_role}`: `{rc.get('leadModel', ctx.get('LEAD_MODEL', ''))}`"
+    ]
+    for assignment in task_manifest.get("workerAssignments", []):
+        if not isinstance(assignment, dict):
+            continue
+        worker_id = assignment.get("workerId", "")
+        provider = assignment.get("provider", "")
+        if worker_id == "report-writer":
+            label = "Report writer worker"
+        else:
+            try:
+                label = f"{provider_spec(provider).display_label} worker"
+            except (UnknownProviderError, TypeError):
+                label = f"{worker_id} worker"
+        model_assignment_lines.append(
+            f"- `{label}`: `{assignment.get('model', '')}`"
+        )
     mapping = {
         "{{TASK_KEY}}": task_manifest.get("taskKey", ctx.get("TASK_KEY", "")),
         "{{TASK_TYPE}}": task_manifest.get("taskType", ctx.get("TASK_TYPE", "")),
@@ -1686,15 +1792,7 @@ def render_task_index(template_path: str, output_path: str, ctx: dict) -> None:
             "status", ctx.get("VALIDATION_STATUS", "not-run")
         ),
         "{{CLAUDE_RESUME_COMMAND_RELATIVE_PATH}}": latest_resume_command,
-        "{{MODEL_ASSIGNMENT_LINES}}": "\n".join(
-            [
-                f"- `{lead_role}`: `{rc.get('leadModel', ctx.get('LEAD_MODEL', ''))}`",
-                f"- `Claude worker`: `{ctx.get('CLAUDE_WORKER_MODEL', '')}`",
-                f"- `Codex worker`: `{ctx.get('CODEX_WORKER_MODEL', '')}`",
-                f"- `Antigravity worker`: `{ctx.get('ANTIGRAVITY_WORKER_MODEL', '')}`",
-                f"- `Report writer worker`: `{ctx.get('REPORT_WRITER_MODEL', '')}`",
-            ]
-        ),
+        "{{MODEL_ASSIGNMENT_LINES}}": "\n".join(model_assignment_lines),
         "{{TASK_MANIFEST_RELATIVE_PATH}}": task_manifest.get(
             "taskManifestPath", ctx.get("TASK_MANIFEST_RELATIVE_PATH", "")
         ),

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

@@ -10,19 +10,55 @@ def audit_context(data: dict) -> dict[str, object]:
     }
 
 
+_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.
+
+    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.
+    """
+    return {
+        "id": row.get("id", ""),
+        "text": _first_filled(row, _LEDGER_TEXT_KEYS),
+        "codeEvidence": row.get("currentCodeEvidence") or [],
+        "source": _first_filled(row, _LEDGER_SOURCE_KEYS),
+    }
+
+
 def evidence_index(data: dict) -> dict[str, object]:
     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] = row
+                rows[row_id] = _ledger_row(row)
     analysis = data.get("analysisCommon", {})
     for collection in ("confirmedFacts", "inferences", "unknowns"):
         for row in analysis.get(collection, []):
             row_id = row.get("id")
             if row_id:
-                rows[row_id] = row
+                rows[row_id] = _ledger_row(row)
     return rows