okstra 0.174.0 → 0.176.0

package/runtime/python/okstra_ctl/run_index_row.py

@@ -25,7 +25,9 @@ def build_run_index_row(*, project_id: str, project_root: str,
                         run_seq: int, status: str, started_at: str,
                         finished_at: Optional[str], workers: list, lead_model: str,
                         validation: str, run_dir_rel: str,
-                        final_report_rel: str, final_status_rel: str) -> dict:
+                        final_report_rel: str, final_status_rel: str,
+                        execution_manifest_path: str = "",
+                        role_execution_refs: list | None = None) -> dict:
     """slim run-index row(14필드)를 만든다. 파생 4필드는 포함하지 않는다."""
     return {
         "runId": build_run_id(project_id, task_group, task_id,
@@ -43,6 +45,10 @@ def build_run_index_row(*, project_id: str, project_root: str,
         "finalReportRel": final_report_rel,
         "finalStatusRel": final_status_rel,
         "runDirRel": run_dir_rel,
+        **({
+            "executionManifestPath": execution_manifest_path,
+            "roleExecutionRefs": list(role_execution_refs or []),
+        } if execution_manifest_path else {}),
     }
 
 

package/runtime/python/okstra_ctl/stage_fix_carry.py

@@ -84,10 +84,26 @@ def derive_stage_fix_carry(
             str(row.get("discrepancy") or row.get("verifier") or "")
             for row in failed
         ],
-        routing_recommendation=str(impl.get("routingRecommendation") or ""),
+        routing_recommendation=_routing_line(impl.get("routingRecommendation")),
     )
 
 
+def _routing_line(value: object) -> str:
+    """구조체 라우팅을 캐리 프롬프트에 실을 한 줄로 편다.
+
+    리포트의 `implementation.routingRecommendation` 은 `{target, rationale}`
+    구조체다. dict 를 str() 로 강제하면 executor 프롬프트에 파이썬 dict repr 이
+    그대로 실려 사람도 모델도 읽을 수 없는 줄이 된다.
+    """
+    if not isinstance(value, dict):
+        return ""
+    target = str(value.get("target") or "").strip()
+    rationale = str(value.get("rationale") or "").strip()
+    if target and rationale:
+        return f"{target} — {rationale}"
+    return target or rationale
+
+
 def _latest_report(stage_run_dir: Path) -> Path | None:
     reports_dir = stage_run_dir / "reports"
     if not reports_dir.is_dir():

package/runtime/python/okstra_ctl/team.py

@@ -163,10 +163,21 @@ def _teardown(args) -> int:
     if args.dry_run:
         _emit_teardown(args.json, panes)
         return 0
-    if _is_cmux_run(manifest):
+    from .adapters.runtime.assembly import port_for, runtime_chain
+    from .domain.worker_runtime import RuntimeHandle, SURFACE_CMUX_PANE
+
+    chain = runtime_chain(_manifest_backend(manifest))
+    # cli-wrapper chains have no cmux port; leftover paneIds must not KeyError.
+    if panes and any(port.surface == SURFACE_CMUX_PANE for port in chain):
+        closer = port_for(chain, SURFACE_CMUX_PANE)
         for pane in panes:
-            cmux.close_surface(pane["paneId"])
-        _restore_lead_width()
+            closer.close(
+                RuntimeHandle(SURFACE_CMUX_PANE, pane["paneId"], False)
+            )
+    try:
+        chain[0].restore_lead()
+    except (OSError, subprocess.SubprocessError, RuntimeError) as exc:
+        print(f"okstra team: could not restore the lead's width: {exc}", file=sys.stderr)
     _mark_teardown_errors(team_state_path)
     _emit_teardown(args.json, panes)
     return 0
@@ -280,21 +291,6 @@ def _append_pane(panes: list[dict[str, str]], seen: set[str], pane_id: str, kind
         seen.add(pane_id)
 
 
-def _restore_lead_width() -> None:
-    """Give the lead back the width the reclaimed panes left behind.
-
-    Reported rather than raised: teardown's contract is to reclaim the run's
-    panes and print what it reclaimed, and a failed resize must not cost the
-    caller that record — the panes are already closed by the time this runs.
-    Reported rather than swallowed, because a width failure nobody is told
-    about is what left the lead at 18 columns unnoticed.
-    """
-    try:
-        cmux.restore_lead_width()
-    except (OSError, subprocess.SubprocessError, RuntimeError) as exc:
-        print(f"okstra team: could not restore the lead's width: {exc}", file=sys.stderr)
-
-
 def _mark_teardown_errors(team_state_path: Path) -> None:
     def mark(payload: dict[str, Any]) -> bool:
         changed = False

package/runtime/python/okstra_ctl/time_report.py

@@ -19,6 +19,18 @@ from okstra_project import read_task_key
 from okstra_ctl.task_target import resolve_task_root
 
 
+def time_rows_with_identity(run_root: Path) -> list[dict]:
+    """Project time rows from stored execution labels without reparsing them."""
+    from okstra_ctl.usage_identity import identity_rows_from_state
+
+    state_path = run_root / "state" / "team-state.json"
+    try:
+        state = json.loads(state_path.read_text(encoding="utf-8"))
+    except (OSError, ValueError):
+        return []
+    return identity_rows_from_state(state if isinstance(state, dict) else {})
+
+
 def load_runs(task_root: Path) -> tuple[list[dict], bool]:
     path = task_timeline_file(task_root)
     try:
@@ -98,14 +110,26 @@ def _collect_run(run: dict, project_root: Path) -> dict:
     state = _read_state(project_root, run.get("teamStatePath", ""))
     if state is None:
         return {**base, "reason": "team-state missing"}
+    from okstra_ctl.execution_identity import stored_identity
+    from okstra_ctl.usage_identity import identity_rows_from_state
+
     lead = _duration_ms(state.get("leadUsage"))
-    workers = [{"workerId": w.get("workerId", ""), "agent": w.get("agent", ""),
-                "durationMs": _duration_ms(w.get("usage"))}
-               for w in (state.get("workers") or []) if isinstance(w, dict)]
+    workers = []
+    for worker in (state.get("workers") or []):
+        if not isinstance(worker, dict):
+            continue
+        row = {
+            "workerId": worker.get("workerId", ""),
+            "agent": worker.get("agent", ""),
+            "durationMs": _duration_ms(worker.get("usage")),
+        }
+        row.update(stored_identity(worker))
+        workers.append(row)
     if lead == 0 and all(w["durationMs"] == 0 for w in workers):
         return {**base, "reason": "no durationMs (Phase 7 not reached)"}
     return {**base, "leadMs": lead, "workers": workers,
-            "wallClockMs": wall_clock_ms(state), "phases": _phase_rows(state)}
+            "wallClockMs": wall_clock_ms(state), "phases": _phase_rows(state),
+            "identityRows": identity_rows_from_state(state)}
 
 
 def _by_task_type(collected: list[dict]) -> list[dict]:
@@ -165,6 +189,15 @@ def aggregate_time(runs: list[dict], project_root: Path) -> dict:
         (unavailable if "reason" in c else collected).append(c)
     by_tt = _by_task_type(collected)
     grand = {k: sum(r[k] for r in by_tt) for k in ("runs", "leadMs", "workersMs", "cpuSumMs")}
+    identity_rows = []
+    seen: set[str] = set()
+    for collected_run in collected:
+        for row in collected_run.get("identityRows") or []:
+            key = str(row.get("roleExecutionRef") or row.get("executionLabel"))
+            if key in seen:
+                continue
+            seen.add(key)
+            identity_rows.append(row)
     return {
         "byTaskType": by_tt,
         "grandTotal": grand,
@@ -173,6 +206,7 @@ def aggregate_time(runs: list[dict], project_root: Path) -> dict:
                              "wallClockMs": c["wallClockMs"]} for c in collected],
         "phaseTimelines": [{"runTimestamp": c["runTimestamp"], "taskType": c["taskType"],
                             "phases": c["phases"]} for c in collected if c["phases"]],
+        "identityRows": identity_rows,
         "unavailable": unavailable,
     }
 

package/runtime/python/okstra_ctl/usage_identity.py

@@ -0,0 +1,86 @@
+"""Project usage rows from stored execution-identity refs."""
+from __future__ import annotations
+
+import json
+from pathlib import Path
+from collections.abc import Mapping
+from typing import Any
+
+from .execution_identity import (
+    ExecutionManifest,
+    execution_identity_for_ref,
+    stored_execution_label,
+    stored_identity,
+)
+from .execution_manifest import read_execution_manifest
+
+
+def run_execution_manifest(run_root: Path) -> ExecutionManifest:
+    """Load the first run-manifest under ``run_root/manifests``."""
+    return read_execution_manifest(_manifest_path(run_root))
+
+
+def identity_rows_from_state(state: Mapping[str, Any] | None) -> list[dict[str, Any]]:
+    """Collect stored identity rows from a team-state document."""
+    if not isinstance(state, Mapping):
+        return []
+    rows: list[dict[str, Any]] = []
+    seen: set[str] = set()
+    for collection in (
+        state.get("workers") or [],
+        state.get("workerDispatches") or [],
+        state.get("agentDispatches") or [],
+    ):
+        if not isinstance(collection, list):
+            continue
+        for item in collection:
+            ident = stored_identity(item if isinstance(item, Mapping) else None)
+            if not ident:
+                continue
+            key = str(ident.get("roleExecutionRef") or ident.get("executionLabel"))
+            if key in seen:
+                continue
+            seen.add(key)
+            rows.append(ident)
+    return rows
+
+
+def collect_usage_rows(run_root: Path) -> list[dict[str, Any]]:
+    """Project usage rows with stored execution identity refs."""
+    manifest = run_execution_manifest(run_root)
+    team_state = _load_json(run_root / "state" / "team-state.json")
+    rows: list[dict[str, Any]] = []
+    for collection in (
+        team_state.get("workerDispatches") or [],
+        team_state.get("agentDispatches") or [],
+    ):
+        for item in collection:
+            if not isinstance(item, Mapping):
+                continue
+            rows.append(_usage_row(manifest, item))
+    return rows
+
+
+def _usage_row(manifest: ExecutionManifest, item: Mapping[str, Any]) -> dict[str, Any]:
+    ref = str(item.get("roleExecutionRef") or "")
+    role = execution_identity_for_ref(manifest, ref)
+    return {
+        "participantRef": item.get("participantRef") or role.participant_ref,
+        "roleExecutionRef": role.role_execution_ref,
+        "invocationRef": item.get("invocationRef"),
+        "attempt": item.get("attempt", 1),
+        "executionLabel": stored_execution_label(
+            {"executionLabel": item.get("executionLabel") or role.execution_label}
+        ),
+    }
+
+
+def _manifest_path(run_root: Path) -> Path:
+    manifests = run_root / "manifests"
+    for path in sorted(manifests.glob("*.json")):
+        return path
+    raise FileNotFoundError(f"no run manifest under {run_root}")
+
+
+def _load_json(path: Path) -> dict[str, Any]:
+    return json.loads(path.read_text(encoding="utf-8"))

package/runtime/python/okstra_ctl/usage_report.py

@@ -147,9 +147,13 @@ def _collect_usage(
     end_at: dt.datetime,
     unavailable: dict[str, int],
     warnings: dict[str, int],
-) -> tuple[dict[str, dict], set[str], int, int]:
+) -> tuple[dict[str, dict], set[str], int, int, list[dict]]:
+    from okstra_ctl.usage_identity import identity_rows_from_state
+
     buckets: dict[str, dict] = {}
     unmatched_models: set[str] = set()
+    identity_rows: list[dict] = []
+    seen_identity: set[str] = set()
     total_runs = 0
     collected_runs = 0
     for entry in list_project_tasks(project_root):
@@ -173,6 +177,13 @@ def _collect_usage(
             total_runs += 1
             bucket["runs"] += 1
             metrics, reason = _run_metrics(run, project_root)
+            state = _read_state(project_root, str(run.get("teamStatePath") or ""))
+            for row in identity_rows_from_state(state):
+                key = str(row.get("roleExecutionRef") or row.get("executionLabel"))
+                if key in seen_identity:
+                    continue
+                seen_identity.add(key)
+                identity_rows.append(row)
             if reason is not None:
                 unavailable[reason] += 1
                 continue
@@ -182,7 +193,7 @@ def _collect_usage(
                 bucket[key] += metrics[key]
             bucket["costUsd"] += metrics["costUsd"]
             unmatched_models.update(metrics["unmatchedModels"])
-    return buckets, unmatched_models, total_runs, collected_runs
+    return buckets, unmatched_models, total_runs, collected_runs, identity_rows
 
 
 def build_usage_report(project_root: Path, days: int, now: dt.datetime) -> dict:
@@ -196,7 +207,7 @@ def build_usage_report(project_root: Path, days: int, now: dt.datetime) -> dict:
         start_at = dt.datetime.min.replace(tzinfo=UTC)
     unavailable = {key: 0 for key in UNAVAILABLE_KEYS}
     warnings = {"missingOrInvalidTimelines": 0}
-    buckets, unmatched_models, total_runs, collected_runs = _collect_usage(
+    buckets, unmatched_models, total_runs, collected_runs, identity_rows = _collect_usage(
         project_root, start_at, end_at, unavailable, warnings
     )
 
@@ -226,6 +237,7 @@ def build_usage_report(project_root: Path, days: int, now: dt.datetime) -> dict:
         "unavailable": unavailable,
         "warnings": warnings,
         "unmatchedModels": sorted(unmatched_models),
+        "identityRows": identity_rows,
     }