okstra 0.174.0 → 0.175.1

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/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,
     }