okstra 0.34.1 → 0.36.1

package/runtime/python/lib/okstra/globals.sh

@@ -4,7 +4,7 @@ PROFILE_DIR="$WORKSPACE_ROOT/prompts/profiles"
 PROMPT_TEMPLATE="$WORKSPACE_ROOT/prompts/launch.template.md"
 TASK_INDEX_TEMPLATE="$WORKSPACE_ROOT/templates/project-docs/task-index.template.md"
 FINAL_REPORT_TEMPLATE_SOURCE="$WORKSPACE_ROOT/templates/reports/final-report.template.md"
-RUN_VALIDATOR_SCRIPT="$WORKSPACE_ROOT/validators/validate-run.py"
+RUN_VALIDATOR_PATH="$WORKSPACE_ROOT/validators/validate-run.py"
 SOURCE_CLAUDE_OKSTRA_SKILL="$WORKSPACE_ROOT/agents/SKILL.md"
 OKSTRA_ROOT=""
 OKSTRA_TASKS_ROOT=""
@@ -27,14 +27,14 @@ EXECUTOR_OVERRIDE=""
 WORK_CATEGORY=""
 BASE_REF=""
 RELATED_TASKS_RAW=""
-ANALYSIS_TYPE=""
+TASK_TYPE=""
 BRIEF_PATH=""
 PROJECT_ID=""
 TASK_GROUP=""
 TASK_ID=""
 TASK_KEY_INPUT=""
 TASK_KEY=""
-REVIEW_PROFILE=""
+ANALYSIS_PROFILE=""
 DIRECTIVE=""
 CLARIFICATION_RESPONSE_PATH=""
 APPROVED_PLAN_PATH=""
@@ -42,7 +42,7 @@ APPROVE_PLAN_ACK="false"
 # Phase 6 plan-body verification toggle. Default "true" (round runs).
 # Flipped to "false" by --no-plan-verification on the CLI.
 PLAN_VERIFICATION_ENABLED="true"
-CLARIFICATION_RESPONSE_FILE=""
+CLARIFICATION_RESPONSE_PATH=""
 CLARIFICATION_RESPONSE_RELATIVE_PATH=""
 PROJECT_ROOT=""
 PROJECT_ROOT_OVERRIDE=""
@@ -50,17 +50,17 @@ PROFILE_FILE=""
 BRIEF_FILE_PATH=""
 REVIEW_MATERIAL=""
 PROFILE_CONTENT=""
-SELECTED_REVIEWERS=""
+RECOMMENDED_ANALYSERS=""
 BRIEF_RELATIVE_PATH=""
 TASK_GROUP_SEGMENT=""
 TASK_ID_SEGMENT=""
 TASK_ROOT=""
-TASK_MANIFEST_FILE=""
-TASK_INDEX_FILE=""
-INSTRUCTION_SET_DIR=""
+TASK_MANIFEST_PATH=""
+TASK_INDEX_PATH=""
+INSTRUCTION_SET_PATH=""
 RUNS_DIR=""
 HISTORY_DIR=""
-TIMELINE_FILE=""
+TIMELINE_PATH=""
 RUN_DIR=""
 RUN_MANIFESTS_DIR=""
 RUN_STATE_DIR=""
@@ -69,7 +69,7 @@ RUN_REPORTS_DIR=""
 RUN_STATUS_DIR=""
 RUN_SESSIONS_DIR=""
 RUN_LOGS_DIR=""
-RUN_MANIFEST_FILE=""
+RUN_MANIFEST_PATH=""
 RUN_MANIFEST_RELATIVE_PATH=""
 RUN_PROMPT_SNAPSHOT_FILE=""
 RUN_PROMPT_SNAPSHOT_RELATIVE_PATH=""
@@ -81,17 +81,17 @@ GEMINI_WORKER_PROMPT_FILE=""
 GEMINI_WORKER_PROMPT_RELATIVE_PATH=""
 REPORT_WRITER_WORKER_PROMPT_FILE=""
 REPORT_WRITER_WORKER_PROMPT_RELATIVE_PATH=""
-FINAL_REPORT_FILE=""
-FINAL_STATUS_FILE=""
+FINAL_REPORT_PATH=""
+FINAL_STATUS_PATH=""
 FINAL_REPORT_RELATIVE_PATH=""
 FINAL_STATUS_RELATIVE_PATH=""
-FINAL_REPORT_TEMPLATE_FILE=""
+FINAL_REPORT_TEMPLATE_PATH=""
 FINAL_REPORT_TEMPLATE_RELATIVE_PATH=""
 REFERENCE_EXPECTATIONS_FILE=""
 REFERENCE_EXPECTATIONS_RELATIVE_PATH=""
-TEAM_STATE_FILE=""
+TEAM_STATE_PATH=""
 TEAM_STATE_RELATIVE_PATH=""
-WORKER_RESULTS_DIR=""
+WORKER_RESULTS_PATH=""
 WORKER_RESULTS_RELATIVE_PATH=""
 RUN_VALIDATOR_RELATIVE_PATH=""
 CLAUDE_WORKER_RESULT_FILE=""
@@ -103,7 +103,7 @@ GEMINI_WORKER_RESULT_RELATIVE_PATH=""
 REPORT_WRITER_WORKER_RESULT_FILE=""
 REPORT_WRITER_WORKER_RESULT_RELATIVE_PATH=""
 CLAUDE_SESSION_ID=""
-CLAUDE_RESUME_COMMAND_FILE=""
+CLAUDE_RESUME_COMMAND_PATH=""
 CLAUDE_RESUME_COMMAND_RELATIVE_PATH=""
 RUN_TIMESTAMP_ISO=""
 RUN_DATETIME_SEGMENT=""
@@ -143,15 +143,15 @@ RELATED_TASKS_JSON="[]"
 RELATED_TASKS_BULLETS="- None recorded"
 RELATED_TASKS_INLINE="None"
 PROMPT=""
-LEAD_MODEL_DISPLAY=""
+LEAD_MODEL=""
 LEAD_MODEL_EXECUTION_VALUE=""
-CLAUDE_WORKER_MODEL_DISPLAY=""
+CLAUDE_WORKER_MODEL=""
 CLAUDE_WORKER_MODEL_EXECUTION_VALUE=""
-CODEX_WORKER_MODEL_DISPLAY=""
+CODEX_WORKER_MODEL=""
 CODEX_WORKER_MODEL_EXECUTION_VALUE=""
-GEMINI_WORKER_MODEL_DISPLAY=""
+GEMINI_WORKER_MODEL=""
 GEMINI_WORKER_MODEL_EXECUTION_VALUE=""
-REPORT_WRITER_MODEL_DISPLAY=""
+REPORT_WRITER_MODEL=""
 REPORT_WRITER_MODEL_EXECUTION_VALUE=""
 DEFAULT_WORKERS="claude,codex,report-writer"
 DEFAULT_LEAD_MODEL_NAME="${OKSTRA_DEFAULT_LEAD_MODEL:-opus-4-6}"

package/runtime/python/lib/okstra/interactive.sh

@@ -152,7 +152,7 @@ autofill_from_manifest() {
   if [[ -z "$PROJECT_ID" ]]; then
     return 0
   fi
-  if [[ -n "$BRIEF_PATH" && -n "$ANALYSIS_TYPE" ]]; then
+  if [[ -n "$BRIEF_PATH" && -n "$TASK_TYPE" ]]; then
     return 0
   fi
   if [[ -z "$TASK_GROUP" || -z "$TASK_ID" ]]; then
@@ -176,7 +176,7 @@ autofill_from_manifest() {
 
   local need_brief_val need_type_val
   need_brief_val="$([[ -z "$BRIEF_PATH" ]] && printf '1' || printf '0')"
-  need_type_val="$([[ -z "$ANALYSIS_TYPE" ]] && printf '1' || printf '0')"
+  need_type_val="$([[ -z "$TASK_TYPE" ]] && printf '1' || printf '0')"
   local autofill_output=""
   autofill_output="$(python3 - "$manifest_path" "$need_brief_val" "$need_type_val" <<'PY'
 import json, sys
@@ -217,9 +217,9 @@ PY
     BRIEF_PATH="$manifest_brief"
     printf 'autofill: brief-path from task-manifest.json: %s\n' "$BRIEF_PATH" >&2
   fi
-  if [[ -z "$ANALYSIS_TYPE" && -n "$manifest_type" ]]; then
-    ANALYSIS_TYPE="$manifest_type"
-    printf 'autofill: task-type from manifest workflow.nextRecommendedPhase: %s\n' "$ANALYSIS_TYPE" >&2
+  if [[ -z "$TASK_TYPE" && -n "$manifest_type" ]]; then
+    TASK_TYPE="$manifest_type"
+    printf 'autofill: task-type from manifest workflow.nextRecommendedPhase: %s\n' "$TASK_TYPE" >&2
   fi
 }
 
@@ -229,7 +229,7 @@ missing_required_arguments_summary() {
   [[ -z "$PROJECT_ID" ]] && missing+=("<project-id>")
   [[ -z "$TASK_GROUP" ]] && missing+=("<task-group>")
   [[ -z "$TASK_ID" ]] && missing+=("<task-id>")
-  [[ -z "$ANALYSIS_TYPE" ]] && missing+=("<task-type>")
+  [[ -z "$TASK_TYPE" ]] && missing+=("<task-type>")
   [[ -z "$BRIEF_PATH" ]] && missing+=("<brief-path>")
 
   if (( ${#missing[@]} == 0 )); then
@@ -349,7 +349,7 @@ run_resume_clarification() {
 
   local lookup_result=""
   if ! lookup_result="$(find_latest_final_report \
-        "$resume_project_root" "$TASK_GROUP" "$TASK_ID" "${ANALYSIS_TYPE-}")"; then
+        "$resume_project_root" "$TASK_GROUP" "$TASK_ID" "${TASK_TYPE-}")"; then
     exit 1
   fi
   local report_path="${lookup_result%$'\t'*}"

package/runtime/python/okstra_ctl/clarification_items.py

@@ -5,8 +5,8 @@ single section) is the canonical home for every clarification an
 implementation-planning run owes the user — decisions, file attachments,
 single data points. Each row carries a ``Blocks`` column whose value picks
 one of ``{approval, next-phase, none}``. Rows with ``Blocks=approval`` are
-the approval gate: they MUST resolve before the user marks the report
-``Approved`` and starts the next ``implementation`` run.
+the approval gate: they MUST resolve before the user flips the frontmatter
+``approved`` field to ``true`` and starts the next ``implementation`` run.
 
 This module exposes one read function for that gate so both
 ``_validate_approved_plan`` (pre-implementation run-prep) and any later
@@ -168,7 +168,7 @@ UNRESOLVED_STATUSES = {"open", "answered"}
 
 
 def unresolved_approval_blockers(report_text: str) -> Optional[list[ClarificationItem]]:
-    """Return rows that gate the User Approval Request — ``Blocks=approval``
+    """Return rows that gate the frontmatter ``approved`` flag — ``Blocks=approval``
     AND ``Status`` in ``{open, answered}``.
 
     ``None`` propagates the "schema absent" signal from
@@ -182,9 +182,3 @@ def unresolved_approval_blockers(report_text: str) -> Optional[list[Clarificatio
         it for it in items
         if it.blocks == "approval" and it.status in UNRESOLVED_STATUSES
     ]
-
-
-def unresolved_approval_blockers_in_file(path: Path) -> Optional[list[ClarificationItem]]:
-    return unresolved_approval_blockers(
-        Path(path).read_text(encoding="utf-8", errors="replace")
-    )

package/runtime/python/okstra_ctl/consumers.py

@@ -0,0 +1,53 @@
+"""Append-only writer / reader for `consumers.jsonl` under a plan run's task root.
+
+A row's identity for idempotency is the tuple
+    (impl_task_key, stage, status)
+so the same (started / done) record is never duplicated."""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+from typing import Any, Dict, List
+
+from .run_context import consumers_mutex
+
+CONSUMERS_FILENAME = "consumers.jsonl"
+
+
+def _path(plan_run_root: Path) -> Path:
+    return plan_run_root / CONSUMERS_FILENAME
+
+
+def read_consumers(plan_run_root: Path) -> List[Dict[str, Any]]:
+    p = _path(plan_run_root)
+    if not p.exists():
+        return []
+    out = []
+    for line in p.read_text(encoding="utf-8").splitlines():
+        line = line.strip()
+        if not line:
+            continue
+        out.append(json.loads(line))
+    return out
+
+
+def append_consumer(plan_run_root: Path, *, impl_task_key: str, stage: int,
+                    status: str, **fields: Any) -> None:
+    if status not in ("started", "done"):
+        raise ValueError(f"status must be 'started' or 'done', got: {status!r}")
+    with consumers_mutex(plan_run_root.name):
+        existing = read_consumers(plan_run_root)
+        for row in existing:
+            if (row.get("impl_task_key") == impl_task_key
+                    and row.get("stage") == stage
+                    and row.get("status") == status):
+                return  # idempotent
+        record: Dict[str, Any] = {
+            "impl_task_key": impl_task_key,
+            "stage": stage,
+            "status": status,
+            **fields,
+        }
+        with _path(plan_run_root).open("a", encoding="utf-8") as f:
+            f.write(json.dumps(record, ensure_ascii=False) + "\n")

package/runtime/python/okstra_ctl/final_report_schema.py

@@ -244,10 +244,3 @@ def load_schema(schema_path: Path | None = None) -> dict:
                 "could not locate schemas/final-report-v1.0.schema.json"
             )
     return json.loads(Path(schema_path).read_text(encoding="utf-8"))
-
-
-def validate_data_file(data_path: Path, schema_path: Path | None = None) -> list[str]:
-    """Convenience wrapper: read data.json, return validation errors."""
-    schema = load_schema(schema_path)
-    data = json.loads(Path(data_path).read_text(encoding="utf-8"))
-    return validate(data, schema)

package/runtime/python/okstra_ctl/i18n.py

@@ -0,0 +1,73 @@
+"""Final-report i18n dictionary loader + Jinja2 lookup function.
+
+사전은 ``templates/reports/i18n/<lang>.json`` 에 둔다. ChainableUndefined
+환경에서도 누락 키가 silent 로 빈 문자열이 되지 않도록 lookup 함수가
+직접 raise 한다.
+"""
+from __future__ import annotations
+
+import json
+import os
+from pathlib import Path
+from typing import Any, Callable
+
+SUPPORTED_LANGS = ("en", "ko")
+DICTIONARY_REL = ("templates", "reports", "i18n")
+
+
+class I18nError(RuntimeError):
+    """사전 lookup 실패 또는 사전 로드 실패."""
+
+
+def _i18n_dir() -> Path:
+    okstra_home = os.environ.get("OKSTRA_HOME")
+    if okstra_home:
+        candidate = Path(okstra_home).joinpath(*DICTIONARY_REL)
+        if candidate.is_dir():
+            return candidate
+    here = Path(__file__).resolve()
+    for parent in [here, *here.parents]:
+        candidate = parent.joinpath(*DICTIONARY_REL)
+        if candidate.is_dir():
+            return candidate
+    raise I18nError(
+        "could not locate templates/reports/i18n/. Set OKSTRA_HOME or "
+        "run from a checkout that contains templates/reports/i18n/."
+    )
+
+
+def load_dictionary(lang: str) -> dict[str, Any]:
+    if lang not in SUPPORTED_LANGS:
+        raise I18nError(
+            f"unsupported reportLanguage {lang!r}; supported: {SUPPORTED_LANGS}"
+        )
+    path = _i18n_dir() / f"{lang}.json"
+    try:
+        return json.loads(path.read_text(encoding="utf-8"))
+    except (OSError, json.JSONDecodeError) as exc:
+        raise I18nError(f"failed to load {path}: {exc}") from exc
+
+
+def lookup(dictionary: dict[str, Any], dotted_key: str) -> str:
+    parts = dotted_key.split(".")
+    cur: Any = dictionary
+    for i, part in enumerate(parts):
+        if not isinstance(cur, dict):
+            raise I18nError(
+                f"i18n key {dotted_key!r}: segment {'.'.join(parts[:i]) or '<root>'!r} "
+                f"is not a dict (got {type(cur).__name__})"
+            )
+        if part not in cur:
+            raise I18nError(f"i18n key {dotted_key!r} not found in dictionary")
+        cur = cur[part]
+    if not isinstance(cur, str):
+        raise I18nError(
+            f"i18n key {dotted_key!r} resolved to {type(cur).__name__}, expected str"
+        )
+    return cur
+
+
+def make_jinja_global(dictionary: dict[str, Any]) -> Callable[[str], str]:
+    def t(dotted_key: str) -> str:
+        return lookup(dictionary, dotted_key)
+    return t

package/runtime/python/okstra_ctl/improvement_lenses.py

@@ -0,0 +1,44 @@
+"""Improvement-discovery phase SSOT: lens enum and cap constants.
+
+profile / brief skill / validator / wizard MUST import from this module.
+Re-defining the enum anywhere else violates the single-reference-point rule
+and is rejected by tests/test_okstra_improvement_lenses.py.
+"""
+from __future__ import annotations
+
+LENSES: tuple[str, ...] = (
+    "performance",
+    "security",
+    "readability",
+    "architecture",
+    "test-coverage",
+    "dx",
+    "observability",
+    "accessibility",
+)
+
+DEFAULT_CANDIDATE_CAP = 8
+ABSOLUTE_CANDIDATE_CAP = 12
+MIN_PRIORITY_LENSES = 1
+MAX_PRIORITY_LENSES = 4
+
+# report-writer is the AUTHOR of the final report; it never produces source
+# findings. validators reject `report-writer:<id>` entries in Source workers.
+SOURCE_WORKERS: tuple[str, ...] = ("claude", "codex", "gemini")
+
+
+def is_valid_lens(value: str) -> bool:
+    return value in LENSES
+
+
+def is_valid_lens_subset(values: list[str]) -> bool:
+    if not (MIN_PRIORITY_LENSES <= len(values) <= MAX_PRIORITY_LENSES):
+        return False
+    return all(v in LENSES for v in values)
+
+
+def is_within_candidate_cap(count: int, *, brief_cap: int | None) -> bool:
+    cap = brief_cap if brief_cap is not None else DEFAULT_CANDIDATE_CAP
+    if cap < 1 or cap > ABSOLUTE_CANDIDATE_CAP:
+        return False
+    return 1 <= count <= cap

package/runtime/python/okstra_ctl/index.py

@@ -87,7 +87,7 @@ def record_start(home: Path, *, project_id: str, project_root: str,
         "leadModel": lead_model,
         "validation": "not-run",
         "finalReportRel": final_report_rel,
-        # FINAL_STATUS_FILE 의 카운터(RUN_STATUS_SEQ) 는 RUN_MANIFESTS_SEQ
+        # FINAL_STATUS_PATH 의 카운터(RUN_STATUS_SEQ) 는 RUN_MANIFESTS_SEQ
         # 와 별개로 advance 한다(render-only/실패 prep 은 manifest 만 증가).
         # 따라서 status 파일을 추적할 때는 manifest seq 를 추정해 glob 으로
         # 찾지 말고 run 시작 시점의 정식 경로를 row 에 박아 두고 사용한다.

package/runtime/python/okstra_ctl/paths.py

@@ -4,8 +4,8 @@ Inputs: project root, identity (project-id/task-group/task-id), task-type,
 workspace root, optional run-seq override.
 
 Output: dict with every path value the bash render-context used to expose as
-environment variables (TASK_ROOT, RUN_DIR, RUN_MANIFESTS_DIR, RUN_MANIFEST_FILE,
-FINAL_REPORT_FILE, ...). 호출자가 이 dict 를 그대로 인자로 사용하거나
+environment variables (TASK_ROOT, RUN_DIR, RUN_MANIFESTS_DIR, RUN_MANIFEST_PATH,
+FINAL_REPORT_PATH, ...). 호출자가 이 dict 를 그대로 인자로 사용하거나
 `write_run_context()` 로 디스크에 박는다.
 
 이 모듈은 read-only 한 path 계산만 담당한다. 디렉터리 생성, 파일 쓰기,
@@ -104,6 +104,7 @@ def compute_run_paths(
     run_sessions = run_dir / "sessions"
     run_logs = run_dir / "logs"
     worker_results = run_dir / "worker-results"
+    run_carry = run_dir / "carry"
 
     if run_seq_override is not None:
         seq_int = int(run_seq_override)
@@ -158,20 +159,23 @@ def compute_run_paths(
         "TASK_GROUP": task_group,
         "TASK_ID": task_id,
         "TASK_KEY": f"{project_id}:{task_group}:{task_id}",
-        "ANALYSIS_TYPE": task_type,
+        "TASK_TYPE": task_type,
         "TASK_GROUP_SEGMENT": task_group_segment,
         "TASK_ID_SEGMENT": task_id_segment,
         "TASK_TYPE_SEGMENT": task_type_segment,
         "OKSTRA_ROOT": str(okstra_root),
         "OKSTRA_TASKS_ROOT": str(tasks_root),
+        "WORKER_PROMPT_PREAMBLE_PATH": str(
+            Path.home() / ".okstra" / "templates" / "worker-prompt-preamble.md"
+        ),
         "OKSTRA_DISCOVERY_DIR": str(discovery_dir),
         "TASK_ROOT": str(task_root),
-        "TASK_MANIFEST_FILE": str(task_manifest),
-        "TASK_INDEX_FILE": str(task_index),
-        "INSTRUCTION_SET_DIR": str(instruction_set),
+        "TASK_MANIFEST_PATH": str(task_manifest),
+        "TASK_INDEX_PATH": str(task_index),
+        "INSTRUCTION_SET_PATH": str(instruction_set),
         "RUNS_DIR": str(runs_dir),
         "HISTORY_DIR": str(history_dir),
-        "TIMELINE_FILE": str(timeline_file),
+        "TIMELINE_PATH": str(timeline_file),
         "RUN_DIR": str(run_dir),
         "RUN_MANIFESTS_DIR": str(run_manifests),
         "RUN_STATE_DIR": str(run_state),
@@ -180,31 +184,32 @@ def compute_run_paths(
         "RUN_STATUS_DIR": str(run_status),
         "RUN_SESSIONS_DIR": str(run_sessions),
         "RUN_LOGS_DIR": str(run_logs),
-        "WORKER_RESULTS_DIR": str(worker_results),
-        "RUN_MANIFEST_FILE": str(run_manifest_file),
+        "WORKER_RESULTS_PATH": str(worker_results),
+        "RUN_CARRY_PATH": str(run_carry),
+        "RUN_MANIFEST_PATH": str(run_manifest_file),
         "RUN_PROMPT_SNAPSHOT_FILE": str(run_prompt_snapshot),
         "CLAUDE_WORKER_PROMPT_FILE": str(claude_worker_prompt),
         "CODEX_WORKER_PROMPT_FILE": str(codex_worker_prompt),
         "GEMINI_WORKER_PROMPT_FILE": str(gemini_worker_prompt),
         "REPORT_WRITER_WORKER_PROMPT_FILE": str(report_writer_worker_prompt),
-        "FINAL_REPORT_FILE": str(final_report),
-        "FINAL_STATUS_FILE": str(final_status),
-        "TEAM_STATE_FILE": str(team_state),
-        "FINAL_REPORT_TEMPLATE_FILE": str(final_report_template),
+        "FINAL_REPORT_PATH": str(final_report),
+        "FINAL_STATUS_PATH": str(final_status),
+        "TEAM_STATE_PATH": str(team_state),
+        "FINAL_REPORT_TEMPLATE_PATH": str(final_report_template),
         "REFERENCE_EXPECTATIONS_FILE": str(reference_expectations),
-        "CLAUDE_RESUME_COMMAND_FILE": str(claude_resume_command),
+        "CLAUDE_RESUME_COMMAND_PATH": str(claude_resume_command),
         "OKSTRA_LATEST_TASK_FILE": str(latest_task_file),
         "OKSTRA_TASK_CATALOG_FILE": str(task_catalog_file),
         "CLAUDE_WORKER_RESULT_FILE": str(claude_worker_result),
         "CODEX_WORKER_RESULT_FILE": str(codex_worker_result),
         "GEMINI_WORKER_RESULT_FILE": str(gemini_worker_result),
         "REPORT_WRITER_WORKER_RESULT_FILE": str(report_writer_worker_result),
-        "RUN_ERRORS_LOG_FILE": str(run_errors_log),
-        "CLAUDE_WORKER_ERRORS_SIDECAR_FILE": str(claude_worker_errors_sidecar),
-        "CODEX_WORKER_ERRORS_SIDECAR_FILE": str(codex_worker_errors_sidecar),
-        "GEMINI_WORKER_ERRORS_SIDECAR_FILE": str(gemini_worker_errors_sidecar),
-        "REPORT_WRITER_WORKER_ERRORS_SIDECAR_FILE": str(report_writer_worker_errors_sidecar),
-        "RUN_VALIDATOR_SCRIPT": str(run_validator_script),
+        "RUN_ERRORS_LOG_PATH": str(run_errors_log),
+        "CLAUDE_WORKER_ERRORS_SIDECAR_PATH": str(claude_worker_errors_sidecar),
+        "CODEX_WORKER_ERRORS_SIDECAR_PATH": str(codex_worker_errors_sidecar),
+        "GEMINI_WORKER_ERRORS_SIDECAR_PATH": str(gemini_worker_errors_sidecar),
+        "REPORT_WRITER_WORKER_ERRORS_SIDECAR_PATH": str(report_writer_worker_errors_sidecar),
+        "RUN_VALIDATOR_PATH": str(run_validator_script),
         "RUN_MANIFEST_FILENAME": run_manifest_file.name,
         "RUN_PROMPT_SNAPSHOT_FILENAME": run_prompt_snapshot.name,
         "FINAL_REPORT_FILENAME": final_report.name,
@@ -248,6 +253,7 @@ def compute_run_paths(
         ("FINAL_STATUS_RELATIVE_PATH", final_status),
         ("TEAM_STATE_RELATIVE_PATH", team_state),
         ("WORKER_RESULTS_RELATIVE_PATH", worker_results),
+        ("RUN_CARRY_RELATIVE_PATH", run_carry),
         ("FINAL_REPORT_TEMPLATE_RELATIVE_PATH", final_report_template),
         ("REFERENCE_EXPECTATIONS_RELATIVE_PATH", reference_expectations),
         ("CLAUDE_RESUME_COMMAND_RELATIVE_PATH", claude_resume_command),