okstra 0.136.0 → 0.138.0

package/runtime/python/okstra_project/state.py

@@ -30,6 +30,7 @@ from .dirs import (
     DISCOVERY_RELATIVE,
     LATEST_TASK_RELATIVE,
     TASK_CATALOG_RELATIVE,
+    TASK_MANIFEST_FILENAME,
     TASKS_RELATIVE,
 )
 
@@ -82,7 +83,24 @@ def read_latest_task(project_root: Path) -> Optional[dict]:
 
 def read_task_manifest(task_root: Path) -> Optional[dict]:
     """<task-root>/task-manifest.json 을 dict 로. 파일 없으면 None."""
-    return _load_json(Path(task_root) / "task-manifest.json")
+    return _load_json(Path(task_root) / TASK_MANIFEST_FILENAME)
+
+
+def read_task_key(task_root: Path) -> str:
+    """manifest 의 taskKey. 파일이 없거나 깨졌으면 "".
+
+    리포트 렌더러(recap·time-report·error-report)는 taskKey 를 헤더 라벨로만 쓰므로
+    manifest 가 없어도 실패하지 않아야 한다 — 세 모듈이 각자 갖고 있던 관용 리더를
+    여기로 모은다.
+    """
+    try:
+        manifest = read_task_manifest(Path(task_root))
+    except (StateError, OSError):
+        return ""
+    if not isinstance(manifest, dict):
+        return ""
+    value = manifest.get("taskKey")
+    return value if isinstance(value, str) else ""
 
 
 def _reconcile_task_root_best_effort(project_root: Path, task_root: Path) -> None:
@@ -94,6 +112,31 @@ def _reconcile_task_root_best_effort(project_root: Path, task_root: Path) -> Non
         return
 
 
+_DERIVED_STATUS_STRING_FIELDS = (
+    "workStatus",
+    "currentStatus",
+    "latestRunStatus",
+    "latestReportPath",
+)
+
+
+def derived_task_status(manifest: dict) -> dict:
+    """Task status a caller acts on, projected off the raw manifest.
+
+    Both the task list rows and the read-side snapshot project through here so
+    the two views cannot disagree about whether a task is finished.
+    """
+    out: dict = {}
+    for field in _DERIVED_STATUS_STRING_FIELDS:
+        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 _entry_with_manifest_state(entry: dict, task_root: Path) -> dict:
     out = {**entry}
     manifest = read_task_manifest(task_root) or {}
@@ -107,13 +150,7 @@ def _entry_with_manifest_state(entry: dict, task_root: Path) -> dict:
         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
+    out.update(derived_task_status(manifest))
     return out
 
 
@@ -329,8 +366,41 @@ def task_read_side_snapshot(project_root: Path, task_key: str) -> dict:
             "routingStatus": workflow.get("routingStatus"),
             "phaseStates": workflow.get("phaseStates"),
         },
+        "status": derived_task_status(manifest),
         "resultContract": manifest.get("resultContract"),
         "artifacts": manifest.get("artifacts"),
         "modelAssignments": manifest.get("modelAssignments"),
         "latestRunPath": manifest.get("latestRunPath"),
     }
+
+
+def stage_map_read_side_snapshot(project_root: Path, task_key: str) -> dict:
+    """stage-map inspect 용 read-side view: Stage Map + done 처리된 stage 번호.
+
+    Stage Map 파싱과 planning run-root 위치를 caller 에게 노출하지 않는다 —
+    Node inspect 가 okstra_ctl 의 private 심볼을 import 하거나 `runs/` 경로를
+    직접 조립하지 않도록 하는 어댑터다.
+    """
+    from okstra_ctl.consumers import read_stage_consumer_state
+    from okstra_ctl.implementation_outcome import load_stage_map
+    from okstra_ctl.paths import RunRef
+
+    identity = resolve_task_identity(project_root, task_key)
+    task_root = Path(identity["taskRoot"])
+    stages = load_stage_map(task_root, identity["manifest"])
+    plan_run_root = RunRef.from_task_root(
+        task_root, "implementation-planning"
+    ).run_dir
+    done: list[int] = []
+    if plan_run_root.is_dir():
+        done = sorted(
+            read_stage_consumer_state(
+                plan_run_root, recover_from_carry=True
+            ).done_stages
+        )
+    return {
+        "taskKey": identity["taskKey"],
+        "taskRoot": identity["taskRoot"],
+        "stages": stages,
+        "doneStages": done,
+    }

package/runtime/validators/lib/fixtures.sh

@@ -137,6 +137,7 @@ prompt_path.write_text(
             f"**Errors sidecar path:** {project_root}/run/worker-results/"
             f"{target_worker_id}-errors.json",
             f"Assigned worker prompt history path: {prompt_relative}",
+            "**Prompt Delivery Mode:** eager-include",
             f"- Primary analysis packet: `{analysis_packet_path}`",
             "",
             "# Initial Analysis Prompt",
@@ -230,6 +231,7 @@ for worker in team_state.get("workers", []):
             f"**Errors sidecar path:** {project_root}/run/worker-results/"
             f"{worker_id}-errors.json",
             f"Assigned worker prompt history path: {prompt_relative}",
+            "**Prompt Delivery Mode:** eager-include",
         ]
         if worker_id != "report-writer":
             prompt_lines.append(

package/runtime/validators/validate-run.py

@@ -44,6 +44,7 @@ from okstra_ctl.conformance import (  # noqa: E402
     validate_conformance_manifest,
 )
 from okstra_ctl.paths import RunRef  # noqa: E402
+from okstra_ctl.workflow import DEFAULT_NEXT_PHASE, PHASE_SEQUENCE  # noqa: E402
 from okstra_ctl.md_table import (  # noqa: E402
     is_separator_row as _is_markdown_separator,
     split_pipe_row as _split_pipe_row,
@@ -158,19 +159,7 @@ def write_json(path: Path, payload: dict) -> None:
 
 
 def default_next_phase(task_type: str) -> str:
-    mapping = {
-        "requirements-discovery": "pending-routing-decision",
-        "improvement-discovery": "pending-routing-decision",
-        "error-analysis": "implementation-planning",
-        "implementation-planning": "implementation",
-        "implementation": "final-verification",
-        # final-verification 의 다음 phase 는 verdict 에 따라 갈리므로
-        # 정적 매핑은 `pending-release-handoff` 로 두고, 실제 진입은
-        # release-handoff profile 의 entry gate (`accepted` 확인) 에서 강제한다.
-        "final-verification": "pending-release-handoff",
-        "release-handoff": "done-or-follow-up",
-    }
-    return mapping.get(task_type, "unknown")
+    return DEFAULT_NEXT_PHASE.get(task_type, "unknown")
 
 
 def advance_next_phase(
@@ -209,14 +198,7 @@ def update_workflow_metadata(
     )
     phase_sequence = workflow.get("phaseSequence", [])
     if not isinstance(phase_sequence, list) or not phase_sequence:
-        phase_sequence = [
-            "requirements-discovery",
-            "error-analysis",
-            "implementation-planning",
-            "implementation",
-            "final-verification",
-            "release-handoff",
-        ]
+        phase_sequence = list(PHASE_SEQUENCE)
 
     phase_states = workflow.get("phaseStates", {})
     if not isinstance(phase_states, dict):

package/src/commands/inspect/stage-map.mjs

@@ -40,9 +40,9 @@ function parseArgs(args) {
 const SCRIPT = `
 import json, sys
 from pathlib import Path
-from okstra_project import resolve_project_root, find_task_root, read_task_manifest, ResolverError
-from okstra_ctl.implementation_outcome import _load_stage_map
-from okstra_ctl.consumers import read_stage_consumer_state
+from okstra_project import (
+    resolve_project_root, stage_map_read_side_snapshot, ResolverError, StateError,
+)
 
 explicit, cwd, task_key = sys.argv[1], sys.argv[2], sys.argv[3]
 
@@ -52,24 +52,17 @@ except ResolverError as e:
     print(json.dumps({"ok": False, "stage": "resolve", "reason": str(e)}))
     sys.exit(2)
 
-task_root = find_task_root(Path(pr), task_key)
-if task_root is None:
-    print(json.dumps({"ok": False, "stage": "task_root", "reason": f"task root not found for {task_key}"}))
+try:
+    snapshot = stage_map_read_side_snapshot(Path(pr), task_key)
+except StateError as e:
+    print(json.dumps({
+        "ok": False,
+        "stage": getattr(e, "stage", None) or "stage_map",
+        "reason": str(e),
+    }))
     sys.exit(1)
 
-manifest = read_task_manifest(task_root) or {}
-stages = _load_stage_map(task_root, manifest)
-
-plan_run_root = task_root / "runs" / "implementation-planning"
-done = sorted(read_stage_consumer_state(plan_run_root, recover_from_carry=True).done_stages) if plan_run_root.is_dir() else []
-
-print(json.dumps({
-    "ok": True,
-    "taskKey": task_key,
-    "taskRoot": str(task_root),
-    "stages": stages,
-    "doneStages": done,
-}, ensure_ascii=False, indent=2))
+print(json.dumps({"ok": True, **snapshot}, ensure_ascii=False, indent=2))
 `;
 
 export async function run(args) {