okstra 0.32.1 → 0.34.0

package/runtime/python/okstra_ctl/render.py

@@ -14,13 +14,14 @@ ctx dict 의 schema 는 `okstra_ctl.paths.compute_run_paths()` 의 반환값을
 기본으로, 호출자가 추가 키 (workflow state / model display / related tasks /
 session id 등) 를 덧붙여 전달한다.
 """
+
 from __future__ import annotations
 
 import json
+import re
 import sys
 from pathlib import Path
 
-
 # --------------------------------------------------------------------------- #
 # helpers
 # --------------------------------------------------------------------------- #
@@ -47,9 +48,47 @@ def _write_json(path: Path, payload: dict) -> None:
     _write_text(path, json.dumps(payload, indent=2, ensure_ascii=False) + "\n")
 
 
+_PHASE_BLOCK_RE = re.compile(
+    r"\{% if header\.taskType == '(implementation-planning|release-handoff|implementation|final-verification)' %\}\n(.*?)\{% endif %\}\n",
+    re.DOTALL,
+)
+
+
+def _strip_phase_blocks(text: str, current_phase: str) -> str:
+    """Resolve phase-conditional blocks (`{% if header.taskType == 'X' %}
+    ... {% endif %}`) against *current_phase*.
+
+    Blocks whose target equals *current_phase* keep their body (jinja
+    markers dropped); blocks targeting a different phase are removed
+    entirely. When *current_phase* is empty or not one of the four
+    block-targetable phases (e.g. `requirements-discovery`,
+    `error-analysis`), every block is dropped — correct because none of
+    the `## 4.5` / `4.6` / `4.7` / `4.8` deliverable sections apply
+    there.
+
+    Observed (fontsninja-classifier-v2 RD run): the raw final-report
+    template copied into instruction-set/final-report-template.md was
+    43 KB / 631 lines; ~30 KB / ~330 lines belonged to the four other
+    phases' deliverables and was never relevant to that run. Stripping
+    at copy time cuts the lead/report-writer's baseline by ~7 K tokens
+    per phase entry.
+
+    Inline conditionals (those that begin and end on the same line) are
+    intentionally untouched — the regex only matches block-form
+    `{% if ... %}\\n ... \\n{% endif %}\\n`.
+    """
+
+    def repl(m: "re.Match[str]") -> str:
+        target_phase = m.group(1)
+        body = m.group(2)
+        return body if target_phase == current_phase else ""
+
+    return _PHASE_BLOCK_RE.sub(repl, text)
+
+
 _FM_DEFAULT = "no-classification"
 
-_FM_TAGS_BASE = ["obsidian", "okstra"]
+_FM_TAGS_BASE = []
 
 _FM_TAGS_CATALOG: dict[str, list[str]] = {
     "task-brief": ["task-brief"],
@@ -139,7 +178,9 @@ def _frontmatter_mapping(ctx: dict) -> dict:
 
 
 def _resolve_workers(ctx: dict) -> list[str]:
-    return [w.strip() for w in ctx.get("SELECTED_REVIEWERS", "").split(",") if w.strip()]
+    return [
+        w.strip() for w in ctx.get("SELECTED_REVIEWERS", "").split(",") if w.strip()
+    ]
 
 
 def _worker_catalog(ctx: dict) -> dict:
@@ -198,17 +239,19 @@ def render_team_state(team_state_path: str, ctx: dict) -> None:
     workers = []
     for w in selected:
         m = catalog[w]
-        workers.append({
-            "workerId": m["workerId"],
-            "role": m["role"],
-            "agent": m["agent"],
-            "model": m["model"],
-            "modelExecutionValue": m["modelExecutionValue"],
-            "status": "not-run",
-            "resultPath": m["resultPath"],
-            "promptPath": m["promptPath"],
-            "reason": "",
-        })
+        workers.append(
+            {
+                "workerId": m["workerId"],
+                "role": m["role"],
+                "agent": m["agent"],
+                "model": m["model"],
+                "modelExecutionValue": m["modelExecutionValue"],
+                "status": "not-run",
+                "resultPath": m["resultPath"],
+                "promptPath": m["promptPath"],
+                "reason": "",
+            }
+        )
     payload = {
         "schemaVersion": "1.0",
         "taskKey": ctx.get("TASK_KEY", ""),
@@ -280,9 +323,15 @@ def render_reference_expectations(brief_path: str, output_path: str, ctx: dict)
         "## Configuration References and Expected Values",
         "",
     ]
-    parts.append(config_text or "- No explicit configuration-file expectations were provided in the task brief.")
+    parts.append(
+        config_text
+        or "- No explicit configuration-file expectations were provided in the task brief."
+    )
     parts.extend(["", "## Deployment Manifests and Expected Values", ""])
-    parts.append(deployment_text or "- No explicit deployment-manifest expectations were provided in the task brief.")
+    parts.append(
+        deployment_text
+        or "- No explicit deployment-manifest expectations were provided in the task brief."
+    )
     _write_text(Path(output_path), "\n".join(parts).rstrip() + "\n")
 
 
@@ -315,7 +364,11 @@ def render_task_catalog_discovery(output_path: str, ctx: dict) -> None:
             continue
         task_root = manifest_path.parent
         timeline_relative = s(manifest, "historyTimelinePath").strip()
-        timeline_path = (project_root / timeline_relative) if timeline_relative else (task_root / "history" / "timeline.json")
+        timeline_path = (
+            (project_root / timeline_relative)
+            if timeline_relative
+            else (task_root / "history" / "timeline.json")
+        )
         latest_run = {}
         if timeline_path.is_file():
             try:
@@ -328,43 +381,69 @@ def render_task_catalog_discovery(output_path: str, ctx: dict) -> None:
                     if isinstance(item, dict):
                         latest_run = item
                         break
-        workflow = manifest.get("workflow") if isinstance(manifest.get("workflow"), dict) else {}
-        entries.append({
-            "taskKey": task_key,
-            "taskGroup": s(manifest, "taskGroup"),
-            "taskId": s(manifest, "taskId"),
-            "taskGroupPathSegment": s(manifest, "taskGroupPathSegment"),
-            "taskIdPathSegment": s(manifest, "taskIdPathSegment"),
-            "taskType": s(manifest, "taskType"),
-            "workCategory": s(manifest, "workCategory"),
-            "currentStatus": s(manifest, "currentStatus"),
-            "workStatus": s(manifest, "workStatus"),
-            "workStatusUpdatedAt": s(manifest, "workStatusUpdatedAt"),
-            "workStatusNote": s(manifest, "workStatusNote"),
-            "updatedAt": s(manifest, "updatedAt"),
-            "currentPhase": (workflow or {}).get("currentPhase", "") if isinstance(workflow, dict) else "",
-            "currentPhaseState": (workflow or {}).get("currentPhaseState", "") if isinstance(workflow, dict) else "",
-            "lastCompletedPhase": (workflow or {}).get("lastCompletedPhase", "") if isinstance(workflow, dict) else "",
-            "nextRecommendedPhase": (workflow or {}).get("nextRecommendedPhase", "") if isinstance(workflow, dict) else "",
-            "awaitingApproval": (workflow or {}).get("awaitingApproval", False) if isinstance(workflow, dict) else False,
-            "routingStatus": (workflow or {}).get("routingStatus", "") if isinstance(workflow, dict) else "",
-            "taskRootPath": s(manifest, "taskRootPath") or rel(task_root),
-            "taskManifestPath": s(manifest, "taskManifestPath") or rel(manifest_path),
-            "taskIndexPath": s(manifest, "taskIndexPath"),
-            "instructionSetPath": s(manifest, "instructionSetPath"),
-            "referenceExpectationsPath": s(manifest, "referenceExpectationsPath"),
-            "taskBriefPath": s(manifest, "taskBriefPath"),
-            "latestRunPath": s(manifest, "latestRunPath") or s(latest_run, "runDirectoryPath"),
-            "latestRunManifestPath": s(latest_run, "runManifestPath"),
-            "latestRunPromptsPath": s(manifest, "latestRunPromptsPath") or s(latest_run, "workerPromptDirectoryPath"),
-            "latestPromptSnapshotPath": s(latest_run, "promptSnapshotPath"),
-            "latestTeamStatePath": s(latest_run, "teamStatePath"),
-            "latestRunStatus": s(manifest, "latestRunStatus") or s(latest_run, "status"),
-            "latestReportPath": s(manifest, "latestReportPath") or s(latest_run, "reportPath"),
-            "latestResumeCommandPath": s(manifest, "latestResumeCommandPath") or s(latest_run, "resumeCommandPath"),
-            "historyTimelinePath": timeline_relative or rel(timeline_path),
-        })
-    entries.sort(key=lambda x: (x.get("updatedAt", ""), x.get("taskKey", "")), reverse=True)
+        workflow = (
+            manifest.get("workflow")
+            if isinstance(manifest.get("workflow"), dict)
+            else {}
+        )
+        entries.append(
+            {
+                "taskKey": task_key,
+                "taskGroup": s(manifest, "taskGroup"),
+                "taskId": s(manifest, "taskId"),
+                "taskGroupPathSegment": s(manifest, "taskGroupPathSegment"),
+                "taskIdPathSegment": s(manifest, "taskIdPathSegment"),
+                "taskType": s(manifest, "taskType"),
+                "workCategory": s(manifest, "workCategory"),
+                "currentStatus": s(manifest, "currentStatus"),
+                "workStatus": s(manifest, "workStatus"),
+                "workStatusUpdatedAt": s(manifest, "workStatusUpdatedAt"),
+                "workStatusNote": s(manifest, "workStatusNote"),
+                "updatedAt": s(manifest, "updatedAt"),
+                "currentPhase": (workflow or {}).get("currentPhase", "")
+                if isinstance(workflow, dict)
+                else "",
+                "currentPhaseState": (workflow or {}).get("currentPhaseState", "")
+                if isinstance(workflow, dict)
+                else "",
+                "lastCompletedPhase": (workflow or {}).get("lastCompletedPhase", "")
+                if isinstance(workflow, dict)
+                else "",
+                "nextRecommendedPhase": (workflow or {}).get("nextRecommendedPhase", "")
+                if isinstance(workflow, dict)
+                else "",
+                "awaitingApproval": (workflow or {}).get("awaitingApproval", False)
+                if isinstance(workflow, dict)
+                else False,
+                "routingStatus": (workflow or {}).get("routingStatus", "")
+                if isinstance(workflow, dict)
+                else "",
+                "taskRootPath": s(manifest, "taskRootPath") or rel(task_root),
+                "taskManifestPath": s(manifest, "taskManifestPath")
+                or rel(manifest_path),
+                "taskIndexPath": s(manifest, "taskIndexPath"),
+                "instructionSetPath": s(manifest, "instructionSetPath"),
+                "referenceExpectationsPath": s(manifest, "referenceExpectationsPath"),
+                "taskBriefPath": s(manifest, "taskBriefPath"),
+                "latestRunPath": s(manifest, "latestRunPath")
+                or s(latest_run, "runDirectoryPath"),
+                "latestRunManifestPath": s(latest_run, "runManifestPath"),
+                "latestRunPromptsPath": s(manifest, "latestRunPromptsPath")
+                or s(latest_run, "workerPromptDirectoryPath"),
+                "latestPromptSnapshotPath": s(latest_run, "promptSnapshotPath"),
+                "latestTeamStatePath": s(latest_run, "teamStatePath"),
+                "latestRunStatus": s(manifest, "latestRunStatus")
+                or s(latest_run, "status"),
+                "latestReportPath": s(manifest, "latestReportPath")
+                or s(latest_run, "reportPath"),
+                "latestResumeCommandPath": s(manifest, "latestResumeCommandPath")
+                or s(latest_run, "resumeCommandPath"),
+                "historyTimelinePath": timeline_relative or rel(timeline_path),
+            }
+        )
+    entries.sort(
+        key=lambda x: (x.get("updatedAt", ""), x.get("taskKey", "")), reverse=True
+    )
     payload = {
         "schemaVersion": "1.0",
         "projectId": ctx.get("PROJECT_ID", ""),
@@ -385,22 +464,34 @@ def render_latest_task_discovery(output_path: str, ctx: dict) -> None:
             task_manifest = json.loads(task_manifest_path.read_text(encoding="utf-8"))
         except Exception:
             task_manifest = {}
-    workflow = task_manifest.get("workflow") if isinstance(task_manifest.get("workflow"), dict) else {}
+    workflow = (
+        task_manifest.get("workflow")
+        if isinstance(task_manifest.get("workflow"), dict)
+        else {}
+    )
     payload = {
         "schemaVersion": "1.0",
         "updatedAt": ctx.get("RUN_TIMESTAMP_ISO", ""),
         "taskKey": ctx.get("TASK_KEY", ""),
         "taskType": ctx.get("ANALYSIS_TYPE", ""),
-        "workCategory": task_manifest.get("workCategory", ctx.get("WORKFLOW_WORK_CATEGORY", "unknown")),
-        "currentStatus": task_manifest.get("currentStatus", ctx.get("CURRENT_TASK_STATUS", "")),
-        "latestRunStatus": task_manifest.get("latestRunStatus", ctx.get("CURRENT_RUN_STATUS", "")),
+        "workCategory": task_manifest.get(
+            "workCategory", ctx.get("WORKFLOW_WORK_CATEGORY", "unknown")
+        ),
+        "currentStatus": task_manifest.get(
+            "currentStatus", ctx.get("CURRENT_TASK_STATUS", "")
+        ),
+        "latestRunStatus": task_manifest.get(
+            "latestRunStatus", ctx.get("CURRENT_RUN_STATUS", "")
+        ),
         "workflow": workflow,
         "taskRootPath": ctx.get("TASK_ROOT_RELATIVE_PATH", ""),
         "taskManifestPath": ctx.get("TASK_MANIFEST_RELATIVE_PATH", ""),
         "taskIndexPath": ctx.get("TASK_INDEX_RELATIVE_PATH", ""),
         "instructionSetPath": ctx.get("INSTRUCTION_SET_RELATIVE_PATH", ""),
         "taskCatalogPath": ctx.get("OKSTRA_TASK_CATALOG_RELATIVE_PATH", ""),
-        "referenceExpectationsPath": ctx.get("REFERENCE_EXPECTATIONS_RELATIVE_PATH", ""),
+        "referenceExpectationsPath": ctx.get(
+            "REFERENCE_EXPECTATIONS_RELATIVE_PATH", ""
+        ),
         "latestRunPath": ctx.get("LATEST_RUN_RELATIVE_PATH", ""),
         "latestRunManifestPath": ctx.get("RUN_MANIFEST_RELATIVE_PATH", ""),
         "latestRunPromptsPath": ctx.get("RUN_PROMPTS_RELATIVE_PATH", ""),
@@ -508,8 +599,12 @@ def render_task_manifest(manifest_path: str, ctx: dict) -> None:
     reviewers = _resolve_workers(ctx)
     catalog = _worker_catalog(ctx)
     phase_sequence = [
-        "requirements-discovery", "error-analysis", "implementation-planning",
-        "implementation", "final-verification", "release-handoff",
+        "requirements-discovery",
+        "error-analysis",
+        "implementation-planning",
+        "implementation",
+        "final-verification",
+        "release-handoff",
     ]
     default_next_phase = {
         "requirements-discovery": "pending-routing-decision",
@@ -521,18 +616,32 @@ def render_task_manifest(manifest_path: str, ctx: dict) -> None:
     }
     required_worker_roles = _required_worker_roles(ctx, reviewers)
     worker_prompt_paths = {item: catalog[item]["promptPath"] for item in reviewers}
-    required_agent_status_entries = ["Claude lead"] + [catalog[item]["role"] for item in reviewers]
+    required_agent_status_entries = ["Claude lead"] + [
+        catalog[item]["role"] for item in reviewers
+    ]
     related_tasks = json.loads(ctx.get("RELATED_TASKS_JSON", "[]"))
-    current_report_relative = ctx.get("LATEST_REPORT_RELATIVE_PATH") or ctx.get("FINAL_REPORT_RELATIVE_PATH", "")
-    workflow = existing.get("workflow", {}) if isinstance(existing.get("workflow"), dict) else {}
-    phase_states = workflow.get("phaseStates", {}) if isinstance(workflow.get("phaseStates"), dict) else {}
+    current_report_relative = ctx.get("LATEST_REPORT_RELATIVE_PATH") or ctx.get(
+        "FINAL_REPORT_RELATIVE_PATH", ""
+    )
+    workflow = (
+        existing.get("workflow", {})
+        if isinstance(existing.get("workflow"), dict)
+        else {}
+    )
+    phase_states = (
+        workflow.get("phaseStates", {})
+        if isinstance(workflow.get("phaseStates"), dict)
+        else {}
+    )
     current_phase = ctx.get("WORKFLOW_CURRENT_PHASE", ctx.get("ANALYSIS_TYPE", ""))
     current_phase_state = ctx.get("WORKFLOW_CURRENT_PHASE_STATE", "not-started")
     for phase in phase_sequence:
         phase_states.setdefault(phase, "not-started")
     if current_phase:
         phase_states[current_phase] = current_phase_state
-    work_category = existing.get("workCategory") or ctx.get("WORKFLOW_WORK_CATEGORY", "unknown")
+    work_category = existing.get("workCategory") or ctx.get(
+        "WORKFLOW_WORK_CATEGORY", "unknown"
+    )
     # Compute the canonical next phase from current_phase deterministically.
     # Only preserve `existing.workflow.nextRecommendedPhase` when it is a
     # legitimate forward pointer — i.e. NOT equal to `current_phase` itself
@@ -546,31 +655,63 @@ def render_task_manifest(manifest_path: str, ctx: dict) -> None:
         next_recommended_phase = existing_next
     else:
         next_recommended_phase = canonical_next
-    last_completed_phase = workflow.get("lastCompletedPhase") or ctx.get("WORKFLOW_LAST_COMPLETED_PHASE", "")
-    routing_status = workflow.get("routingStatus") or ctx.get("WORKFLOW_ROUTING_STATUS", "not-applicable")
+    last_completed_phase = workflow.get("lastCompletedPhase") or ctx.get(
+        "WORKFLOW_LAST_COMPLETED_PHASE", ""
+    )
+    routing_status = workflow.get("routingStatus") or ctx.get(
+        "WORKFLOW_ROUTING_STATUS", "not-applicable"
+    )
     awaiting_approval = workflow.get("awaitingApproval")
     if not isinstance(awaiting_approval, bool):
         awaiting_approval = ctx.get("WORKFLOW_AWAITING_APPROVAL", "false") == "true"
     render_only = ctx.get("RENDER_ONLY", "") == "true"
-    existing_checkpoint = existing.get("workflow", {}).get("lastSafeCheckpoint", {}) if isinstance(existing.get("workflow"), dict) else {}
+    existing_checkpoint = (
+        existing.get("workflow", {}).get("lastSafeCheckpoint", {})
+        if isinstance(existing.get("workflow"), dict)
+        else {}
+    )
     if not isinstance(existing_checkpoint, dict):
         existing_checkpoint = {}
     if render_only:
         last_safe_checkpoint = {
             "label": existing_checkpoint.get("label", ""),
-            "taskManifestPath": existing_checkpoint.get("taskManifestPath", ctx.get("TASK_MANIFEST_RELATIVE_PATH", "")),
-            "taskIndexPath": existing_checkpoint.get("taskIndexPath", ctx.get("TASK_INDEX_RELATIVE_PATH", "")),
-            "latestRunPath": existing_checkpoint.get("latestRunPath", existing.get("latestRunPath", "")),
-            "latestRunManifestPath": existing_checkpoint.get("latestRunManifestPath", ""),
-            "latestTeamStatePath": existing_checkpoint.get("latestTeamStatePath", existing.get("teamStatePath", "")),
-            "latestReportPath": existing_checkpoint.get("latestReportPath", existing.get("latestReportPath", "")),
-            "latestResumeCommandPath": existing_checkpoint.get("latestResumeCommandPath", existing.get("latestResumeCommandPath", "")),
+            "taskManifestPath": existing_checkpoint.get(
+                "taskManifestPath", ctx.get("TASK_MANIFEST_RELATIVE_PATH", "")
+            ),
+            "taskIndexPath": existing_checkpoint.get(
+                "taskIndexPath", ctx.get("TASK_INDEX_RELATIVE_PATH", "")
+            ),
+            "latestRunPath": existing_checkpoint.get(
+                "latestRunPath", existing.get("latestRunPath", "")
+            ),
+            "latestRunManifestPath": existing_checkpoint.get(
+                "latestRunManifestPath", ""
+            ),
+            "latestTeamStatePath": existing_checkpoint.get(
+                "latestTeamStatePath", existing.get("teamStatePath", "")
+            ),
+            "latestReportPath": existing_checkpoint.get(
+                "latestReportPath", existing.get("latestReportPath", "")
+            ),
+            "latestResumeCommandPath": existing_checkpoint.get(
+                "latestResumeCommandPath", existing.get("latestResumeCommandPath", "")
+            ),
         }
-        latest_run_relative = existing.get("latestRunPath", "") or ctx.get("LATEST_RUN_RELATIVE_PATH", "")
-        latest_run_status = existing.get("latestRunStatus", "") or ctx.get("CURRENT_RUN_STATUS", "")
-        latest_run_prompts_relative = existing.get("latestRunPromptsPath", "") or ctx.get("RUN_PROMPTS_RELATIVE_PATH", "")
-        latest_report_relative = existing.get("latestReportPath", "") or current_report_relative
-        latest_team_state_relative = existing.get("teamStatePath", "") or ctx.get("TEAM_STATE_RELATIVE_PATH", "")
+        latest_run_relative = existing.get("latestRunPath", "") or ctx.get(
+            "LATEST_RUN_RELATIVE_PATH", ""
+        )
+        latest_run_status = existing.get("latestRunStatus", "") or ctx.get(
+            "CURRENT_RUN_STATUS", ""
+        )
+        latest_run_prompts_relative = existing.get(
+            "latestRunPromptsPath", ""
+        ) or ctx.get("RUN_PROMPTS_RELATIVE_PATH", "")
+        latest_report_relative = (
+            existing.get("latestReportPath", "") or current_report_relative
+        )
+        latest_team_state_relative = existing.get("teamStatePath", "") or ctx.get(
+            "TEAM_STATE_RELATIVE_PATH", ""
+        )
         latest_resume_command_relative = existing.get("latestResumeCommandPath", "")
     else:
         last_safe_checkpoint = {
@@ -581,14 +722,20 @@ def render_task_manifest(manifest_path: str, ctx: dict) -> None:
             "latestRunManifestPath": ctx.get("RUN_MANIFEST_RELATIVE_PATH", ""),
             "latestTeamStatePath": ctx.get("TEAM_STATE_RELATIVE_PATH", ""),
             "latestReportPath": current_report_relative,
-            "latestResumeCommandPath": ctx.get("CLAUDE_RESUME_COMMAND_RELATIVE_PATH", ""),
+            "latestResumeCommandPath": ctx.get(
+                "CLAUDE_RESUME_COMMAND_RELATIVE_PATH", ""
+            ),
         }
         latest_run_relative = ctx.get("LATEST_RUN_RELATIVE_PATH", "")
         latest_run_status = ctx.get("CURRENT_RUN_STATUS", "")
         latest_run_prompts_relative = ctx.get("RUN_PROMPTS_RELATIVE_PATH", "")
-        latest_report_relative = current_report_relative or existing.get("latestReportPath", "")
+        latest_report_relative = current_report_relative or existing.get(
+            "latestReportPath", ""
+        )
         latest_team_state_relative = ctx.get("TEAM_STATE_RELATIVE_PATH", "")
-        latest_resume_command_relative = ctx.get("CLAUDE_RESUME_COMMAND_RELATIVE_PATH", "") or existing.get("latestResumeCommandPath", "")
+        latest_resume_command_relative = ctx.get(
+            "CLAUDE_RESUME_COMMAND_RELATIVE_PATH", ""
+        ) or existing.get("latestResumeCommandPath", "")
     convergence_block = _build_convergence_block(ctx)
     payload = {
         "schemaVersion": "1.0",
@@ -614,7 +761,9 @@ def render_task_manifest(manifest_path: str, ctx: dict) -> None:
         "historyPath": ctx.get("HISTORY_RELATIVE_PATH", ""),
         "historyTimelinePath": ctx.get("TIMELINE_RELATIVE_PATH", ""),
         "taskCatalogPath": ctx.get("OKSTRA_TASK_CATALOG_RELATIVE_PATH", ""),
-        "referenceExpectationsPath": ctx.get("REFERENCE_EXPECTATIONS_RELATIVE_PATH", ""),
+        "referenceExpectationsPath": ctx.get(
+            "REFERENCE_EXPECTATIONS_RELATIVE_PATH", ""
+        ),
         "latestRunPath": latest_run_relative,
         "latestRunStatus": latest_run_status,
         "latestRunPromptsPath": latest_run_prompts_relative,
@@ -633,15 +782,23 @@ def render_task_manifest(manifest_path: str, ctx: dict) -> None:
             "lastSafeCheckpoint": last_safe_checkpoint,
         },
         "artifacts": {
-            "analysisProfilePath": ctx.get("INSTRUCTION_SET_RELATIVE_PATH", "") + "/analysis-profile.md",
-            "analysisMaterialPath": ctx.get("INSTRUCTION_SET_RELATIVE_PATH", "") + "/analysis-material.md",
-            "taskBriefCopyPath": ctx.get("INSTRUCTION_SET_RELATIVE_PATH", "") + "/task-brief.md",
-            "referenceExpectationsPath": ctx.get("REFERENCE_EXPECTATIONS_RELATIVE_PATH", ""),
-            "claudeExecutionPromptPath": ctx.get("INSTRUCTION_SET_RELATIVE_PATH", "") + "/claude-execution-prompt.md",
+            "analysisProfilePath": ctx.get("INSTRUCTION_SET_RELATIVE_PATH", "")
+            + "/analysis-profile.md",
+            "analysisMaterialPath": ctx.get("INSTRUCTION_SET_RELATIVE_PATH", "")
+            + "/analysis-material.md",
+            "taskBriefCopyPath": ctx.get("INSTRUCTION_SET_RELATIVE_PATH", "")
+            + "/task-brief.md",
+            "referenceExpectationsPath": ctx.get(
+                "REFERENCE_EXPECTATIONS_RELATIVE_PATH", ""
+            ),
+            "claudeExecutionPromptPath": ctx.get("INSTRUCTION_SET_RELATIVE_PATH", "")
+            + "/claude-execution-prompt.md",
             "leadPromptSnapshotPath": ctx.get("RUN_PROMPT_SNAPSHOT_RELATIVE_PATH", ""),
             "workerPromptsDirectoryPath": ctx.get("RUN_PROMPTS_RELATIVE_PATH", ""),
             "workerPromptPathByWorkerId": worker_prompt_paths,
-            "finalReportTemplatePath": ctx.get("FINAL_REPORT_TEMPLATE_RELATIVE_PATH", ""),
+            "finalReportTemplatePath": ctx.get(
+                "FINAL_REPORT_TEMPLATE_RELATIVE_PATH", ""
+            ),
             "resumeCommandPath": ctx.get("CLAUDE_RESUME_COMMAND_RELATIVE_PATH", ""),
             "teamStatePath": ctx.get("TEAM_STATE_RELATIVE_PATH", ""),
             "workerResultsDirectoryPath": ctx.get("WORKER_RESULTS_RELATIVE_PATH", ""),
@@ -670,20 +827,33 @@ def render_task_manifest(manifest_path: str, ctx: dict) -> None:
             "disallowLeadSoloAnalysisAsWorkerResult": True,
             "disallowGenericParallelOnlyExecution": True,
             "workerOutputSections": [
-                "Findings", "Missing Information or Assumptions",
-                "Safe or Reasonable Areas", "Uncertain Points",
+                "Findings",
+                "Missing Information or Assumptions",
+                "Safe or Reasonable Areas",
+                "Uncertain Points",
                 "Recommended Next Actions",
             ],
             "finalReportSections": [
-                "Problem or Validation Summary", "Agent Execution Status",
-                "Cross Verification Result", "Final Verdict",
+                "Problem or Validation Summary",
+                "Agent Execution Status",
+                "Cross Verification Result",
+                "Final Verdict",
                 "Evidence and Detailed Analysis",
-                "Missing Information and Risk", "Recommended Next Actions",
+                "Missing Information and Risk",
+                "Recommended Next Actions",
             ],
             "statusLabels": [
-                "prepared", "team-created", "workers-dispatched",
-                "worker-results-collected", "synthesis-written", "in-progress",
-                "completed", "contract-violated", "timeout", "error", "not-run",
+                "prepared",
+                "team-created",
+                "workers-dispatched",
+                "worker-results-collected",
+                "synthesis-written",
+                "in-progress",
+                "completed",
+                "contract-violated",
+                "timeout",
+                "error",
+                "not-run",
             ],
         },
         "contractValidation": {
@@ -749,7 +919,11 @@ def render_run_manifest(run_manifest_path: str, ctx: dict) -> None:
     required_worker_roles = _required_worker_roles(ctx, reviewers)
     worker_prompt_paths = {item: catalog[item]["promptPath"] for item in reviewers}
     related_tasks = json.loads(ctx.get("RELATED_TASKS_JSON", "[]"))
-    workflow = task_manifest.get("workflow", {}) if isinstance(task_manifest.get("workflow"), dict) else {}
+    workflow = (
+        task_manifest.get("workflow", {})
+        if isinstance(task_manifest.get("workflow"), dict)
+        else {}
+    )
     payload = {
         "schemaVersion": "1.0",
         "okstraVersion": ctx.get("OKSTRA_VERSION", ""),
@@ -758,7 +932,9 @@ def render_run_manifest(run_manifest_path: str, ctx: dict) -> None:
         "taskId": ctx.get("TASK_ID", ""),
         "taskKey": ctx.get("TASK_KEY", ""),
         "taskType": ctx.get("ANALYSIS_TYPE", ""),
-        "workCategory": task_manifest.get("workCategory", ctx.get("WORKFLOW_WORK_CATEGORY", "unknown")),
+        "workCategory": task_manifest.get(
+            "workCategory", ctx.get("WORKFLOW_WORK_CATEGORY", "unknown")
+        ),
         "taskBriefPath": ctx.get("BRIEF_RELATIVE_PATH", ""),
         "relatedTasks": related_tasks,
         "recommendedWorkers": reviewers,
@@ -766,7 +942,9 @@ def render_run_manifest(run_manifest_path: str, ctx: dict) -> None:
         "taskManifestPath": ctx.get("TASK_MANIFEST_RELATIVE_PATH", ""),
         "instructionSetPath": ctx.get("INSTRUCTION_SET_RELATIVE_PATH", ""),
         "taskCatalogPath": ctx.get("OKSTRA_TASK_CATALOG_RELATIVE_PATH", ""),
-        "referenceExpectationsPath": ctx.get("REFERENCE_EXPECTATIONS_RELATIVE_PATH", ""),
+        "referenceExpectationsPath": ctx.get(
+            "REFERENCE_EXPECTATIONS_RELATIVE_PATH", ""
+        ),
         "runDirectoryPath": ctx.get("RUN_DIR_RELATIVE_PATH", ""),
         "runDateTimeSegment": ctx.get("RUN_DATETIME_SEGMENT", ""),
         "runSequencesByCategory": {
@@ -792,13 +970,26 @@ def render_run_manifest(run_manifest_path: str, ctx: dict) -> None:
         "resumeCommandPath": ctx.get("CLAUDE_RESUME_COMMAND_RELATIVE_PATH", ""),
         "workflowSnapshot": {
             "phaseSequence": workflow.get("phaseSequence", []),
-            "currentPhase": workflow.get("currentPhase", ctx.get("WORKFLOW_CURRENT_PHASE", "")),
-            "currentPhaseState": workflow.get("currentPhaseState", ctx.get("WORKFLOW_CURRENT_PHASE_STATE", "")),
+            "currentPhase": workflow.get(
+                "currentPhase", ctx.get("WORKFLOW_CURRENT_PHASE", "")
+            ),
+            "currentPhaseState": workflow.get(
+                "currentPhaseState", ctx.get("WORKFLOW_CURRENT_PHASE_STATE", "")
+            ),
             "phaseStates": workflow.get("phaseStates", {}),
-            "lastCompletedPhase": workflow.get("lastCompletedPhase", ctx.get("WORKFLOW_LAST_COMPLETED_PHASE", "")),
-            "nextRecommendedPhase": workflow.get("nextRecommendedPhase", ctx.get("WORKFLOW_NEXT_RECOMMENDED_PHASE", "")),
-            "awaitingApproval": workflow.get("awaitingApproval", ctx.get("WORKFLOW_AWAITING_APPROVAL", "false") == "true"),
-            "routingStatus": workflow.get("routingStatus", ctx.get("WORKFLOW_ROUTING_STATUS", "")),
+            "lastCompletedPhase": workflow.get(
+                "lastCompletedPhase", ctx.get("WORKFLOW_LAST_COMPLETED_PHASE", "")
+            ),
+            "nextRecommendedPhase": workflow.get(
+                "nextRecommendedPhase", ctx.get("WORKFLOW_NEXT_RECOMMENDED_PHASE", "")
+            ),
+            "awaitingApproval": workflow.get(
+                "awaitingApproval",
+                ctx.get("WORKFLOW_AWAITING_APPROVAL", "false") == "true",
+            ),
+            "routingStatus": workflow.get(
+                "routingStatus", ctx.get("WORKFLOW_ROUTING_STATUS", "")
+            ),
             "lastSafeCheckpoint": workflow.get("lastSafeCheckpoint", {}),
         },
         "teamContract": {
@@ -810,7 +1001,8 @@ def render_run_manifest(run_manifest_path: str, ctx: dict) -> None:
             "finalSynthesisOwner": "Claude lead",
             "requiredWorkerAttempts": reviewers,
             "requiredWorkerRoles": required_worker_roles,
-            "requiredAgentStatusEntries": ["Claude lead"] + [catalog[item]["role"] for item in reviewers],
+            "requiredAgentStatusEntries": ["Claude lead"]
+            + [catalog[item]["role"] for item in reviewers],
             "requireDistinctLeadFromClaudeWorker": True,
             "requireAllRequiredWorkerAttempts": True,
             "requireGeminiWorkerAttempt": "gemini" in reviewers,
@@ -867,49 +1059,61 @@ def render_timeline(timeline_path: str, ctx: dict) -> None:
     current_run_manifest_path = ctx.get("RUN_MANIFEST_FILE", "")
     current_run_manifest_relative_path = ctx.get("RUN_MANIFEST_RELATIVE_PATH", "")
     filtered = [
-        item for item in runs
+        item
+        for item in runs
         if item.get("runManifestPath") != current_run_manifest_relative_path
         and item.get("runManifestPath") != current_run_manifest_path
     ]
-    workflow = task_manifest.get("workflow") if isinstance(task_manifest.get("workflow"), dict) else {}
+    workflow = (
+        task_manifest.get("workflow")
+        if isinstance(task_manifest.get("workflow"), dict)
+        else {}
+    )
     workflow = workflow or {}
-    filtered.append({
-        "runTimestamp": ctx.get("RUN_TIMESTAMP_ISO", ""),
-        "runDirectoryPath": ctx.get("RUN_DIR_RELATIVE_PATH", ""),
-        "runManifestPath": ctx.get("RUN_MANIFEST_RELATIVE_PATH", ""),
-        "runDateTimeSegment": ctx.get("RUN_DATETIME_SEGMENT", ""),
-        "runSequencesByCategory": {
-            "manifests": ctx.get("RUN_MANIFESTS_SEQ", ""),
-            "prompts": ctx.get("RUN_PROMPTS_SEQ", ""),
-            "reports": ctx.get("RUN_REPORTS_SEQ", ""),
-            "status": ctx.get("RUN_STATUS_SEQ", ""),
-            "state": ctx.get("RUN_STATE_SEQ", ""),
-            "sessions": ctx.get("RUN_SESSIONS_SEQ", ""),
-            "workerResults": ctx.get("WORKER_RESULTS_SEQ", ""),
-        },
-        "taskType": ctx.get("ANALYSIS_TYPE", ""),
-        "workCategory": task_manifest.get("workCategory", ctx.get("WORKFLOW_WORK_CATEGORY", "unknown")),
-        "status": ctx.get("CURRENT_RUN_STATUS", ""),
-        "taskBriefPath": ctx.get("BRIEF_RELATIVE_PATH", ""),
-        "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},
-        "reportPath": ctx.get("LATEST_REPORT_RELATIVE_PATH") or ctx.get("FINAL_REPORT_RELATIVE_PATH", ""),
-        "teamStatePath": ctx.get("TEAM_STATE_RELATIVE_PATH", ""),
-        "resumeCommandPath": ctx.get("CLAUDE_RESUME_COMMAND_RELATIVE_PATH", ""),
-        "relatedTasks": json.loads(ctx.get("RELATED_TASKS_JSON", "[]")),
-        "workflowSnapshot": {
-            "phaseSequence": workflow.get("phaseSequence", []),
-            "currentPhase": workflow.get("currentPhase", ""),
-            "currentPhaseState": workflow.get("currentPhaseState", ""),
-            "phaseStates": workflow.get("phaseStates", {}),
-            "lastCompletedPhase": workflow.get("lastCompletedPhase", ""),
-            "nextRecommendedPhase": workflow.get("nextRecommendedPhase", ""),
-            "awaitingApproval": workflow.get("awaitingApproval", False),
-            "routingStatus": workflow.get("routingStatus", ""),
-            "lastSafeCheckpoint": workflow.get("lastSafeCheckpoint", {}),
-        },
-    })
+    filtered.append(
+        {
+            "runTimestamp": ctx.get("RUN_TIMESTAMP_ISO", ""),
+            "runDirectoryPath": ctx.get("RUN_DIR_RELATIVE_PATH", ""),
+            "runManifestPath": ctx.get("RUN_MANIFEST_RELATIVE_PATH", ""),
+            "runDateTimeSegment": ctx.get("RUN_DATETIME_SEGMENT", ""),
+            "runSequencesByCategory": {
+                "manifests": ctx.get("RUN_MANIFESTS_SEQ", ""),
+                "prompts": ctx.get("RUN_PROMPTS_SEQ", ""),
+                "reports": ctx.get("RUN_REPORTS_SEQ", ""),
+                "status": ctx.get("RUN_STATUS_SEQ", ""),
+                "state": ctx.get("RUN_STATE_SEQ", ""),
+                "sessions": ctx.get("RUN_SESSIONS_SEQ", ""),
+                "workerResults": ctx.get("WORKER_RESULTS_SEQ", ""),
+            },
+            "taskType": ctx.get("ANALYSIS_TYPE", ""),
+            "workCategory": task_manifest.get(
+                "workCategory", ctx.get("WORKFLOW_WORK_CATEGORY", "unknown")
+            ),
+            "status": ctx.get("CURRENT_RUN_STATUS", ""),
+            "taskBriefPath": ctx.get("BRIEF_RELATIVE_PATH", ""),
+            "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
+            },
+            "reportPath": ctx.get("LATEST_REPORT_RELATIVE_PATH")
+            or ctx.get("FINAL_REPORT_RELATIVE_PATH", ""),
+            "teamStatePath": ctx.get("TEAM_STATE_RELATIVE_PATH", ""),
+            "resumeCommandPath": ctx.get("CLAUDE_RESUME_COMMAND_RELATIVE_PATH", ""),
+            "relatedTasks": json.loads(ctx.get("RELATED_TASKS_JSON", "[]")),
+            "workflowSnapshot": {
+                "phaseSequence": workflow.get("phaseSequence", []),
+                "currentPhase": workflow.get("currentPhase", ""),
+                "currentPhaseState": workflow.get("currentPhaseState", ""),
+                "phaseStates": workflow.get("phaseStates", {}),
+                "lastCompletedPhase": workflow.get("lastCompletedPhase", ""),
+                "nextRecommendedPhase": workflow.get("nextRecommendedPhase", ""),
+                "awaitingApproval": workflow.get("awaitingApproval", False),
+                "routingStatus": workflow.get("routingStatus", ""),
+                "lastSafeCheckpoint": workflow.get("lastSafeCheckpoint", {}),
+            },
+        }
+    )
     payload = {
         "schemaVersion": "1.0",
         "projectId": ctx.get("PROJECT_ID", ""),
@@ -930,20 +1134,35 @@ def render_task_index(template_path: str, output_path: str, ctx: dict) -> None:
             task_manifest = json.loads(task_manifest_path.read_text(encoding="utf-8"))
         except Exception:
             task_manifest = {}
-    workflow = task_manifest.get("workflow", {}) if isinstance(task_manifest.get("workflow"), dict) else {}
-    phase_states = workflow.get("phaseStates", {}) if isinstance(workflow.get("phaseStates"), dict) else {}
+    workflow = (
+        task_manifest.get("workflow", {})
+        if isinstance(task_manifest.get("workflow"), dict)
+        else {}
+    )
+    phase_states = (
+        workflow.get("phaseStates", {})
+        if isinstance(workflow.get("phaseStates"), dict)
+        else {}
+    )
     phase_order = workflow.get("phaseSequence", [])
     if not isinstance(phase_order, list) or not phase_order:
         phase_order = [
-            "requirements-discovery", "error-analysis",
-            "implementation-planning", "implementation", "final-verification",
+            "requirements-discovery",
+            "error-analysis",
+            "implementation-planning",
+            "implementation",
+            "final-verification",
             "release-handoff",
         ]
     phase_state_lines = [
         f"- `{phase}`: `{phase_states.get(phase, 'not-started')}`"
         for phase in phase_order
     ]
-    checkpoint = workflow.get("lastSafeCheckpoint", {}) if isinstance(workflow.get("lastSafeCheckpoint"), dict) else {}
+    checkpoint = (
+        workflow.get("lastSafeCheckpoint", {})
+        if isinstance(workflow.get("lastSafeCheckpoint"), dict)
+        else {}
+    )
     checkpoint_lines = [
         f"- Label: `{checkpoint.get('label', 'unknown')}`",
         f"- Run manifest: `{checkpoint.get('latestRunManifestPath', ctx.get('RUN_MANIFEST_RELATIVE_PATH', ''))}`",
@@ -951,9 +1170,21 @@ def render_task_index(template_path: str, output_path: str, ctx: dict) -> None:
         f"- Report: `{checkpoint.get('latestReportPath', task_manifest.get('latestReportPath', '--')) or '--'}`",
         f"- Resume command: `{checkpoint.get('latestResumeCommandPath', task_manifest.get('latestResumeCommandPath', '--')) or '--'}`",
     ]
-    rc = task_manifest.get("resultContract") if isinstance(task_manifest.get("resultContract"), dict) else {}
-    cv = task_manifest.get("contractValidation") if isinstance(task_manifest.get("contractValidation"), dict) else {}
-    art = task_manifest.get("artifacts") if isinstance(task_manifest.get("artifacts"), dict) else {}
+    rc = (
+        task_manifest.get("resultContract")
+        if isinstance(task_manifest.get("resultContract"), dict)
+        else {}
+    )
+    cv = (
+        task_manifest.get("contractValidation")
+        if isinstance(task_manifest.get("contractValidation"), dict)
+        else {}
+    )
+    art = (
+        task_manifest.get("artifacts")
+        if isinstance(task_manifest.get("artifacts"), dict)
+        else {}
+    )
     mapping = {
         "{{TASK_KEY}}": task_manifest.get("taskKey", ctx.get("TASK_KEY", "")),
         "{{TASK_TYPE}}": task_manifest.get("taskType", ctx.get("ANALYSIS_TYPE", "")),
@@ -961,44 +1192,96 @@ def render_task_index(template_path: str, output_path: str, ctx: dict) -> None:
         "{{PROJECT_ID}}": ctx.get("PROJECT_ID", ""),
         "{{TASK_GROUP}}": ctx.get("TASK_GROUP", ""),
         "{{TASK_ID}}": ctx.get("TASK_ID", ""),
-        "{{CURRENT_TASK_STATUS}}": task_manifest.get("currentStatus", ctx.get("CURRENT_TASK_STATUS", "")),
-        "{{CURRENT_RUN_STATUS}}": task_manifest.get("latestRunStatus", ctx.get("CURRENT_RUN_STATUS", "")),
+        "{{CURRENT_TASK_STATUS}}": task_manifest.get(
+            "currentStatus", ctx.get("CURRENT_TASK_STATUS", "")
+        ),
+        "{{CURRENT_RUN_STATUS}}": task_manifest.get(
+            "latestRunStatus", ctx.get("CURRENT_RUN_STATUS", "")
+        ),
         "{{RELATED_TASKS_INLINE}}": ctx.get("RELATED_TASKS_INLINE", "None"),
-        "{{RECOMMENDED_ANALYSERS}}": ", ".join(task_manifest.get("recommendedWorkers", [])),
+        "{{RECOMMENDED_ANALYSERS}}": ", ".join(
+            task_manifest.get("recommendedWorkers", [])
+        ),
         "{{LEAD_MODEL}}": rc.get("leadModel", ctx.get("LEAD_MODEL_DISPLAY", "")),
         "{{OKSTRA_VERSION}}": ctx.get("OKSTRA_VERSION", ""),
-        "{{LATEST_RUN_RELATIVE_PATH}}": task_manifest.get("latestRunPath", ctx.get("LATEST_RUN_RELATIVE_PATH", "")),
-        "{{LATEST_REPORT_RELATIVE_PATH}}": task_manifest.get("latestReportPath", ctx.get("LATEST_REPORT_RELATIVE_PATH", "")),
-        "{{TEAM_STATE_RELATIVE_PATH}}": task_manifest.get("teamStatePath", ctx.get("TEAM_STATE_RELATIVE_PATH", "")),
-        "{{VALIDATION_STATUS}}": cv.get("status", ctx.get("VALIDATION_STATUS", "not-run")),
-        "{{CLAUDE_RESUME_COMMAND_RELATIVE_PATH}}": task_manifest.get("latestResumeCommandPath", ctx.get("CLAUDE_RESUME_COMMAND_RELATIVE_PATH", "")),
-        "{{MODEL_ASSIGNMENT_LINES}}": "\n".join([
-            f"- `Claude lead`: `{rc.get('leadModel', ctx.get('LEAD_MODEL_DISPLAY', ''))}`",
-            f"- `Claude worker`: `{ctx.get('CLAUDE_WORKER_MODEL_DISPLAY', '')}`",
-            f"- `Codex worker`: `{ctx.get('CODEX_WORKER_MODEL_DISPLAY', '')}`",
-            f"- `Gemini worker`: `{ctx.get('GEMINI_WORKER_MODEL_DISPLAY', '')}`",
-            f"- `Report writer worker`: `{ctx.get('REPORT_WRITER_MODEL_DISPLAY', '')}`",
-        ]),
-        "{{TASK_MANIFEST_RELATIVE_PATH}}": task_manifest.get("taskManifestPath", ctx.get("TASK_MANIFEST_RELATIVE_PATH", "")),
-        "{{OKSTRA_LATEST_TASK_RELATIVE_PATH}}": ctx.get("OKSTRA_LATEST_TASK_RELATIVE_PATH", ""),
-        "{{INSTRUCTION_SET_RELATIVE_PATH}}": task_manifest.get("instructionSetPath", ctx.get("INSTRUCTION_SET_RELATIVE_PATH", "")),
-        "{{REFERENCE_EXPECTATIONS_RELATIVE_PATH}}": task_manifest.get("referenceExpectationsPath", ctx.get("REFERENCE_EXPECTATIONS_RELATIVE_PATH", "")),
-        "{{FINAL_REPORT_TEMPLATE_RELATIVE_PATH}}": art.get("finalReportTemplatePath", ctx.get("FINAL_REPORT_TEMPLATE_RELATIVE_PATH", "")),
+        "{{LATEST_RUN_RELATIVE_PATH}}": task_manifest.get(
+            "latestRunPath", ctx.get("LATEST_RUN_RELATIVE_PATH", "")
+        ),
+        "{{LATEST_REPORT_RELATIVE_PATH}}": task_manifest.get(
+            "latestReportPath", ctx.get("LATEST_REPORT_RELATIVE_PATH", "")
+        ),
+        "{{TEAM_STATE_RELATIVE_PATH}}": task_manifest.get(
+            "teamStatePath", ctx.get("TEAM_STATE_RELATIVE_PATH", "")
+        ),
+        "{{VALIDATION_STATUS}}": cv.get(
+            "status", ctx.get("VALIDATION_STATUS", "not-run")
+        ),
+        "{{CLAUDE_RESUME_COMMAND_RELATIVE_PATH}}": task_manifest.get(
+            "latestResumeCommandPath",
+            ctx.get("CLAUDE_RESUME_COMMAND_RELATIVE_PATH", ""),
+        ),
+        "{{MODEL_ASSIGNMENT_LINES}}": "\n".join(
+            [
+                f"- `Claude lead`: `{rc.get('leadModel', ctx.get('LEAD_MODEL_DISPLAY', ''))}`",
+                f"- `Claude worker`: `{ctx.get('CLAUDE_WORKER_MODEL_DISPLAY', '')}`",
+                f"- `Codex worker`: `{ctx.get('CODEX_WORKER_MODEL_DISPLAY', '')}`",
+                f"- `Gemini worker`: `{ctx.get('GEMINI_WORKER_MODEL_DISPLAY', '')}`",
+                f"- `Report writer worker`: `{ctx.get('REPORT_WRITER_MODEL_DISPLAY', '')}`",
+            ]
+        ),
+        "{{TASK_MANIFEST_RELATIVE_PATH}}": task_manifest.get(
+            "taskManifestPath", ctx.get("TASK_MANIFEST_RELATIVE_PATH", "")
+        ),
+        "{{OKSTRA_LATEST_TASK_RELATIVE_PATH}}": ctx.get(
+            "OKSTRA_LATEST_TASK_RELATIVE_PATH", ""
+        ),
+        "{{INSTRUCTION_SET_RELATIVE_PATH}}": task_manifest.get(
+            "instructionSetPath", ctx.get("INSTRUCTION_SET_RELATIVE_PATH", "")
+        ),
+        "{{REFERENCE_EXPECTATIONS_RELATIVE_PATH}}": task_manifest.get(
+            "referenceExpectationsPath",
+            ctx.get("REFERENCE_EXPECTATIONS_RELATIVE_PATH", ""),
+        ),
+        "{{FINAL_REPORT_TEMPLATE_RELATIVE_PATH}}": art.get(
+            "finalReportTemplatePath",
+            ctx.get("FINAL_REPORT_TEMPLATE_RELATIVE_PATH", ""),
+        ),
         "{{RUN_MANIFESTS_RELATIVE_PATH}}": ctx.get("RUN_MANIFESTS_RELATIVE_PATH", ""),
         "{{RUN_STATE_RELATIVE_PATH}}": ctx.get("RUN_STATE_RELATIVE_PATH", ""),
-        "{{RUN_PROMPTS_RELATIVE_PATH}}": task_manifest.get("latestRunPromptsPath", ctx.get("RUN_PROMPTS_RELATIVE_PATH", "")),
+        "{{RUN_PROMPTS_RELATIVE_PATH}}": task_manifest.get(
+            "latestRunPromptsPath", ctx.get("RUN_PROMPTS_RELATIVE_PATH", "")
+        ),
         "{{RUN_REPORTS_RELATIVE_PATH}}": ctx.get("RUN_REPORTS_RELATIVE_PATH", ""),
         "{{RUN_STATUS_RELATIVE_PATH}}": ctx.get("RUN_STATUS_RELATIVE_PATH", ""),
         "{{RUN_SESSIONS_RELATIVE_PATH}}": ctx.get("RUN_SESSIONS_RELATIVE_PATH", ""),
-        "{{WORKER_RESULTS_RELATIVE_PATH}}": art.get("workerResultsDirectoryPath", ctx.get("WORKER_RESULTS_RELATIVE_PATH", "")),
-        "{{RUN_VALIDATOR_RELATIVE_PATH}}": cv.get("validatorScriptPath", ctx.get("RUN_VALIDATOR_RELATIVE_PATH", "")),
-        "{{WORK_CATEGORY}}": task_manifest.get("workCategory", ctx.get("WORKFLOW_WORK_CATEGORY", "unknown")),
-        "{{WORKFLOW_CURRENT_PHASE}}": workflow.get("currentPhase", ctx.get("WORKFLOW_CURRENT_PHASE", "")),
-        "{{WORKFLOW_CURRENT_PHASE_STATE}}": workflow.get("currentPhaseState", ctx.get("WORKFLOW_CURRENT_PHASE_STATE", "")),
-        "{{WORKFLOW_LAST_COMPLETED_PHASE}}": workflow.get("lastCompletedPhase", ctx.get("WORKFLOW_LAST_COMPLETED_PHASE", "")) or "--",
-        "{{WORKFLOW_NEXT_RECOMMENDED_PHASE}}": workflow.get("nextRecommendedPhase", ctx.get("WORKFLOW_NEXT_RECOMMENDED_PHASE", "")),
-        "{{WORKFLOW_AWAITING_APPROVAL}}": "yes" if workflow.get("awaitingApproval", False) else "no",
-        "{{WORKFLOW_ROUTING_STATUS}}": workflow.get("routingStatus", ctx.get("WORKFLOW_ROUTING_STATUS", "")),
+        "{{WORKER_RESULTS_RELATIVE_PATH}}": art.get(
+            "workerResultsDirectoryPath", ctx.get("WORKER_RESULTS_RELATIVE_PATH", "")
+        ),
+        "{{RUN_VALIDATOR_RELATIVE_PATH}}": cv.get(
+            "validatorScriptPath", ctx.get("RUN_VALIDATOR_RELATIVE_PATH", "")
+        ),
+        "{{WORK_CATEGORY}}": task_manifest.get(
+            "workCategory", ctx.get("WORKFLOW_WORK_CATEGORY", "unknown")
+        ),
+        "{{WORKFLOW_CURRENT_PHASE}}": workflow.get(
+            "currentPhase", ctx.get("WORKFLOW_CURRENT_PHASE", "")
+        ),
+        "{{WORKFLOW_CURRENT_PHASE_STATE}}": workflow.get(
+            "currentPhaseState", ctx.get("WORKFLOW_CURRENT_PHASE_STATE", "")
+        ),
+        "{{WORKFLOW_LAST_COMPLETED_PHASE}}": workflow.get(
+            "lastCompletedPhase", ctx.get("WORKFLOW_LAST_COMPLETED_PHASE", "")
+        )
+        or "--",
+        "{{WORKFLOW_NEXT_RECOMMENDED_PHASE}}": workflow.get(
+            "nextRecommendedPhase", ctx.get("WORKFLOW_NEXT_RECOMMENDED_PHASE", "")
+        ),
+        "{{WORKFLOW_AWAITING_APPROVAL}}": "yes"
+        if workflow.get("awaitingApproval", False)
+        else "no",
+        "{{WORKFLOW_ROUTING_STATUS}}": workflow.get(
+            "routingStatus", ctx.get("WORKFLOW_ROUTING_STATUS", "")
+        ),
         "{{WORKFLOW_PHASE_STATE_LINES}}": "\n".join(phase_state_lines),
         "{{WORKFLOW_LAST_SAFE_CHECKPOINT_LINES}}": "\n".join(checkpoint_lines),
     }
@@ -1008,6 +1291,7 @@ def render_task_index(template_path: str, output_path: str, ctx: dict) -> None:
     rendered = template
     for k, v in mapping.items():
         rendered = rendered.replace(k, v)
+    rendered = _strip_phase_blocks(rendered, ctx.get("ANALYSIS_TYPE", ""))
     _write_text(Path(output_path), rendered.rstrip() + "\n")
 
 
@@ -1055,7 +1339,9 @@ def build_available_mcp_servers_block(project_root: Path) -> str:
         if description:
             parts.append(description)
         if isinstance(tools, list) and tools:
-            tool_names = ", ".join(f"`{str(t).strip()}`" for t in tools if str(t).strip())
+            tool_names = ", ".join(
+                f"`{str(t).strip()}`" for t in tools if str(t).strip()
+            )
             if tool_names:
                 parts.append(f"Tools: {tool_names}")
         if notes:
@@ -1083,7 +1369,9 @@ def render_template_file(template_path: str, output_path: str, ctx: dict) -> Non
 
     worker_result_lines = []
     team_role_lines = [f"  1. `Claude lead` (assigned model: `{lead_model}`)"]
-    model_assignment_lines = [fmt_assignment("Claude lead", lead_model, lead_model_execution)]
+    model_assignment_lines = [
+        fmt_assignment("Claude lead", lead_model, lead_model_execution)
+    ]
     worker_role_labels = []
     execution_status_entries = ["`Claude lead`"]
     execution_status_table_lines = [
@@ -1094,24 +1382,34 @@ def render_template_file(template_path: str, output_path: str, ctx: dict) -> Non
     for index, worker in enumerate(selected, start=2):
         m = catalog[worker]
         worker_result_lines.append(
-            f"- {m['role']} result path: `{m['resultPath']}` (assigned model: `{m['model']}`)")
-        team_role_lines.append(f"  {index}. `{m['role']}` (assigned model: `{m['model']}`)")
-        model_assignment_lines.append(fmt_assignment(m["role"], m["model"], m["modelExecutionValue"]))
+            f"- {m['role']} result path: `{m['resultPath']}` (assigned model: `{m['model']}`)"
+        )
+        team_role_lines.append(
+            f"  {index}. `{m['role']}` (assigned model: `{m['model']}`)"
+        )
+        model_assignment_lines.append(
+            fmt_assignment(m["role"], m["model"], m["modelExecutionValue"])
+        )
         worker_role_labels.append(f"`{m['role']}`")
         execution_status_entries.append(f"`{m['role']}`")
         execution_status_table_lines.append(
-            f"| {m['agentLabel']} | {m['role']} | {m['model']} | completed / timeout / error / not-run | {m['role']}의 핵심 발견 요약 |")
+            f"| {m['agentLabel']} | {m['role']} | {m['model']} | completed / timeout / error / not-run | {m['role']}의 핵심 발견 요약 |"
+        )
 
     if worker_role_labels:
         if len(worker_role_labels) == 1:
-            worker_role_sentence = f"- {worker_role_labels[0]} is the required worker role."
+            worker_role_sentence = (
+                f"- {worker_role_labels[0]} is the required worker role."
+            )
         else:
             worker_role_sentence = (
                 f"- {', '.join(worker_role_labels[:-1])}, "
-                f"and {worker_role_labels[-1]} are the required worker roles.")
+                f"and {worker_role_labels[-1]} are the required worker roles."
+            )
         preferred_results_sentence = (
             f"- Aim to collect completed results from all "
-            f"{len(worker_role_labels)} required workers.")
+            f"{len(worker_role_labels)} required workers."
+        )
     else:
         worker_role_sentence = "- No worker roles were selected for this run."
         preferred_results_sentence = "- No worker results are expected for this run."
@@ -1144,7 +1442,7 @@ def render_template_file(template_path: str, output_path: str, ctx: dict) -> Non
             "## Team Creation Gate (BLOCKING)\n"
             "\n"
             "Before any `Agent` dispatch for workers, you MUST perform Phase 3 of the\n"
-            "`okstra` skill (`agents/SKILL.md` → \"Phase 3 — Team creation\"). Skipping\n"
+            '`okstra` skill (`agents/SKILL.md` → "Phase 3 — Team creation"). Skipping\n'
             "this gate silently degrades the run to in-process background dispatch and\n"
             "loses the Teams split-pane observability surface, even though worker\n"
             "outputs may still appear correct on disk.\n"
@@ -1155,16 +1453,16 @@ def render_template_file(template_path: str, output_path: str, ctx: dict) -> Non
             "\n"
             "1. Invoke the `okstra-team-contract` skill and verify the selected worker\n"
             "   roster against `task-manifest.json`'s `resultContract.requiredWorkerRoles`.\n"
-            f"2. Call `TeamCreate(team_name: \"okstra-{ctx.get('TASK_KEY', '')}\", description: ...)`.\n"
+            f'2. Call `TeamCreate(team_name: "okstra-{ctx.get("TASK_KEY", "")}", description: ...)`.\n'
             "3. Record the outcome in team-state under\n"
-            "   `teamCreate: { attempted: true, status: \"ok\" | \"error\", error?: <msg> }`\n"
+            '   `teamCreate: { attempted: true, status: "ok" | "error", error?: <msg> }`\n'
             "   BEFORE any `Agent(...)` worker dispatch.\n"
             "4. Only after `teamCreate` is persisted may you dispatch workers — with\n"
             "   `team_name` on success, or with `run_in_background: true` and no\n"
-            "   `team_name` ONLY when `teamCreate.status == \"error\"` was recorded.\n"
+            '   `team_name` ONLY when `teamCreate.status == "error"` was recorded.\n'
             "\n"
-            "If the Agent tool rejects a dispatch with `\"team must be created first\"` /\n"
-            "`\"team을 먼저 생성하거나 team_name 없이 호출해야 합니다\"`, the correct\n"
+            'If the Agent tool rejects a dispatch with `"team must be created first"` /\n'
+            '`"team을 먼저 생성하거나 team_name 없이 호출해야 합니다"`, the correct\n'
             "response is to go back to step 2 — NOT to strip `team_name` and retry."
         )
 
@@ -1178,7 +1476,9 @@ def render_template_file(template_path: str, output_path: str, ctx: dict) -> Non
         "{{BRIEF_RELATIVE_PATH}}": ctx.get("BRIEF_RELATIVE_PATH", ""),
         "{{BRIEF_FILE_PATH}}": ctx.get("BRIEF_FILE_PATH", ""),
         "{{CLARIFICATION_RESPONSE_PATH}}": ctx.get("CLARIFICATION_RESPONSE_FILE", ""),
-        "{{CLARIFICATION_RESPONSE_RELATIVE_PATH}}": ctx.get("CLARIFICATION_RESPONSE_RELATIVE_PATH", ""),
+        "{{CLARIFICATION_RESPONSE_RELATIVE_PATH}}": ctx.get(
+            "CLARIFICATION_RESPONSE_RELATIVE_PATH", ""
+        ),
         "{{RUN_DIR}}": ctx.get("RUN_DIR", ""),
         "{{RUN_DIR_RELATIVE_PATH}}": ctx.get("RUN_DIR_RELATIVE_PATH", ""),
         "{{RUN_MANIFESTS_RELATIVE_PATH}}": ctx.get("RUN_MANIFESTS_RELATIVE_PATH", ""),
@@ -1205,31 +1505,63 @@ def render_template_file(template_path: str, output_path: str, ctx: dict) -> Non
         "{{WORKER_RESULTS_RELATIVE_PATH}}": ctx.get("WORKER_RESULTS_RELATIVE_PATH", ""),
         "{{RUN_VALIDATOR_PATH}}": ctx.get("RUN_VALIDATOR_SCRIPT", ""),
         "{{RUN_VALIDATOR_RELATIVE_PATH}}": ctx.get("RUN_VALIDATOR_RELATIVE_PATH", ""),
-        "{{CLAUDE_WORKER_RESULT_RELATIVE_PATH}}": ctx.get("CLAUDE_WORKER_RESULT_RELATIVE_PATH", ""),
-        "{{CODEX_WORKER_RESULT_RELATIVE_PATH}}": ctx.get("CODEX_WORKER_RESULT_RELATIVE_PATH", ""),
-        "{{GEMINI_WORKER_RESULT_RELATIVE_PATH}}": ctx.get("GEMINI_WORKER_RESULT_RELATIVE_PATH", ""),
-        "{{REPORT_WRITER_WORKER_RESULT_RELATIVE_PATH}}": ctx.get("REPORT_WRITER_WORKER_RESULT_RELATIVE_PATH", ""),
+        "{{CLAUDE_WORKER_RESULT_RELATIVE_PATH}}": ctx.get(
+            "CLAUDE_WORKER_RESULT_RELATIVE_PATH", ""
+        ),
+        "{{CODEX_WORKER_RESULT_RELATIVE_PATH}}": ctx.get(
+            "CODEX_WORKER_RESULT_RELATIVE_PATH", ""
+        ),
+        "{{GEMINI_WORKER_RESULT_RELATIVE_PATH}}": ctx.get(
+            "GEMINI_WORKER_RESULT_RELATIVE_PATH", ""
+        ),
+        "{{REPORT_WRITER_WORKER_RESULT_RELATIVE_PATH}}": ctx.get(
+            "REPORT_WRITER_WORKER_RESULT_RELATIVE_PATH", ""
+        ),
         "{{RUN_ERRORS_LOG_PATH}}": ctx.get("RUN_ERRORS_LOG_FILE", ""),
         "{{RUN_ERRORS_LOG_RELATIVE_PATH}}": ctx.get("RUN_ERRORS_LOG_RELATIVE_PATH", ""),
-        "{{CLAUDE_WORKER_ERRORS_SIDECAR_PATH}}": ctx.get("CLAUDE_WORKER_ERRORS_SIDECAR_FILE", ""),
-        "{{CLAUDE_WORKER_ERRORS_SIDECAR_RELATIVE_PATH}}": ctx.get("CLAUDE_WORKER_ERRORS_SIDECAR_RELATIVE_PATH", ""),
-        "{{CODEX_WORKER_ERRORS_SIDECAR_PATH}}": ctx.get("CODEX_WORKER_ERRORS_SIDECAR_FILE", ""),
-        "{{CODEX_WORKER_ERRORS_SIDECAR_RELATIVE_PATH}}": ctx.get("CODEX_WORKER_ERRORS_SIDECAR_RELATIVE_PATH", ""),
-        "{{GEMINI_WORKER_ERRORS_SIDECAR_PATH}}": ctx.get("GEMINI_WORKER_ERRORS_SIDECAR_FILE", ""),
-        "{{GEMINI_WORKER_ERRORS_SIDECAR_RELATIVE_PATH}}": ctx.get("GEMINI_WORKER_ERRORS_SIDECAR_RELATIVE_PATH", ""),
-        "{{REPORT_WRITER_WORKER_ERRORS_SIDECAR_PATH}}": ctx.get("REPORT_WRITER_WORKER_ERRORS_SIDECAR_FILE", ""),
-        "{{REPORT_WRITER_WORKER_ERRORS_SIDECAR_RELATIVE_PATH}}": ctx.get("REPORT_WRITER_WORKER_ERRORS_SIDECAR_RELATIVE_PATH", ""),
+        "{{CLAUDE_WORKER_ERRORS_SIDECAR_PATH}}": ctx.get(
+            "CLAUDE_WORKER_ERRORS_SIDECAR_FILE", ""
+        ),
+        "{{CLAUDE_WORKER_ERRORS_SIDECAR_RELATIVE_PATH}}": ctx.get(
+            "CLAUDE_WORKER_ERRORS_SIDECAR_RELATIVE_PATH", ""
+        ),
+        "{{CODEX_WORKER_ERRORS_SIDECAR_PATH}}": ctx.get(
+            "CODEX_WORKER_ERRORS_SIDECAR_FILE", ""
+        ),
+        "{{CODEX_WORKER_ERRORS_SIDECAR_RELATIVE_PATH}}": ctx.get(
+            "CODEX_WORKER_ERRORS_SIDECAR_RELATIVE_PATH", ""
+        ),
+        "{{GEMINI_WORKER_ERRORS_SIDECAR_PATH}}": ctx.get(
+            "GEMINI_WORKER_ERRORS_SIDECAR_FILE", ""
+        ),
+        "{{GEMINI_WORKER_ERRORS_SIDECAR_RELATIVE_PATH}}": ctx.get(
+            "GEMINI_WORKER_ERRORS_SIDECAR_RELATIVE_PATH", ""
+        ),
+        "{{REPORT_WRITER_WORKER_ERRORS_SIDECAR_PATH}}": ctx.get(
+            "REPORT_WRITER_WORKER_ERRORS_SIDECAR_FILE", ""
+        ),
+        "{{REPORT_WRITER_WORKER_ERRORS_SIDECAR_RELATIVE_PATH}}": ctx.get(
+            "REPORT_WRITER_WORKER_ERRORS_SIDECAR_RELATIVE_PATH", ""
+        ),
         "{{LEAD_MODEL}}": lead_model,
         "{{LEAD_MODEL_EXECUTION_VALUE}}": lead_model_execution,
         "{{OKSTRA_VERSION}}": ctx.get("OKSTRA_VERSION", ""),
         "{{CLAUDE_WORKER_MODEL}}": ctx.get("CLAUDE_WORKER_MODEL_DISPLAY", ""),
-        "{{CLAUDE_WORKER_MODEL_EXECUTION_VALUE}}": ctx.get("CLAUDE_WORKER_MODEL_EXECUTION_VALUE", ""),
+        "{{CLAUDE_WORKER_MODEL_EXECUTION_VALUE}}": ctx.get(
+            "CLAUDE_WORKER_MODEL_EXECUTION_VALUE", ""
+        ),
         "{{CODEX_WORKER_MODEL}}": ctx.get("CODEX_WORKER_MODEL_DISPLAY", ""),
-        "{{CODEX_WORKER_MODEL_EXECUTION_VALUE}}": ctx.get("CODEX_WORKER_MODEL_EXECUTION_VALUE", ""),
+        "{{CODEX_WORKER_MODEL_EXECUTION_VALUE}}": ctx.get(
+            "CODEX_WORKER_MODEL_EXECUTION_VALUE", ""
+        ),
         "{{GEMINI_WORKER_MODEL}}": ctx.get("GEMINI_WORKER_MODEL_DISPLAY", ""),
-        "{{GEMINI_WORKER_MODEL_EXECUTION_VALUE}}": ctx.get("GEMINI_WORKER_MODEL_EXECUTION_VALUE", ""),
+        "{{GEMINI_WORKER_MODEL_EXECUTION_VALUE}}": ctx.get(
+            "GEMINI_WORKER_MODEL_EXECUTION_VALUE", ""
+        ),
         "{{REPORT_WRITER_MODEL}}": ctx.get("REPORT_WRITER_MODEL_DISPLAY", ""),
-        "{{REPORT_WRITER_MODEL_EXECUTION_VALUE}}": ctx.get("REPORT_WRITER_MODEL_EXECUTION_VALUE", ""),
+        "{{REPORT_WRITER_MODEL_EXECUTION_VALUE}}": ctx.get(
+            "REPORT_WRITER_MODEL_EXECUTION_VALUE", ""
+        ),
         "{{WORKER_RESULT_PATH_LINES}}": "\n".join(worker_result_lines),
         "{{MODEL_ASSIGNMENT_LINES}}": "\n".join(model_assignment_lines),
         "{{TEAM_ROLE_LINES}}": "\n".join(team_role_lines),
@@ -1239,30 +1571,48 @@ def render_template_file(template_path: str, output_path: str, ctx: dict) -> Non
         "{{EXECUTION_STATUS_EXACT_ENTRIES}}": ", ".join(execution_status_entries),
         "{{EXECUTION_STATUS_TABLE_ROWS}}": "\n".join(execution_status_table_lines),
         "{{FINAL_REPORT_TEMPLATE_PATH}}": ctx.get("FINAL_REPORT_TEMPLATE_FILE", ""),
-        "{{FINAL_REPORT_TEMPLATE_RELATIVE_PATH}}": ctx.get("FINAL_REPORT_TEMPLATE_RELATIVE_PATH", ""),
-        "{{REFERENCE_EXPECTATIONS_RELATIVE_PATH}}": ctx.get("REFERENCE_EXPECTATIONS_RELATIVE_PATH", ""),
+        "{{FINAL_REPORT_TEMPLATE_RELATIVE_PATH}}": ctx.get(
+            "FINAL_REPORT_TEMPLATE_RELATIVE_PATH", ""
+        ),
+        "{{REFERENCE_EXPECTATIONS_RELATIVE_PATH}}": ctx.get(
+            "REFERENCE_EXPECTATIONS_RELATIVE_PATH", ""
+        ),
         "{{CLAUDE_SESSION_ID}}": ctx.get("CLAUDE_SESSION_ID", ""),
         "{{CLAUDE_RESUME_COMMAND_PATH}}": ctx.get("CLAUDE_RESUME_COMMAND_FILE", ""),
-        "{{CLAUDE_RESUME_COMMAND_RELATIVE_PATH}}": ctx.get("CLAUDE_RESUME_COMMAND_RELATIVE_PATH", ""),
+        "{{CLAUDE_RESUME_COMMAND_RELATIVE_PATH}}": ctx.get(
+            "CLAUDE_RESUME_COMMAND_RELATIVE_PATH", ""
+        ),
         "{{TASK_ROOT_RELATIVE_PATH}}": ctx.get("TASK_ROOT_RELATIVE_PATH", ""),
         "{{TASK_MANIFEST_RELATIVE_PATH}}": ctx.get("TASK_MANIFEST_RELATIVE_PATH", ""),
         "{{TASK_INDEX_RELATIVE_PATH}}": ctx.get("TASK_INDEX_RELATIVE_PATH", ""),
-        "{{INSTRUCTION_SET_RELATIVE_PATH}}": ctx.get("INSTRUCTION_SET_RELATIVE_PATH", ""),
+        "{{INSTRUCTION_SET_RELATIVE_PATH}}": ctx.get(
+            "INSTRUCTION_SET_RELATIVE_PATH", ""
+        ),
         "{{RUNS_RELATIVE_PATH}}": ctx.get("RUNS_RELATIVE_PATH", ""),
         "{{HISTORY_RELATIVE_PATH}}": ctx.get("HISTORY_RELATIVE_PATH", ""),
-        "{{OKSTRA_DISCOVERY_RELATIVE_PATH}}": ctx.get("OKSTRA_DISCOVERY_RELATIVE_PATH", ""),
-        "{{OKSTRA_LATEST_TASK_RELATIVE_PATH}}": ctx.get("OKSTRA_LATEST_TASK_RELATIVE_PATH", ""),
-        "{{OKSTRA_TASK_CATALOG_RELATIVE_PATH}}": ctx.get("OKSTRA_TASK_CATALOG_RELATIVE_PATH", ""),
+        "{{OKSTRA_DISCOVERY_RELATIVE_PATH}}": ctx.get(
+            "OKSTRA_DISCOVERY_RELATIVE_PATH", ""
+        ),
+        "{{OKSTRA_LATEST_TASK_RELATIVE_PATH}}": ctx.get(
+            "OKSTRA_LATEST_TASK_RELATIVE_PATH", ""
+        ),
+        "{{OKSTRA_TASK_CATALOG_RELATIVE_PATH}}": ctx.get(
+            "OKSTRA_TASK_CATALOG_RELATIVE_PATH", ""
+        ),
         "{{LATEST_RUN_RELATIVE_PATH}}": ctx.get("LATEST_RUN_RELATIVE_PATH", ""),
         "{{LATEST_REPORT_RELATIVE_PATH}}": ctx.get("LATEST_REPORT_RELATIVE_PATH", ""),
         "{{TIMELINE_RELATIVE_PATH}}": ctx.get("TIMELINE_RELATIVE_PATH", ""),
         "{{CURRENT_TASK_STATUS}}": ctx.get("CURRENT_TASK_STATUS", ""),
         "{{CURRENT_RUN_STATUS}}": ctx.get("CURRENT_RUN_STATUS", ""),
         "{{VALIDATION_STATUS}}": ctx.get("VALIDATION_STATUS", "not-run"),
-        "{{RELATED_TASKS_BULLETS}}": ctx.get("RELATED_TASKS_BULLETS", "- None recorded"),
+        "{{RELATED_TASKS_BULLETS}}": ctx.get(
+            "RELATED_TASKS_BULLETS", "- None recorded"
+        ),
         "{{RELATED_TASKS_INLINE}}": ctx.get("RELATED_TASKS_INLINE", "None"),
         "{{WORKFLOW_CURRENT_PHASE}}": ctx.get("WORKFLOW_CURRENT_PHASE", ""),
-        "{{WORKFLOW_NEXT_RECOMMENDED_PHASE}}": ctx.get("WORKFLOW_NEXT_RECOMMENDED_PHASE", ""),
+        "{{WORKFLOW_NEXT_RECOMMENDED_PHASE}}": ctx.get(
+            "WORKFLOW_NEXT_RECOMMENDED_PHASE", ""
+        ),
         "{{PHASE_ALLOWED_OUTPUTS}}": ctx.get("PHASE_ALLOWED_OUTPUTS", ""),
         "{{PHASE_FORBIDDEN_ACTIONS}}": ctx.get("PHASE_FORBIDDEN_ACTIONS", ""),
         "{{AVAILABLE_MCP_SERVERS}}": ctx.get(
@@ -1281,6 +1631,7 @@ def render_template_file(template_path: str, output_path: str, ctx: dict) -> Non
     rendered = template
     for k, v in mapping.items():
         rendered = rendered.replace(k, v)
+    rendered = _strip_phase_blocks(rendered, ctx.get("ANALYSIS_TYPE", ""))
     _write_text(Path(output_path), rendered.rstrip() + "\n")