okstra 0.102.3 → 0.102.4

package/docs/kr/architecture/storage-model.md

@@ -158,6 +158,7 @@ scripts/okstra.sh workflow가 사용하는 project-local Claude assets는 아래
 - `workflow.awaitingApproval`
 - `workflow.routingStatus`
 - `workflow.lastSafeCheckpoint`
+- `phaseOutcome` *(artifact-derived semantic phase outcome; 예: implementation carry 가 모든 stage 통과를 증명하면 run contract validation 실패가 남아 있어도 implementation phase outcome 은 completed 로 기록될 수 있음)*
 - `inputs`
 - `artifacts`
 - `resultContract`
@@ -197,7 +198,11 @@ canonical metadata는 항상 `task-manifest.json`을 기준으로 확인합니
 
 각 실행은 `runs/<task-type>/manifests/run-manifest-<task-type>-<seq>.json`에 현재 run 계약을 남깁니다.
 
-`manifests/run-manifest-<task-type>-<seq>.json`의 path 계열 필드는 모두 대상 프로젝트 루트 기준 상대경로만 저장합니다.
+`manifests/run-context-<task-type>-<seq>.json`은 schemaVersion `2.0`부터 모든 legacy path key를 직접 저장하지 않고 `identity` + `pathHints`를 저장합니다. host-side reader는 `pathHints`를 hydrate해 기존 flat key(`RUN_MANIFEST_RELATIVE_PATH`, `TEAM_STATE_PATH` 등)를 메모리에서 재구성합니다.
+
+`state/active-run-context-<task-type>-<seq>.json`도 schemaVersion `2.0`부터 lead Phase 1용 compact intake입니다. 반복 path 문자열 대신 `identity` + `pathHints`와 worker identity만 저장하고, deterministic dispatcher는 읽을 때 legacy active context shape로 hydrate합니다.
+
+`manifests/run-manifest-<task-type>-<seq>.json`의 path 계열 필드는 아직 validator / team dispatch / inspect 호환을 위해 대상 프로젝트 루트 기준 상대경로로 저장합니다.
 `okstra`가 Claude handoff를 시작한 직후에는 현재 run 상태가 보통 `in-progress`로 기록됩니다.
 이후 최종 결과 저장과 상태 갱신은 Claude가 이어서 수행합니다.
 또한 `okstra`는 launch 전에 session ID를 선할당하고, 같은 run의 `sessions/` 아래에 `claude-resume-<task-type>-<seq>.sh`를 생성합니다.
@@ -253,7 +258,7 @@ canonical metadata는 항상 `task-manifest.json`을 기준으로 확인합니
 1. task browsing 또는 task-id disambiguation이 필요하면 `.okstra/discovery/task-catalog.json`을 먼저 읽습니다.
 2. 현재 task key나 task path가 명시되지 않았다면 `.okstra/discovery/latest-task.json`을 current-task pointer로 읽습니다.
 3. `task-manifest.json`을 읽습니다.
-4. current `state/active-run-context-<task-type>-<seq>.json`이 있으면 lead Phase 1의 1차 입력으로 읽습니다. 없으면 current `manifests/run-manifest-<task-type>-<seq>.json`과 `team-state`로 fallback합니다.
+4. current `state/active-run-context-<task-type>-<seq>.json`이 있으면 lead Phase 1의 1차 입력으로 읽습니다. 이 파일은 `identity` + `pathHints` 단서로 run artifact 경로를 재구성하는 compact intake입니다. 없으면 current `manifests/run-manifest-<task-type>-<seq>.json`과 `team-state`로 fallback합니다.
 5. `instruction-set/analysis-profile.md`와 `instruction-set/analysis-packet.md`를 읽습니다.
 6. `task-index.md`는 quick summary가 필요할 때만 선택적으로 읽습니다.
 7. `analysis-material.md`, `reference-expectations.md`, `task-brief.md`, `final-report-template.md`는 packet이 불충분하거나 source citation/보고서 작성에 필요할 때 lazy read합니다.

package/docs/kr/architecture.md

@@ -190,7 +190,7 @@ per-process 환경 변수에 task 정체성·경로·workflow 상태를 보관
 | task 후보 목록 | `<PROJECT_ROOT>/.okstra/discovery/task-catalog.json` |
 | 최신 task 포인터 | `<PROJECT_ROOT>/.okstra/discovery/latest-task.json` |
 | run 입력값 | `<run-dir>/manifests/run-inputs-<task-type>-<seq>.json` |
-| run paths / seq | `<run-dir>/manifests/run-context-<task-type>-<seq>.json` |
+| run path hints / seq | `<run-dir>/manifests/run-context-<task-type>-<seq>.json` |
 | run 이력 | `<task-root>/history/timeline.json` |
 | 글로벌 인덱스 | `~/.okstra/{active,recent}.jsonl`, `~/.okstra/projects/<id>/{index.jsonl, meta.json}` |
 
@@ -198,7 +198,7 @@ per-process 환경 변수에 task 정체성·경로·workflow 상태를 보관
 
 두 종류의 파일 락이 모든 동시성을 처리합니다.
 
-- `~/.okstra/.locks/<task-key>.lock` — per-task mutex. `compute_and_write_run_context` 가 seq 계산과 `run-context.json` 영속화를 한 트랜잭션으로 묶음. 같은 task 의 두 호출은 직렬화.
+- `~/.okstra/.locks/<task-key>.lock` — per-task mutex. `compute_and_write_run_context` 가 seq 계산과 compact `run-context.json` 영속화를 한 트랜잭션으로 묶음. 같은 task 의 두 호출은 직렬화.
 - `~/.okstra/.lock` — 중앙 인덱스 mutex. `record_start` / `reconcile` / `rotate_recent_if_needed` 에서 사용.
 
 다른 (project, task-group, task-id) 사이에는 직렬화가 없습니다 — 디스크 경로가 분리되므로 충돌 자체가 없음. 환경 변수 race 가 사라졌으므로 같은 claude 세션이 여러 task 를 병렬 진행해도 안전.
@@ -604,6 +604,7 @@ scripts/okstra.sh --task-key <project-id>:<task-group>:<task-id> --task-type fin
 - `workflow.awaitingApproval`
 - `workflow.routingStatus`
 - `workflow.lastSafeCheckpoint`
+- `phaseOutcome`
 
 프로젝트 전체 상태를 훑을 때는 `.okstra/discovery/task-catalog.json`을 사용합니다.
 특정 task의 최신 상태를 볼 때는 `.okstra/discovery/latest-task.json`, `task-manifest.json`, 최신 `run-manifest`, `history/timeline.json` 순서로 확인합니다.
@@ -716,6 +717,8 @@ phase 산출물의 출고 가능 여부를 강제하는 진입점:
 
 각 validator 는 contract 위반 시 `contract-violated` exit code 로 phase 를 차단합니다. 위반은 다음 phase 실행 시점에 적용되므로 이전 산출물은 그대로 둡니다.
 
+`contractValidation.status=failed`는 run artifact contract 실패를 뜻하며, 구현 결과 자체가 항상 미완이라는 뜻은 아닙니다. implementation run 은 `runs/implementation/carry/stage-<N>.json`, `runs/implementation-planning/consumers.jsonl`, 승인된 Stage Map 을 함께 읽어 `phaseOutcome.implementation`을 도출합니다. 모든 Stage Map stage 가 pass-grade carry evidence 를 가지면 contract failure 는 감사 정보로 유지하면서 `workflow.nextRecommendedPhase`를 `final-verification`으로 보정할 수 있습니다.
+
 ## Practical notes
 
 - `okstra`는 brief 없이 쓰는 옛 방식이 아닙니다.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "okstra",
-  "version": "0.102.3",
+  "version": "0.102.4",
   "description": "Multi-agent cross-verification orchestrator runtime + Claude Code skills.",
   "license": "MIT",
   "author": "devonshin",

package/runtime/BUILD.json

@@ -1,5 +1,5 @@
 {
-  "package": "0.102.3",
-  "builtAt": "2026-06-25T09:16:07.810Z",
+  "package": "0.102.4",
+  "builtAt": "2026-06-25T17:22:51.416Z",
   "repoRoot": "/home/runner/work/okstra/okstra"
 }

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

@@ -189,6 +189,18 @@ autofill_from_manifest() {
     return 0
   fi
 
+  PYTHONPATH="$WORKSPACE_ROOT/scripts:${PYTHONPATH-}" python3 - "$manifest_project_root" "$manifest_task_root" <<'PY' || true
+import sys
+from pathlib import Path
+
+from okstra_ctl.implementation_outcome import reconcile_implementation_outcome
+
+try:
+    reconcile_implementation_outcome(Path(sys.argv[1]), Path(sys.argv[2]))
+except Exception:
+    pass
+PY
+
   local need_brief_val need_type_val
   need_brief_val="$([[ -z "$BRIEF_PATH" ]] && printf '1' || printf '0')"
   need_type_val="$([[ -z "$TASK_TYPE" ]] && printf '1' || printf '0')"

package/runtime/python/okstra_ctl/codex_dispatch.py

@@ -23,6 +23,7 @@ from .final_report_paths import (
     final_report_markdown_path as _final_report_markdown_path,
 )
 from .lead_events import LeadEvent, append_lead_event
+from .path_hints import hydrate_active_run_context
 from .wrapper_status import status_path_for_prompt
 from .paths import task_dir
 from .worker_prompt_headers import WorkerPromptHeaderError, worker_prompt_headers
@@ -1402,7 +1403,7 @@ def _load_json_object(path: Path, label: str) -> dict[str, Any]:
 def _load_optional_json_object(path: Path | None) -> dict[str, Any]:
     if path is None or not path.is_file():
         return {}
-    return _load_json_object(path, "active-run-context")
+    return hydrate_active_run_context(_load_json_object(path, "active-run-context"))
 
 
 def _resolve_required_path(

package/runtime/python/okstra_ctl/dispatch_core.py

@@ -16,6 +16,7 @@ from .final_report_paths import (
     final_report_markdown_path as _final_report_markdown_path,
 )
 from .lead_events import LeadEvent, append_lead_event
+from .path_hints import hydrate_active_run_context
 from .worker_prompt_headers import WorkerPromptHeaderError, worker_prompt_headers
 from .wrapper_status import read_wrapper_status, status_path_for_prompt
 
@@ -868,7 +869,9 @@ def _load_optional_json(project_root: Path, value: Any) -> dict[str, Any]:
     if not isinstance(value, str) or not value.strip():
         return {}
     path = _resolve_project_path(project_root, value)
-    return _load_json_object(path, "active-run-context") if path.is_file() else {}
+    if not path.is_file():
+        return {}
+    return hydrate_active_run_context(_load_json_object(path, "active-run-context"))
 
 
 def _resolve_required_path(project_root: Path, manifest: Mapping[str, Any], key: str) -> Path:

package/runtime/python/okstra_ctl/implementation_outcome.py

@@ -0,0 +1,271 @@
+"""Artifact-derived implementation phase outcome reconciliation."""
+from __future__ import annotations
+
+import json
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Any
+
+from .consumers import read_stage_consumer_state
+from .workflow import DEFAULT_NEXT_PHASE, PHASE_SEQUENCE
+
+
+@dataclass(frozen=True)
+class ImplementationOutcome:
+    completed: bool
+    stages: list[int] = field(default_factory=list)
+    head_commit: str = ""
+    report_path: str = ""
+    next_recommended_phase: str = ""
+    reason: str = ""
+
+
+def derive_implementation_outcome(task_root: Path) -> ImplementationOutcome:
+    task_root = Path(task_root)
+    manifest = _load_json(task_root / "task-manifest.json")
+    workflow = manifest.get("workflow") if isinstance(manifest.get("workflow"), dict) else {}
+    if workflow.get("currentPhase") != "implementation":
+        return ImplementationOutcome(completed=False, reason="current phase is not implementation")
+
+    plan_run_root = task_root / "runs" / "implementation-planning"
+    if not plan_run_root.is_dir():
+        return ImplementationOutcome(completed=False, reason="implementation-planning run root missing")
+
+    stage_map = _load_stage_map(task_root, manifest)
+    if not stage_map:
+        return ImplementationOutcome(completed=False, reason="stage map unavailable")
+
+    consumers = read_stage_consumer_state(plan_run_root, recover_from_carry=True)
+    required_stages = {stage["stage_number"] for stage in stage_map}
+    if not required_stages or not required_stages.issubset(consumers.done_stages):
+        return ImplementationOutcome(completed=False, reason="not all stages are done")
+
+    carries = [_load_carry(task_root, stage) for stage in sorted(required_stages)]
+    if any(carry is None for carry in carries):
+        return ImplementationOutcome(completed=False, reason="carry sidecar missing")
+    if any(not _carry_passed(carry) for carry in carries if carry is not None):
+        return ImplementationOutcome(completed=False, reason="carry sidecar is not pass-grade")
+
+    latest_stage = max(required_stages)
+    latest_done = consumers.done_by_stage.get(latest_stage) or {}
+    latest_carry = carries[-1] or {}
+    return ImplementationOutcome(
+        completed=True,
+        stages=sorted(required_stages),
+        head_commit=str(latest_done.get("head_commit") or "") or _carry_head_commit(latest_carry),
+        report_path=_latest_implementation_report(task_root),
+        next_recommended_phase=DEFAULT_NEXT_PHASE["implementation"],
+        reason="all implementation stages have pass-grade carry and done rows",
+    )
+
+
+def reconcile_implementation_outcome(project_root: Path, task_root: Path) -> bool:
+    project_root = Path(project_root)
+    task_root = Path(task_root)
+    outcome = derive_implementation_outcome(task_root)
+    if not outcome.completed:
+        return False
+
+    manifest_path = task_root / "task-manifest.json"
+    manifest = _load_json(manifest_path)
+    workflow = manifest.get("workflow")
+    if not isinstance(workflow, dict):
+        workflow = {}
+        manifest["workflow"] = workflow
+
+    changed = _promote_workflow(workflow, outcome)
+    phase_outcome = manifest.get("phaseOutcome")
+    if not isinstance(phase_outcome, dict):
+        phase_outcome = {}
+        manifest["phaseOutcome"] = phase_outcome
+
+    contract = manifest.get("contractValidation")
+    contract_status = contract.get("status", "") if isinstance(contract, dict) else ""
+    implementation = {
+        "state": "completed",
+        "source": "implementation-carry",
+        "stages": outcome.stages,
+        "headCommit": outcome.head_commit,
+        "reportPath": outcome.report_path,
+        "contractValidationStatus": contract_status,
+        "reason": outcome.reason,
+    }
+    if phase_outcome.get("implementation") != implementation:
+        phase_outcome["implementation"] = implementation
+        changed = True
+
+    if changed:
+        _write_json(manifest_path, manifest)
+    return changed or _update_task_catalog(project_root, manifest)
+
+
+def _load_json(path: Path) -> dict[str, Any]:
+    if not path.is_file():
+        return {}
+    try:
+        data = json.loads(path.read_text(encoding="utf-8"))
+    except json.JSONDecodeError:
+        return {}
+    return data if isinstance(data, dict) else {}
+
+
+def _load_stage_map(task_root: Path, manifest: dict[str, Any]) -> list[dict[str, Any]]:
+    plan_path = _source_plan_path(task_root, manifest)
+    if not plan_path.is_file():
+        return []
+    from .run import PrepareError, _load_parsed_stage_map, _stage_map_reject_detail
+
+    try:
+        stages, errs = _load_parsed_stage_map(plan_path.read_text(encoding="utf-8"))
+    except PrepareError:
+        return []
+    if _stage_map_reject_detail(stages, errs) is not None:
+        return []
+    return [
+        {
+            "stage_number": stage.stage_number,
+            "title": stage.title,
+            "depends_on": list(stage.depends_on),
+            "step_count": stage.step_count,
+        }
+        for stage in stages
+    ]
+
+
+def _source_plan_path(task_root: Path, manifest: dict[str, Any]) -> Path:
+    carry_dir = task_root / "runs" / "implementation" / "carry"
+    for carry_path in sorted(carry_dir.glob("stage-*.json")):
+        value = _load_json(carry_path).get("sourcePlanPath")
+        if isinstance(value, str) and value:
+            return _resolve_relative(task_root, value)
+
+    latest = manifest.get("latestReportPath")
+    if isinstance(latest, str) and "implementation-planning" in latest:
+        return _resolve_relative(task_root, latest)
+
+    reports = task_root / "runs" / "implementation-planning" / "reports"
+    candidates = sorted(reports.glob("final-report-implementation-planning-*.md"))
+    return candidates[-1] if candidates else Path()
+
+
+def _resolve_relative(task_root: Path, value: str) -> Path:
+    path = Path(value)
+    if path.is_absolute():
+        return path
+    project_root = _project_root_from_task_root(task_root)
+    project_relative = project_root / path
+    if project_relative.exists():
+        return project_relative
+    task_relative = task_root / path
+    if task_relative.exists():
+        return task_relative
+    return project_relative
+
+
+def _project_root_from_task_root(task_root: Path) -> Path:
+    parts = task_root.resolve().parts
+    if ".okstra" not in parts:
+        return task_root.resolve()
+    return Path(*parts[: parts.index(".okstra")])
+
+
+def _load_carry(task_root: Path, stage: int) -> dict[str, Any] | None:
+    data = _load_json(task_root / "runs" / "implementation" / "carry" / f"stage-{stage}.json")
+    return data or None
+
+
+def _carry_passed(carry: dict[str, Any]) -> bool:
+    status = str(carry.get("status") or "").lower()
+    if status in {"fail", "failed", "blocked", "error", "aborted"}:
+        return False
+    conformance = carry.get("conformance")
+    if isinstance(conformance, dict):
+        overall = str(conformance.get("overall") or "").upper()
+        if overall and overall != "PASS":
+            return False
+    unverified = carry.get("unverified")
+    return not (isinstance(unverified, list) and unverified)
+
+
+def _carry_head_commit(carry: dict[str, Any]) -> str:
+    stage_range = carry.get("stageCommitRange")
+    if isinstance(stage_range, dict) and stage_range.get("head"):
+        return str(stage_range["head"])
+    for key in ("head_sha", "head_commit", "head"):
+        value = carry.get(key)
+        if value:
+            return str(value)
+    commits = carry.get("commits")
+    if isinstance(commits, list) and commits:
+        last = commits[-1]
+        if isinstance(last, dict) and last.get("sha"):
+            return str(last["sha"])
+    return ""
+
+
+def _latest_implementation_report(task_root: Path) -> str:
+    reports = sorted(
+        (task_root / "runs" / "implementation").glob(
+            "stage-*/reports/final-report-implementation-*.md"
+        )
+    )
+    if not reports:
+        return ""
+    project_root = _project_root_from_task_root(task_root)
+    try:
+        return str(reports[-1].relative_to(project_root))
+    except ValueError:
+        return str(reports[-1])
+
+
+def _promote_workflow(workflow: dict[str, Any], outcome: ImplementationOutcome) -> bool:
+    before = json.dumps(workflow, sort_keys=True, ensure_ascii=False)
+    phase_states = workflow.get("phaseStates")
+    if not isinstance(phase_states, dict):
+        phase_states = {}
+        workflow["phaseStates"] = phase_states
+    for phase in PHASE_SEQUENCE:
+        phase_states.setdefault(phase, "not-started")
+    workflow["currentPhase"] = "implementation"
+    workflow["currentPhaseState"] = "completed"
+    phase_states["implementation"] = "completed"
+    workflow["lastCompletedPhase"] = "implementation"
+    workflow["nextRecommendedPhase"] = outcome.next_recommended_phase
+    after = json.dumps(workflow, sort_keys=True, ensure_ascii=False)
+    return before != after
+
+
+def _update_task_catalog(project_root: Path, manifest: dict[str, Any]) -> bool:
+    catalog_path = project_root / ".okstra" / "discovery" / "task-catalog.json"
+    catalog = _load_json(catalog_path)
+    tasks = catalog.get("tasks")
+    if not isinstance(tasks, list):
+        return False
+    task_key = manifest.get("taskKey")
+    workflow = manifest.get("workflow") if isinstance(manifest.get("workflow"), dict) else {}
+    outcome = manifest.get("phaseOutcome") if isinstance(manifest.get("phaseOutcome"), dict) else {}
+    for entry in tasks:
+        if not isinstance(entry, dict) or entry.get("taskKey") != task_key:
+            continue
+        before = json.dumps(entry, sort_keys=True, ensure_ascii=False)
+        entry["currentPhase"] = workflow.get("currentPhase", "")
+        entry["currentPhaseState"] = workflow.get("currentPhaseState", "")
+        entry["lastCompletedPhase"] = workflow.get("lastCompletedPhase", "")
+        entry["nextRecommendedPhase"] = workflow.get("nextRecommendedPhase", "")
+        entry["latestReportPath"] = manifest.get("latestReportPath", "")
+        entry["latestRunStatus"] = manifest.get("latestRunStatus", entry.get("latestRunStatus", ""))
+        entry["currentStatus"] = manifest.get("currentStatus", entry.get("currentStatus", ""))
+        entry["phaseOutcome"] = outcome
+        if before == json.dumps(entry, sort_keys=True, ensure_ascii=False):
+            return False
+        _write_json(catalog_path, catalog)
+        return True
+    return False
+
+
+def _write_json(path: Path, payload: dict[str, Any]) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text(
+        json.dumps(payload, ensure_ascii=False, indent=2) + "\n",
+        encoding="utf-8",
+    )

package/runtime/python/okstra_ctl/path_hints.py

@@ -0,0 +1,665 @@
+"""Compact path-hint persistence and legacy context hydration."""
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any, Mapping
+
+from okstra_project.dirs import (
+    DISCOVERY_RELATIVE,
+    OKSTRA_RELATIVE,
+    TASKS_RELATIVE,
+    okstra_home,
+)
+
+RUN_CONTEXT_KIND = "run-context"
+RUN_CONTEXT_SCHEMA_VERSION = "2.0"
+ACTIVE_CONTEXT_KIND = "active-run-context"
+
+
+def compact_run_context(ctx: Mapping[str, Any]) -> dict[str, Any]:
+    """Persist only path clues that can rehydrate the legacy flat context."""
+    return {
+        "schemaVersion": RUN_CONTEXT_SCHEMA_VERSION,
+        "kind": RUN_CONTEXT_KIND,
+        "identity": _compact_identity(ctx),
+        "pathHints": {
+            "project": _compact_project_hints(),
+            "task": {
+                "taskRoot": ctx.get("TASK_ROOT_RELATIVE_PATH", ""),
+            },
+            "run": _compact_run_hints(ctx),
+            "runtime": {
+                "okstraHome": str(okstra_home()),
+            },
+        },
+        "timestamps": {
+            "runTimestampIso": ctx.get("RUN_TIMESTAMP_ISO", ""),
+            "taskDate": ctx.get("TASK_DATE", ""),
+        },
+    }
+
+
+def compact_active_run_context(
+    ctx: Mapping[str, Any],
+    payload: Mapping[str, Any],
+) -> dict[str, Any]:
+    """Persist active-run-context with path hints instead of repeated paths."""
+    run_context = compact_run_context(ctx)
+    return {
+        "schemaVersion": RUN_CONTEXT_SCHEMA_VERSION,
+        "kind": ACTIVE_CONTEXT_KIND,
+        "identity": run_context["identity"],
+        "pathHints": run_context["pathHints"],
+        "task": _compact_active_task(payload),
+        "workflow": dict(_mapping(payload.get("workflow"))),
+        "run": {
+            "stage": ctx.get("RUN_STAGE", ""),
+        },
+        "inputs": _compact_active_inputs(payload),
+        "workers": _compact_active_workers(payload),
+        "executorWorktree": dict(_mapping(payload.get("executorWorktree"))),
+        "lazyReadPlan": dict(_mapping(payload.get("lazyReadPlan"))),
+    }
+
+
+def hydrate_run_context(payload: Mapping[str, Any]) -> dict[str, Any]:
+    """Return the legacy flat context for compact run-context payloads."""
+    if payload.get("kind") != RUN_CONTEXT_KIND:
+        return dict(payload)
+    hints = payload.get("pathHints")
+    identity = payload.get("identity")
+    if not isinstance(hints, Mapping) or not isinstance(identity, Mapping):
+        return dict(payload)
+    return _hydrate_from_hints(identity, hints, payload.get("timestamps", {}))
+
+
+def hydrate_active_run_context(payload: Mapping[str, Any]) -> dict[str, Any]:
+    """Return the legacy active-run-context shape for compact payloads."""
+    if payload.get("kind") != ACTIVE_CONTEXT_KIND or "pathHints" not in payload:
+        return dict(payload)
+    identity = _mapping(payload.get("identity"))
+    hints = _mapping(payload.get("pathHints"))
+    ctx = hydrate_run_context({
+        "kind": RUN_CONTEXT_KIND,
+        "identity": identity,
+        "pathHints": hints,
+        "timestamps": {},
+    })
+    return {
+        "schemaVersion": "1.0",
+        "kind": ACTIVE_CONTEXT_KIND,
+        "task": _hydrate_active_task(payload, ctx),
+        "workflow": dict(_mapping(payload.get("workflow"))),
+        "run": _hydrate_active_run(ctx),
+        "instructionSet": _hydrate_active_instruction_set(payload, ctx),
+        "workers": _hydrate_active_workers(payload, ctx),
+        "errorLogs": _hydrate_active_error_logs(ctx),
+        "runtimeResources": {
+            "codingPreflightDir": ctx.get("OKSTRA_CODING_PREFLIGHT_DIR", ""),
+        },
+        "executorWorktree": dict(_mapping(payload.get("executorWorktree"))),
+        "sourceArtifacts": _hydrate_active_source_artifacts(ctx),
+        "lazyReadPlan": dict(_mapping(payload.get("lazyReadPlan"))),
+    }
+
+
+def _compact_identity(ctx: Mapping[str, Any]) -> dict[str, Any]:
+    return {
+        "projectId": ctx.get("PROJECT_ID", ""),
+        "projectRoot": ctx.get("PROJECT_ROOT", ""),
+        "workspaceRoot": ctx.get("WORKSPACE_ROOT", ""),
+        "taskGroup": ctx.get("TASK_GROUP", ""),
+        "taskId": ctx.get("TASK_ID", ""),
+        "taskKey": ctx.get("TASK_KEY", ""),
+        "taskType": ctx.get("TASK_TYPE", ""),
+        "segments": {
+            "taskGroup": ctx.get("TASK_GROUP_SEGMENT", ""),
+            "taskId": ctx.get("TASK_ID_SEGMENT", ""),
+            "taskType": ctx.get("TASK_TYPE_SEGMENT", ""),
+        },
+    }
+
+
+def _compact_active_task(payload: Mapping[str, Any]) -> dict[str, Any]:
+    task = _mapping(payload.get("task"))
+    keep = (
+        "projectId", "taskGroup", "taskId", "taskKey", "taskType",
+        "workCategory", "projectRoot",
+    )
+    return {key: task.get(key, "") for key in keep}
+
+
+def _compact_active_inputs(payload: Mapping[str, Any]) -> dict[str, bool]:
+    instruction_set = _mapping(payload.get("instructionSet"))
+    return {
+        "hasClarificationResponse": bool(instruction_set.get("clarificationResponsePath")),
+    }
+
+
+def _compact_active_workers(payload: Mapping[str, Any]) -> list[dict[str, Any]]:
+    workers = payload.get("workers")
+    if not isinstance(workers, list):
+        return []
+    return [_compact_active_worker(worker) for worker in workers if isinstance(worker, Mapping)]
+
+
+def _compact_active_worker(worker: Mapping[str, Any]) -> dict[str, Any]:
+    keep = (
+        "workerId", "role", "agent", "agentLabel", "model",
+        "modelExecutionValue", "attemptRequired",
+    )
+    return {key: worker.get(key, "") for key in keep}
+
+
+def _compact_project_hints() -> dict[str, str]:
+    return {
+        "okstraRoot": str(OKSTRA_RELATIVE),
+        "tasksRoot": str(TASKS_RELATIVE),
+        "discoveryRoot": str(DISCOVERY_RELATIVE),
+    }
+
+
+def _hydrate_active_task(payload: Mapping[str, Any], ctx: Mapping[str, str]) -> dict[str, str]:
+    task = dict(_mapping(payload.get("task")))
+    task["taskRootPath"] = ctx.get("TASK_ROOT_RELATIVE_PATH", "")
+    return task
+
+
+def _hydrate_active_run(ctx: Mapping[str, str]) -> dict[str, str]:
+    return {
+        "runDirectoryPath": ctx.get("RUN_DIR_RELATIVE_PATH", ""),
+        "runManifestPath": ctx.get("RUN_MANIFEST_RELATIVE_PATH", ""),
+        "teamStatePath": ctx.get("TEAM_STATE_RELATIVE_PATH", ""),
+        "promptSnapshotPath": ctx.get("RUN_PROMPT_SNAPSHOT_RELATIVE_PATH", ""),
+        "finalReportPath": ctx.get("FINAL_REPORT_RELATIVE_PATH", ""),
+        "finalStatusPath": ctx.get("FINAL_STATUS_RELATIVE_PATH", ""),
+        "validatorScriptPath": ctx.get("RUN_VALIDATOR_RELATIVE_PATH", ""),
+        "resumeCommandPath": ctx.get("CLAUDE_RESUME_COMMAND_RELATIVE_PATH", ""),
+        "workerPromptsDirectoryPath": ctx.get("RUN_PROMPTS_RELATIVE_PATH", ""),
+        "workerResultsDirectoryPath": ctx.get("WORKER_RESULTS_RELATIVE_PATH", ""),
+    }
+
+
+def _hydrate_active_instruction_set(
+    payload: Mapping[str, Any],
+    ctx: Mapping[str, str],
+) -> dict[str, str]:
+    instruction_set = ctx.get("INSTRUCTION_SET_RELATIVE_PATH", "")
+    inputs = _mapping(payload.get("inputs"))
+    clarification_response = ""
+    if inputs.get("hasClarificationResponse"):
+        clarification_response = f"{instruction_set}/clarification-response.md"
+    return {
+        "path": instruction_set,
+        "analysisPacketPath": ctx.get("ANALYSIS_PACKET_RELATIVE_PATH", ""),
+        "taskBriefPath": f"{instruction_set}/task-brief.md",
+        "analysisProfilePath": f"{instruction_set}/analysis-profile.md",
+        "analysisMaterialPath": f"{instruction_set}/analysis-material.md",
+        "referenceExpectationsPath": ctx.get("REFERENCE_EXPECTATIONS_RELATIVE_PATH", ""),
+        "clarificationResponsePath": clarification_response,
+        "finalReportTemplatePath": ctx.get("FINAL_REPORT_TEMPLATE_RELATIVE_PATH", ""),
+        "finalReportSchemaPath": ctx.get("FINAL_REPORT_SCHEMA_RELATIVE_PATH", ""),
+    }
+
+
+def _hydrate_active_workers(
+    payload: Mapping[str, Any],
+    ctx: Mapping[str, str],
+) -> list[dict[str, Any]]:
+    workers = payload.get("workers")
+    if not isinstance(workers, list):
+        return []
+    return [
+        _hydrate_active_worker(worker, ctx)
+        for worker in workers
+        if isinstance(worker, Mapping)
+    ]
+
+
+def _hydrate_active_worker(
+    worker: Mapping[str, Any],
+    ctx: Mapping[str, str],
+) -> 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"), "")
+    return hydrated
+
+
+def _hydrate_active_error_logs(ctx: Mapping[str, str]) -> dict[str, Any]:
+    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", ""),
+        },
+    }
+
+
+def _hydrate_active_source_artifacts(ctx: Mapping[str, str]) -> dict[str, str]:
+    return {
+        "taskManifestPath": ctx.get("TASK_MANIFEST_RELATIVE_PATH", ""),
+        "runContextPath": ctx.get("RUN_CONTEXT_RELATIVE_PATH", ""),
+        "runInputsPath": ctx.get("RUN_INPUTS_RELATIVE_PATH", ""),
+        "historyTimelinePath": ctx.get("TIMELINE_RELATIVE_PATH", ""),
+    }
+
+
+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", ""),
+        "stage": ctx.get("RUN_STAGE", ""),
+        "fileSuffix": ctx.get("RUN_FILE_SUFFIX", ""),
+        "sequences": {
+            "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", ""),
+        },
+    }
+
+
+def _hydrate_from_hints(
+    identity: Mapping[str, Any],
+    hints: Mapping[str, Any],
+    timestamps: Any,
+) -> dict[str, Any]:
+    paths = _build_path_set(identity, hints)
+    filenames = _filename_fields(paths)
+    relative = _relative_fields(paths["project_root"], paths)
+    return {
+        **_identity_fields(identity),
+        **_runtime_fields(paths),
+        **_absolute_fields(paths),
+        **filenames,
+        **_sequence_fields(paths),
+        **relative,
+        **_timestamp_fields(timestamps),
+    }
+
+
+def _build_path_set(identity: Mapping[str, Any], hints: Mapping[str, Any]) -> dict[str, Any]:
+    project_root = Path(str(identity.get("projectRoot", "")))
+    workspace_root = Path(str(identity.get("workspaceRoot", "")))
+    project_hints = _mapping(hints.get("project"))
+    run_hints = _mapping(hints.get("run"))
+    task_root = _project_path(project_root, _task_root_hint(hints))
+    run_root = _project_path(project_root, str(run_hints.get("runRoot", "")))
+    task_type_segment = _segment(identity, "taskType")
+    sequences = _sequences(run_hints)
+    suffixes = _suffixes(task_type_segment, sequences)
+    paths = {
+        "project_root": project_root,
+        "workspace_root": workspace_root,
+        "okstra_root": _project_path(project_root, str(project_hints.get("okstraRoot", OKSTRA_RELATIVE))),
+        "tasks_root": _project_path(project_root, str(project_hints.get("tasksRoot", TASKS_RELATIVE))),
+        "discovery_dir": _project_path(project_root, str(project_hints.get("discoveryRoot", DISCOVERY_RELATIVE))),
+        "task_root": task_root,
+        "run_dir": run_root,
+        "runtime_home": Path(str(_mapping(hints.get("runtime")).get("okstraHome", okstra_home()))),
+        "task_type_segment": task_type_segment,
+        "run_stage": str(run_hints.get("stage", "")),
+        "run_file_suffix": str(run_hints.get("fileSuffix", suffixes["reports"])),
+        "sequences": sequences,
+        "suffixes": suffixes,
+    }
+    paths.update(_task_path_set(task_root))
+    paths.update(_run_path_set(run_root, task_type_segment, sequences, suffixes))
+    paths.update(_discovery_path_set(paths["discovery_dir"]))
+    return paths
+
+
+def _task_path_set(task_root: Path) -> dict[str, Path]:
+    instruction_set = task_root / "instruction-set"
+    history_dir = task_root / "history"
+    recap_dir = task_root / "recap"
+    return {
+        "task_manifest": task_root / "task-manifest.json",
+        "task_index": task_root / "task-index.md",
+        "instruction_set": instruction_set,
+        "analysis_packet": instruction_set / "analysis-packet.md",
+        "task_qa": task_root / "qa",
+        "runs_dir": task_root / "runs",
+        "history_dir": history_dir,
+        "timeline_file": history_dir / "timeline.json",
+        "recap_dir": recap_dir,
+        "recap_log": recap_dir / "recap-log.jsonl",
+        "final_report_template": instruction_set / "final-report-template.md",
+        "final_report_schema": instruction_set / "final-report-schema.json",
+        "reference_expectations": instruction_set / "reference-expectations.md",
+    }
+
+
+def _run_path_set(
+    run_dir: Path,
+    task_type_segment: str,
+    sequences: Mapping[str, str],
+    suffixes: Mapping[str, str],
+) -> dict[str, Path]:
+    run_prompts = run_dir / "prompts"
+    worker_results = run_dir / "worker-results"
+    return {
+        "run_manifests": run_dir / "manifests",
+        "run_state": run_dir / "state",
+        "run_prompts": run_prompts,
+        "run_reports": run_dir / "reports",
+        "run_status": run_dir / "status",
+        "run_sessions": run_dir / "sessions",
+        "run_logs": run_dir / "logs",
+        "worker_results": worker_results,
+        "run_carry": run_dir / "carry",
+        **_run_files(run_dir, run_prompts, worker_results, task_type_segment, sequences, suffixes),
+    }
+
+
+def _run_files(
+    run_dir: Path,
+    run_prompts: Path,
+    worker_results: Path,
+    task_type_segment: str,
+    sequences: Mapping[str, str],
+    suffixes: Mapping[str, str],
+) -> dict[str, Path]:
+    run_manifests = run_dir / "manifests"
+    run_state = run_dir / "state"
+    run_reports = run_dir / "reports"
+    run_status = run_dir / "status"
+    run_sessions = run_dir / "sessions"
+    run_logs = run_dir / "logs"
+    return {
+        "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",
+        "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",
+        "report_writer_worker_prompt": run_prompts / f"report-writer-worker-prompt{suffixes['prompts']}.md",
+        "final_report": run_reports / f"final-report{suffixes['reports']}.md",
+        "final_status": run_status / f"final{suffixes['status']}.status",
+        "team_state": run_state / f"team-state{suffixes['state']}.json",
+        "active_run_context": run_state / f"active-run-context{suffixes['state']}.json",
+        "lead_events": run_state / f"lead-events-{task_type_segment}-{sequences['state']}.jsonl",
+        "claude_resume_command": run_sessions / f"claude-resume{suffixes['sessions']}.sh",
+        "claude_worker_result": worker_results / f"claude-worker{suffixes['worker_results']}.md",
+        "codex_worker_result": worker_results / f"codex-worker{suffixes['worker_results']}.md",
+        "antigravity_worker_result": worker_results / f"antigravity-worker{suffixes['worker_results']}.md",
+        "report_writer_worker_result": worker_results / f"report-writer-worker{suffixes['worker_results']}.md",
+        "run_errors_log": run_logs / f"errors-{task_type_segment}-{sequences['state']}.jsonl",
+        "claude_worker_errors_sidecar": worker_results / f"claude-worker-errors{suffixes['worker_results']}.json",
+        "codex_worker_errors_sidecar": worker_results / f"codex-worker-errors{suffixes['worker_results']}.json",
+        "antigravity_worker_errors_sidecar": worker_results / f"antigravity-worker-errors{suffixes['worker_results']}.json",
+        "report_writer_errors_sidecar": worker_results / f"report-writer-worker-errors{suffixes['worker_results']}.json",
+    }
+
+
+def _discovery_path_set(discovery_dir: Path) -> dict[str, Path]:
+    return {
+        "latest_task_file": discovery_dir / "latest-task.json",
+        "task_catalog_file": discovery_dir / "task-catalog.json",
+    }
+
+
+def _identity_fields(identity: Mapping[str, Any]) -> dict[str, str]:
+    return {
+        "PROJECT_ID": str(identity.get("projectId", "")),
+        "PROJECT_ROOT": str(identity.get("projectRoot", "")),
+        "WORKSPACE_ROOT": str(identity.get("workspaceRoot", "")),
+        "TASK_GROUP": str(identity.get("taskGroup", "")),
+        "TASK_ID": str(identity.get("taskId", "")),
+        "TASK_KEY": str(identity.get("taskKey", "")),
+        "TASK_TYPE": str(identity.get("taskType", "")),
+        "TASK_GROUP_SEGMENT": _segment(identity, "taskGroup"),
+        "TASK_ID_SEGMENT": _segment(identity, "taskId"),
+        "TASK_TYPE_SEGMENT": _segment(identity, "taskType"),
+    }
+
+
+def _runtime_fields(paths: Mapping[str, Any]) -> dict[str, str]:
+    runtime_home = Path(paths["runtime_home"])
+    lead = runtime_home / "prompts" / "lead"
+    return {
+        "WORKER_PROMPT_PREAMBLE_PATH": str(runtime_home / "templates" / "worker-prompt-preamble.md"),
+        "OKSTRA_LEAD_CONTRACT_PATH": str(lead / "okstra-lead-contract.md"),
+        "OKSTRA_CONTEXT_LOADER_PATH": str(lead / "context-loader.md"),
+        "OKSTRA_TEAM_CONTRACT_PATH": str(lead / "team-contract.md"),
+        "OKSTRA_CONVERGENCE_PATH": str(lead / "convergence.md"),
+        "OKSTRA_REPORT_WRITER_PATH": str(lead / "report-writer.md"),
+        "OKSTRA_CODING_PREFLIGHT_DIR": str(runtime_home / "prompts" / "coding-preflight"),
+    }
+
+
+def _absolute_fields(paths: Mapping[str, Any]) -> dict[str, str]:
+    return {
+        **_absolute_project_task_fields(paths),
+        **_absolute_run_fields(paths),
+        **_absolute_worker_fields(paths),
+    }
+
+
+def _absolute_project_task_fields(paths: Mapping[str, Any]) -> dict[str, str]:
+    return {
+        "OKSTRA_ROOT": str(paths["okstra_root"]),
+        "OKSTRA_TASKS_ROOT": str(paths["tasks_root"]),
+        "OKSTRA_DISCOVERY_DIR": str(paths["discovery_dir"]),
+        "TASK_ROOT": str(paths["task_root"]),
+        "TASK_MANIFEST_PATH": str(paths["task_manifest"]),
+        "TASK_INDEX_PATH": str(paths["task_index"]),
+        "INSTRUCTION_SET_PATH": str(paths["instruction_set"]),
+        "ANALYSIS_PACKET_PATH": str(paths["analysis_packet"]),
+        "TASK_QA_PATH": str(paths["task_qa"]),
+        "RUNS_DIR": str(paths["runs_dir"]),
+        "HISTORY_DIR": str(paths["history_dir"]),
+        "TIMELINE_PATH": str(paths["timeline_file"]),
+        "RECAP_DIR": str(paths["recap_dir"]),
+        "RECAP_LOG_PATH": str(paths["recap_log"]),
+        "FINAL_REPORT_TEMPLATE_PATH": str(paths["final_report_template"]),
+        "FINAL_REPORT_SCHEMA_PATH": str(paths["final_report_schema"]),
+        "REFERENCE_EXPECTATIONS_FILE": str(paths["reference_expectations"]),
+        "OKSTRA_LATEST_TASK_FILE": str(paths["latest_task_file"]),
+        "OKSTRA_TASK_CATALOG_FILE": str(paths["task_catalog_file"]),
+    }
+
+
+def _absolute_run_fields(paths: Mapping[str, Any]) -> dict[str, str]:
+    return {
+        "RUN_DIR": str(paths["run_dir"]),
+        "RUN_STAGE": str(paths["run_stage"]),
+        "RUN_MANIFESTS_DIR": str(paths["run_manifests"]),
+        "RUN_STATE_DIR": str(paths["run_state"]),
+        "RUN_PROMPTS_DIR": str(paths["run_prompts"]),
+        "RUN_REPORTS_DIR": str(paths["run_reports"]),
+        "RUN_STATUS_DIR": str(paths["run_status"]),
+        "RUN_SESSIONS_DIR": str(paths["run_sessions"]),
+        "RUN_LOGS_DIR": str(paths["run_logs"]),
+        "WORKER_RESULTS_PATH": str(paths["worker_results"]),
+        "RUN_CARRY_PATH": str(paths["run_carry"]),
+        "RUN_MANIFEST_PATH": str(paths["run_manifest_file"]),
+        "RUN_CONTEXT_FILE": str(paths["run_context_file"]),
+        "RUN_PROMPT_SNAPSHOT_FILE": str(paths["run_prompt_snapshot"]),
+        "FINAL_REPORT_PATH": str(paths["final_report"]),
+        "FINAL_STATUS_PATH": str(paths["final_status"]),
+        "TEAM_STATE_PATH": str(paths["team_state"]),
+        "ACTIVE_RUN_CONTEXT_PATH": str(paths["active_run_context"]),
+        "LEAD_EVENTS_PATH": str(paths["lead_events"]),
+        "CLAUDE_RESUME_COMMAND_PATH": str(paths["claude_resume_command"]),
+        "RUN_ERRORS_LOG_PATH": str(paths["run_errors_log"]),
+        "RUN_VALIDATOR_PATH": str(paths["workspace_root"] / "validators" / "validate-run.py"),
+        "LATEST_RUN_PATH": str(paths["run_dir"]),
+    }
+
+
+def _absolute_worker_fields(paths: Mapping[str, Any]) -> dict[str, str]:
+    return {
+        "CLAUDE_WORKER_PROMPT_FILE": str(paths["claude_worker_prompt"]),
+        "CODEX_WORKER_PROMPT_FILE": str(paths["codex_worker_prompt"]),
+        "ANTIGRAVITY_WORKER_PROMPT_FILE": str(paths["antigravity_worker_prompt"]),
+        "REPORT_WRITER_WORKER_PROMPT_FILE": str(paths["report_writer_worker_prompt"]),
+        "CLAUDE_WORKER_RESULT_FILE": str(paths["claude_worker_result"]),
+        "CODEX_WORKER_RESULT_FILE": str(paths["codex_worker_result"]),
+        "ANTIGRAVITY_WORKER_RESULT_FILE": str(paths["antigravity_worker_result"]),
+        "REPORT_WRITER_WORKER_RESULT_FILE": str(paths["report_writer_worker_result"]),
+        "CLAUDE_WORKER_ERRORS_SIDECAR_PATH": str(paths["claude_worker_errors_sidecar"]),
+        "CODEX_WORKER_ERRORS_SIDECAR_PATH": str(paths["codex_worker_errors_sidecar"]),
+        "ANTIGRAVITY_WORKER_ERRORS_SIDECAR_PATH": str(paths["antigravity_worker_errors_sidecar"]),
+        "REPORT_WRITER_WORKER_ERRORS_SIDECAR_PATH": str(paths["report_writer_errors_sidecar"]),
+    }
+
+
+def _filename_fields(paths: Mapping[str, Any]) -> dict[str, str]:
+    return {
+        "RUN_MANIFEST_FILENAME": Path(paths["run_manifest_file"]).name,
+        "RUN_PROMPT_SNAPSHOT_FILENAME": Path(paths["run_prompt_snapshot"]).name,
+        "FINAL_REPORT_FILENAME": Path(paths["final_report"]).name,
+        "FINAL_STATUS_FILENAME": Path(paths["final_status"]).name,
+        "CLAUDE_RESUME_COMMAND_FILENAME": Path(paths["claude_resume_command"]).name,
+        "RUN_FILE_SUFFIX": str(paths["run_file_suffix"]),
+    }
+
+
+def _sequence_fields(paths: Mapping[str, Any]) -> dict[str, str]:
+    sequences = paths["sequences"]
+    return {
+        "RUN_MANIFESTS_SEQ": sequences["manifests"],
+        "RUN_PROMPTS_SEQ": sequences["prompts"],
+        "RUN_REPORTS_SEQ": sequences["reports"],
+        "RUN_STATUS_SEQ": sequences["status"],
+        "RUN_STATE_SEQ": sequences["state"],
+        "RUN_SESSIONS_SEQ": sequences["sessions"],
+        "WORKER_RESULTS_SEQ": sequences["worker_results"],
+    }
+
+
+def _relative_fields(project_root: Path, paths: Mapping[str, Any]) -> dict[str, str]:
+    return {
+        "OKSTRA_DISCOVERY_RELATIVE_PATH": _rel(project_root, paths["discovery_dir"]),
+        "OKSTRA_LATEST_TASK_RELATIVE_PATH": _rel(project_root, paths["latest_task_file"]),
+        "OKSTRA_TASK_CATALOG_RELATIVE_PATH": _rel(project_root, paths["task_catalog_file"]),
+        "TASK_ROOT_RELATIVE_PATH": _rel(project_root, paths["task_root"]),
+        "TASK_MANIFEST_RELATIVE_PATH": _rel(project_root, paths["task_manifest"]),
+        "TASK_INDEX_RELATIVE_PATH": _rel(project_root, paths["task_index"]),
+        "INSTRUCTION_SET_RELATIVE_PATH": _rel(project_root, paths["instruction_set"]),
+        "ANALYSIS_PACKET_RELATIVE_PATH": _rel(project_root, paths["analysis_packet"]),
+        "RUNS_RELATIVE_PATH": _rel(project_root, paths["runs_dir"]),
+        "HISTORY_RELATIVE_PATH": _rel(project_root, paths["history_dir"]),
+        "TIMELINE_RELATIVE_PATH": _rel(project_root, paths["timeline_file"]),
+        "RECAP_DIR_RELATIVE_PATH": _rel(project_root, paths["recap_dir"]),
+        "RECAP_LOG_RELATIVE_PATH": _rel(project_root, paths["recap_log"]),
+        "RUN_DIR_RELATIVE_PATH": _rel(project_root, paths["run_dir"]),
+        "RUN_MANIFESTS_RELATIVE_PATH": _rel(project_root, paths["run_manifests"]),
+        "RUN_STATE_RELATIVE_PATH": _rel(project_root, paths["run_state"]),
+        "RUN_PROMPTS_RELATIVE_PATH": _rel(project_root, paths["run_prompts"]),
+        "RUN_REPORTS_RELATIVE_PATH": _rel(project_root, paths["run_reports"]),
+        "RUN_STATUS_RELATIVE_PATH": _rel(project_root, paths["run_status"]),
+        "RUN_SESSIONS_RELATIVE_PATH": _rel(project_root, paths["run_sessions"]),
+        **_relative_file_fields(project_root, paths),
+    }
+
+
+def _relative_file_fields(project_root: Path, paths: Mapping[str, Any]) -> dict[str, str]:
+    return {
+        "RUN_MANIFEST_RELATIVE_PATH": _rel(project_root, paths["run_manifest_file"]),
+        "RUN_CONTEXT_RELATIVE_PATH": _rel(project_root, paths["run_context_file"]),
+        "RUN_INPUTS_RELATIVE_PATH": _rel(project_root, paths["run_inputs_file"]),
+        "RUN_PROMPT_SNAPSHOT_RELATIVE_PATH": _rel(project_root, paths["run_prompt_snapshot"]),
+        "CLAUDE_WORKER_PROMPT_RELATIVE_PATH": _rel(project_root, paths["claude_worker_prompt"]),
+        "CODEX_WORKER_PROMPT_RELATIVE_PATH": _rel(project_root, paths["codex_worker_prompt"]),
+        "ANTIGRAVITY_WORKER_PROMPT_RELATIVE_PATH": _rel(project_root, paths["antigravity_worker_prompt"]),
+        "REPORT_WRITER_WORKER_PROMPT_RELATIVE_PATH": _rel(project_root, paths["report_writer_worker_prompt"]),
+        "FINAL_REPORT_RELATIVE_PATH": _rel(project_root, paths["final_report"]),
+        "FINAL_STATUS_RELATIVE_PATH": _rel(project_root, paths["final_status"]),
+        "TEAM_STATE_RELATIVE_PATH": _rel(project_root, paths["team_state"]),
+        "ACTIVE_RUN_CONTEXT_RELATIVE_PATH": _rel(project_root, paths["active_run_context"]),
+        "LEAD_EVENTS_RELATIVE_PATH": _rel(project_root, paths["lead_events"]),
+        "WORKER_RESULTS_RELATIVE_PATH": _rel(project_root, paths["worker_results"]),
+        "RUN_CARRY_RELATIVE_PATH": _rel(project_root, paths["run_carry"]),
+        "FINAL_REPORT_TEMPLATE_RELATIVE_PATH": _rel(project_root, paths["final_report_template"]),
+        "FINAL_REPORT_SCHEMA_RELATIVE_PATH": _rel(project_root, paths["final_report_schema"]),
+        "REFERENCE_EXPECTATIONS_RELATIVE_PATH": _rel(project_root, paths["reference_expectations"]),
+        "CLAUDE_RESUME_COMMAND_RELATIVE_PATH": _rel(project_root, paths["claude_resume_command"]),
+        "RUN_VALIDATOR_RELATIVE_PATH": _rel(project_root, paths["workspace_root"] / "validators" / "validate-run.py"),
+        "CLAUDE_WORKER_RESULT_RELATIVE_PATH": _rel(project_root, paths["claude_worker_result"]),
+        "CODEX_WORKER_RESULT_RELATIVE_PATH": _rel(project_root, paths["codex_worker_result"]),
+        "ANTIGRAVITY_WORKER_RESULT_RELATIVE_PATH": _rel(project_root, paths["antigravity_worker_result"]),
+        "REPORT_WRITER_WORKER_RESULT_RELATIVE_PATH": _rel(project_root, paths["report_writer_worker_result"]),
+        "RUN_ERRORS_LOG_RELATIVE_PATH": _rel(project_root, paths["run_errors_log"]),
+        "CLAUDE_WORKER_ERRORS_SIDECAR_RELATIVE_PATH": _rel(project_root, paths["claude_worker_errors_sidecar"]),
+        "CODEX_WORKER_ERRORS_SIDECAR_RELATIVE_PATH": _rel(project_root, paths["codex_worker_errors_sidecar"]),
+        "ANTIGRAVITY_WORKER_ERRORS_SIDECAR_RELATIVE_PATH": _rel(project_root, paths["antigravity_worker_errors_sidecar"]),
+        "REPORT_WRITER_WORKER_ERRORS_SIDECAR_RELATIVE_PATH": _rel(project_root, paths["report_writer_errors_sidecar"]),
+        "LATEST_RUN_RELATIVE_PATH": _rel(project_root, paths["run_dir"]),
+    }
+
+
+def _timestamp_fields(timestamps: Any) -> dict[str, str]:
+    values = _mapping(timestamps)
+    return {
+        "RUN_TIMESTAMP_ISO": str(values.get("runTimestampIso", "")),
+        "TASK_DATE": str(values.get("taskDate", "")),
+    }
+
+
+def _task_root_hint(hints: Mapping[str, Any]) -> str:
+    task_hints = _mapping(hints.get("task"))
+    return str(task_hints.get("taskRoot", ""))
+
+
+def _segment(identity: Mapping[str, Any], name: str) -> str:
+    segments = _mapping(identity.get("segments"))
+    return str(segments.get(name, ""))
+
+
+def _mapping(value: Any) -> Mapping[str, Any]:
+    return value if isinstance(value, Mapping) else {}
+
+
+def _sequences(run_hints: Mapping[str, Any]) -> dict[str, str]:
+    raw = _mapping(run_hints.get("sequences"))
+    return {
+        "manifests": str(raw.get("manifests", "")),
+        "prompts": str(raw.get("prompts", "")),
+        "reports": str(raw.get("reports", "")),
+        "status": str(raw.get("status", "")),
+        "state": str(raw.get("state", "")),
+        "sessions": str(raw.get("sessions", "")),
+        "worker_results": str(raw.get("workerResults", "")),
+    }
+
+
+def _suffixes(task_type_segment: str, sequences: Mapping[str, str]) -> dict[str, str]:
+    return {key: f"-{task_type_segment}-{seq}" for key, seq in sequences.items()}
+
+
+def _project_path(project_root: Path, value: str) -> Path:
+    path = Path(value)
+    return path if path.is_absolute() else project_root / path
+
+
+def _rel(project_root: Path, target: Path) -> str:
+    try:
+        return str(target.resolve().relative_to(project_root.resolve()))
+    except (ValueError, OSError):
+        return str(target)

package/runtime/python/okstra_ctl/render.py

@@ -31,6 +31,7 @@ from okstra_project.dirs import OKSTRA_DIR_NAME, project_json_path
 from . import fix_cycles
 from .paths import okstra_home
 from .lead_runtime import lead_runtime_info
+from .path_hints import compact_active_run_context, hydrate_run_context
 from .workflow import DEFAULT_NEXT_PHASE, PHASE_SEQUENCE
 
 
@@ -56,8 +57,8 @@ def _load_ctx(ctx_arg: str) -> dict:
     """
     s = ctx_arg.lstrip()
     if s.startswith("{"):
-        return json.loads(ctx_arg)
-    return json.loads(Path(ctx_arg).read_text(encoding="utf-8"))
+        return hydrate_run_context(json.loads(ctx_arg))
+    return hydrate_run_context(json.loads(Path(ctx_arg).read_text(encoding="utf-8")))
 
 
 def _write_text(path: Path, text: str) -> None:
@@ -434,7 +435,7 @@ def render_active_run_context(active_context_path: str, ctx: dict) -> None:
         "sourceArtifacts": _active_source_artifacts(ctx),
         "lazyReadPlan": _active_lazy_read_plan(),
     }
-    _write_json(Path(active_context_path), payload)
+    _write_json(Path(active_context_path), compact_active_run_context(ctx, payload))
 
 
 def render_team_state(team_state_path: str, ctx: dict) -> None:

package/runtime/python/okstra_ctl/run_context.py

@@ -25,6 +25,7 @@ from typing import Iterator, Optional
 
 from okstra_project.dirs import okstra_home
 
+from .path_hints import compact_run_context, hydrate_run_context
 from .paths import compute_run_paths, task_runs_dir
 
 
@@ -188,7 +189,7 @@ def compute_and_write_run_context(
             str(ctx_path.relative_to(project_root.resolve()))
             if ctx_path.resolve().is_relative_to(project_root.resolve())
             else str(ctx_path))
-        _atomic_write_json(ctx_path, ctx)
+        _atomic_write_json(ctx_path, compact_run_context(ctx))
     return ctx
 
 
@@ -225,7 +226,8 @@ def read_run_context(run_manifests_dir: Path, task_type_segment: str,
     path = Path(run_manifests_dir) / _run_context_filename(task_type_segment, seq)
     if not path.is_file():
         return None
-    return json.loads(path.read_text(encoding="utf-8"))
+    payload = json.loads(path.read_text(encoding="utf-8"))
+    return hydrate_run_context(payload)
 
 
 def read_run_inputs(run_manifests_dir: Path, task_type_segment: str,

package/runtime/python/okstra_ctl/wizard.py

@@ -1053,6 +1053,18 @@ def _opt(value: str, label: str = "", description: str = "") -> Option:
 
 # --- builders ---
 
+def _contract_outcome_suffix(entry: dict) -> str:
+    outcome = entry.get("phaseOutcome")
+    implementation = outcome.get("implementation") if isinstance(outcome, dict) else {}
+    if not isinstance(implementation, dict):
+        return ""
+    if implementation.get("state") != "completed":
+        return ""
+    if entry.get("currentStatus") == "contract-violated":
+        return " · implementation complete; contract warnings"
+    return ""
+
+
 def _build_task_pick(state: WizardState) -> Prompt:
     t = _p(state.workspace_root, "task_pick")
     project_root = Path(state.project_root)
@@ -1070,7 +1082,7 @@ def _build_task_pick(state: WizardState) -> Prompt:
         phase = entry.get("currentPhase") or ttype
         nxt = entry.get("nextRecommendedPhase") or ""
         suffix = latest_suffix if key == latest_key else ""
-        label = f"{key}  ·  {phase}  ·  next: {nxt}{suffix}"
+        label = f"{key}  ·  {phase}  ·  next: {nxt}{_contract_outcome_suffix(entry)}{suffix}"
         options.append(_opt(value=key, label=label))
     for value, label in _static_options(t):
         options.append(_opt(value=value, label=label))

package/runtime/python/okstra_project/state.py

@@ -1,10 +1,13 @@
-"""Read-only state accessors over okstra's on-disk authority files.
+"""Read-side state accessors over okstra's on-disk authority files.
 
 Skills, okstra.sh, and okstra-ctl all read the same files through this module
 so identity / discovery values are derived from disk on every call instead of
 being passed via process environment. This keeps concurrent claude-code skill
 invocations isolated — each call reads the authoritative state at the moment
 it runs and never sees stale snapshots inherited from a parent process.
+Some accessors also run best-effort reconciliation before returning derived
+phase pointers, so stale catalog entries can be healed from authoritative
+task artifacts.
 
 권위 파일 매핑 (okstra root = <PROJECT_ROOT>/<OKSTRA_DIR_NAME>):
   - <okstra root>/project.json
@@ -78,6 +81,38 @@ def read_task_manifest(task_root: Path) -> Optional[dict]:
     return _load_json(Path(task_root) / "task-manifest.json")
 
 
+def _reconcile_task_root_best_effort(project_root: Path, task_root: Path) -> None:
+    try:
+        from okstra_ctl.implementation_outcome import reconcile_implementation_outcome
+
+        reconcile_implementation_outcome(project_root, task_root)
+    except Exception:
+        return
+
+
+def _entry_with_manifest_state(entry: dict, task_root: Path) -> dict:
+    out = {**entry}
+    manifest = read_task_manifest(task_root) or {}
+    workflow = manifest.get("workflow") if isinstance(manifest.get("workflow"), dict) else {}
+    for source, target in (
+        ("currentPhase", "currentPhase"),
+        ("currentPhaseState", "currentPhaseState"),
+        ("lastCompletedPhase", "lastCompletedPhase"),
+        ("nextRecommendedPhase", "nextRecommendedPhase"),
+    ):
+        value = workflow.get(source)
+        if isinstance(value, str):
+            out[target] = value
+    for field in ("currentStatus", "latestRunStatus", "latestReportPath"):
+        value = manifest.get(field)
+        if isinstance(value, str):
+            out[field] = value
+    phase_outcome = manifest.get("phaseOutcome")
+    if isinstance(phase_outcome, dict):
+        out["phaseOutcome"] = phase_outcome
+    return out
+
+
 def parse_task_key(task_key: str) -> tuple[str, str, str]:
     """`project-id:task-group:task-id` 를 3-tuple 로 분해.
 
@@ -111,10 +146,12 @@ def find_task_root(project_root: Path, task_key: str) -> Optional[Path]:
         if isinstance(rel, str) and rel:
             abs_path = project_root / rel if not Path(rel).is_absolute() else Path(rel)
             if abs_path.is_dir():
+                _reconcile_task_root_best_effort(project_root, abs_path)
                 return abs_path
 
     slug_path = project_root / TASKS_RELATIVE / slugify(task_group) / slugify(task_id)
     if slug_path.is_dir():
+        _reconcile_task_root_best_effort(project_root, slug_path)
         return slug_path
     return None
 
@@ -180,7 +217,8 @@ def list_project_tasks(
         root = find_task_root(project_root, entry_key)
         if root is None:
             continue
-        out.append({**entry, "_resolvedTaskRoot": str(root)})
+        reconciled_entry = _entry_with_manifest_state(entry, root)
+        out.append({**reconciled_entry, "_resolvedTaskRoot": str(root)})
     if limit is not None and limit >= 0:
         out = out[:limit]
     return out