okstra 0.200.0 → 0.201.0

package/runtime/python/okstra_token_usage/collect.py

@@ -9,7 +9,7 @@ from pathlib import Path
 from typing import Any
 from okstra_project.dirs import OKSTRA_RELATIVE
 
-from .blocks import na_block, usage_block
+from .blocks import accounting_workers, na_block, usage_block
 from .claude import (
     claude_code_status_total,
     claude_session_totals,
@@ -21,6 +21,7 @@ from .codex import (
     codex_session_is_worker,
     codex_session_total,
     codex_session_window_total,
+    codex_wrapper_session_ids,
     find_codex_sessions,
 )
 from .antigravity import (
@@ -37,7 +38,11 @@ from .grok import (
 )
 from .paths import claude_project_dir, find_session_jsonl, utc_now
 from .pricing import antigravity_cost_usd, provider_billable_equivalent, provider_cost_usd
-from okstra_ctl.dispatch_state import worker_dispatch_records, worker_session_ids
+from okstra_ctl.usage_identity import (
+    unrostered_usage_workers,
+    usage_dispatch_records,
+    usage_session_ids,
+)
 from okstra_ctl.models import provider_wrappers
 from okstra_ctl.wrapper_status import (
     log_path_for_prompt,
@@ -248,7 +253,7 @@ def _recorded_run_end(state: dict, manifest: dict | None) -> str | None:
         return None
     ends: list[str] = []
     blocks = [state.get("leadUsage")] + [
-        worker.get("usage") for worker in (state.get("workers") or []) if isinstance(worker, dict)
+        worker.get("usage") for worker in accounting_workers(state)
     ]
     for block in blocks:
         if not isinstance(block, dict) or block.get("source") == "unavailable":
@@ -586,7 +591,7 @@ def _codex_worker_windows(project_root: Path, state: dict) -> dict[str, list[tup
                 windows.setdefault(worker_id, []).append((started_at, timestamp))
     running_workers = {
         str(worker.get("workerId") or "").strip()
-        for worker in state.get("workers", [])
+        for worker in accounting_workers(state)
         if isinstance(worker, dict) and worker.get("status") in {"running", "in-progress"}
     }
     if running_workers:
@@ -663,7 +668,7 @@ def _cli_session_totals(
             )
         elif provider == "grok":
             total = grok_session_total(session_path)
-        elif provider == "zai":
+        elif provider in {"zai", "claude"}:
             total = claude_code_status_total(session_path)
         else:
             continue
@@ -919,11 +924,9 @@ def _worker_cli_usage_block(
     used_fallback = not windows
     if used_fallback:
         windows = fallback_windows
-    session_paths: list[Path] = []
-    for cwd in _worker_session_cwds(project_root, records):
-        for path in _cli_sessions_for_windows(provider, cwd, windows):
-            if path not in session_paths:
-                session_paths.append(path)
+    session_paths, attribution = _worker_cli_sessions(
+        provider, project_root, worker, records, windows, status_paths,
+    )
     status_path = status_paths[-1] if status_paths else None
     if provider == "zai":
         session_paths = list(dict.fromkeys(
@@ -942,6 +945,7 @@ def _worker_cli_usage_block(
         sessions=session_paths,
         fallback_window_used=used_fallback,
     )
+    block.update(attribution)
     durations = [
         wrapper_execution(path).get("durationMs")
         for path in status_paths
@@ -953,6 +957,97 @@ def _worker_cli_usage_block(
     return block
 
 
+def _worker_cli_sessions(
+    provider: str, project_root: Path, worker: dict, records: list[dict],
+    windows: list[tuple[str, str]], status_paths: list[Path | None],
+) -> tuple[list[Path], dict]:
+    candidates = list(dict.fromkeys(
+        path for cwd in _worker_session_cwds(project_root, records)
+        for path in _cli_sessions_for_windows(provider, cwd, windows)
+    ))
+    if provider != "codex":
+        return candidates, {}
+    wanted = {str(record["sessionId"]) for record in records if record.get("sessionId")}
+    for raw in _worker_prompt_paths(worker, records):
+        prompt = _resolve_project_path(project_root, raw)
+        if prompt is not None:
+            wanted.update(codex_wrapper_session_ids(log_path_for_prompt(prompt)))
+    for path in status_paths:
+        status = read_wrapper_status(path) if path is not None else None
+        if status is not None and status.raw.get("sessionId"):
+            wanted.add(str(status.raw["sessionId"]))
+    if wanted:
+        selected = [path for path in candidates if codex_session_ids(path) & wanted]
+        found = {session_id for path in selected for session_id in codex_session_ids(path)}
+        return selected, {"attribution": "session-id", "requestedSessionIds": sorted(wanted),
+                          "missingSessionIds": sorted(wanted - found)}
+    unique_windows = all(
+        len({path for cwd in _worker_session_cwds(project_root, records)
+             for path in _cli_sessions_for_windows(provider, cwd, [window])}) <= 1
+        for window in windows
+    )
+    if unique_windows:
+        return candidates, {"attribution": "legacy-window"}
+    return [], {
+        "attribution": "ambiguous", "unattributedCliSessionPaths": [str(path) for path in candidates],
+        "cliNote": "Several Codex sessions match the wrapper window; no session identity was recorded.",
+    }
+
+
+def _remove_shared_codex_usage(state: dict) -> None:
+    """같은 세션의 시간대 추정을 확정된 소유자보다 우선하지 않는다."""
+    rows = [row for row in accounting_workers(state)
+            if (row.get("usage") or {}).get("source") == "codex-cli"]
+    owners: dict[str, list[dict]] = {}
+    for row in rows:
+        for path in row["usage"].get("cliSessionPaths") or []:
+            owners.setdefault(path, []).append(row)
+    exclusions = []
+    for row in rows:
+        block = row["usage"]
+        rejected = []
+        for path in block.get("cliSessionPaths") or []:
+            shared = owners[path]
+            if len(shared) < 2:
+                continue
+            exact = [item for item in shared if item["usage"].get("attribution") == "session-id"]
+            if len(exact) != 1 or exact[0] is not row:
+                rejected.append(path)
+        if not rejected:
+            continue
+        exclusions.append((row, rejected))
+    for row, rejected in exclusions:
+        block = row["usage"]
+        kept = [Path(path) for path in block.get("cliSessionPaths") or [] if path not in rejected]
+        replacement = collect_cli_usage(provider="codex", status_path=None, sessions=kept)
+        replacement.update({key: block[key] for key in ("durationMs", "cliExecutionStatus") if key in block})
+        replacement.update(attribution="ambiguous", unattributedCliSessionPaths=rejected,
+                           cliNote="Codex session matched more than one worker; duplicate attribution excluded.")
+        row["usage"] = replacement
+
+
+def _unattributed_usage(state: dict, claude_usage: dict | None) -> dict | None:
+    workers = accounting_workers(state)
+    assigned = {path for row in workers for path in (row.get("usage") or {}).get("cliSessionPaths") or []}
+    assigned.update((state.get("leadUsage") or {}).get("cliSessionPaths") or [])
+    ambiguous = {path for row in workers
+                 for path in (row.get("usage") or {}).get("unattributedCliSessionPaths") or []}
+    paths = [Path(path) for path in sorted(ambiguous - assigned)]
+    totals = _cli_session_totals("codex", paths)
+    if not totals:
+        return claude_usage
+    cli_usage = _cli_usage_block("codex", _aggregate_totals(totals), paths)
+    blocks = [cli_usage] + ([claude_usage] if claude_usage is not None else [])
+    combined = _aggregate_totals(blocks)
+    for key in ("billableEquivalentTokens", "estimatedCostUsd", "cliEstimatedCostUsd"):
+        combined[key] = sum(block.get(key, 0) or 0 for block in blocks)
+    combined.update(source="unattributed", cliSessionPaths=[str(path) for path in paths],
+                    note="Measured session usage counted once; worker identity is ambiguous.")
+    if claude_usage is not None:
+        combined["sessionIds"] = claude_usage.get("sessionIds") or []
+    return combined
+
+
 def _wrapper_claude_worker(worker: dict) -> bool:
     """호스트가 claude 가 아닐 때 래퍼로 띄운 claude 워커."""
     provider = str(worker.get("provider") or worker.get("agent") or "").strip()
@@ -979,10 +1074,11 @@ def _claude_wrapper_usage_block(
     호스트의 `collect_claude_runtime_usage` 가 같은 id 로 하는 일을 여기서 한다.
     """
     since, until = window
-    session_ids = worker_session_ids(state, worker_id)
+    session_ids = usage_session_ids(state, worker_id)
     if not session_ids:
-        return na_block(
-            "claude wrapper worker has no dispatch session id recorded in workerDispatches"
+        return _claude_wrapper_status_usage(
+            project_root, usage_dispatch_records(state, worker_id),
+            "claude wrapper worker has no dispatch session id recorded in workerDispatches",
         )
     totals: list[dict] = []
     paths: list[Path] = []
@@ -1002,7 +1098,8 @@ def _claude_wrapper_usage_block(
         paths.append(path)
         attributed.append(session_id)
     if not totals:
-        return na_block(
+        return _claude_wrapper_status_usage(
+            project_root, usage_dispatch_records(state, worker_id),
             "claude session jsonl not found under "
             f"{claude_project_dir(project_root)} for dispatch session ids {session_ids}"
         )
@@ -1012,30 +1109,23 @@ def _claude_wrapper_usage_block(
     return block
 
 
-def _attach_cli_usage(
-    block: dict,
-    provider: str,
-    project_root: Path,
-    windows: list[tuple[str, str]],
-    status_path: Path | None,
-    fallback_window_used: bool,
-) -> None:
-    """Layer aggregated CLI token/cost onto a Claude-side worker ``block``.
-
-    A CLI-wrapper worker re-dispatched within one aggregated wrapper
-    window produces several rollout jsonls; pricing only the latest (the old
-    ``find_codex_session`` -> ``sessions[-1]`` behavior) dropped the earlier
-    attempts' tokens. We sum every in-window session here so the redispatched
-    CLI spend is fully reported. antigravity 는 status 사이드카의 ``usage``
-    스냅샷을 같은 합산 경로에 붙인다.
-    """
-    session_paths = _cli_sessions_for_windows(provider, project_root, windows)
-    cli = collect_cli_usage(
-        provider=provider,
-        status_path=status_path,
-        sessions=session_paths,
-        fallback_window_used=fallback_window_used,
-    )
+def _claude_wrapper_status_usage(project_root: Path, records: list, reason: str) -> dict:
+    paths = []
+    for raw in _worker_prompt_paths({}, records):
+        prompt = _resolve_project_path(project_root, raw)
+        if prompt is not None:
+            paths.append(status_path_for_prompt(prompt))
+    totals = _cli_session_totals("claude", paths)
+    if not totals:
+        return na_block(reason)
+    block = usage_block(_aggregate_totals(totals), source="claude-jsonl")
+    block["attribution"] = "wrapper-status"
+    block["statusPaths"] = [str(path) for path in paths]
+    return block
+
+
+def _attach_cli_usage(block: dict, cli: dict) -> None:
+    """Claude 호스트 사용량에 이미 귀속한 공급자 CLI 비용을 붙인다."""
     for key in (
         "cliTotalTokens",
         "cliEstimatedCostUsd",
@@ -1055,16 +1145,17 @@ def _collect_cli_runtime_usage(
     *,
     incremental: bool = True,
 ) -> dict:
+    state["additionalWorkerUsage"] = unrostered_usage_workers(state)
     windows_by_worker = _codex_worker_windows(project_root, state)
     run_window: tuple[str | None, str | None] = (None, None)
     if team_state_path is not None:
         run_window = resolve_run_window(team_state_path, state)
-    for worker in state.get("workers", []):
+    for worker in accounting_workers(state):
         if not isinstance(worker, dict):
             continue
         worker_id = str(worker.get("workerId") or "").strip()
         records = [
-            dict(record) for record in worker_dispatch_records(state, worker_id)
+            dict(record) for record in usage_dispatch_records(state, worker_id)
         ] if worker_id else []
         provider = _cli_assignment_provider(worker)
         if provider:
@@ -1090,6 +1181,7 @@ def _collect_cli_runtime_usage(
                 f"{worker.get('provider') or worker.get('agent') or worker.get('workerId')}"
             )
     state["leadUsage"] = _cli_lead_usage(state, project_root, team_state_path)
+    _remove_shared_codex_usage(state)
     _populate_usage_summary(state, team_name=resolve_team_name(state),
                             sessions_found=0, needle_source="none")
     return state
@@ -1130,7 +1222,7 @@ def _cli_lead_usage(
         )
     worker_paths = {
         Path(path)
-        for worker in state.get("workers") or []
+        for worker in accounting_workers(state)
         if isinstance(worker, dict)
         for path in ((worker.get("usage") or {}).get("cliSessionPaths") or [])
     }
@@ -1222,17 +1314,7 @@ def _pinned_cli_lead_session(
     return None
 
 
-def _populate_usage_summary(
-    state: dict,
-    *,
-    team_name: str,
-    sessions_found: int,
-    unattributed_sessions: list[str] | None = None,
-    unattributed_usage: dict[str, Any] | None = None,
-    needle_source: str = "observed-team-names",
-) -> None:
-    workers = state.get("workers", [])
-    lead = state.get("leadUsage") or {}
+def _usage_summary_totals(lead: dict, workers: list[dict], unattributed_usage: dict | None) -> dict:
     lead_total = lead.get("totalTokens", 0) or 0
     lead_cache_read = lead.get("cacheReadTokens", 0) or 0
     lead_billable = lead.get("billableEquivalentTokens", 0) or 0
@@ -1247,7 +1329,28 @@ def _populate_usage_summary(
         worker_cache_read += unattributed_usage.get("cacheReadTokens", 0) or 0
         worker_billable += unattributed_usage.get("billableEquivalentTokens", 0) or 0
         worker_cost += unattributed_usage.get("estimatedCostUsd", 0) or 0
+        cli_cost += unattributed_usage.get("cliEstimatedCostUsd", 0) or 0
+
+    return {
+        "leadTotalTokens": lead_total,
+        "workerTotalTokens": worker_total,
+        "grandTotalTokens": lead_total + worker_total,
+        "leadCacheReadTokens": lead_cache_read,
+        "workerCacheReadTokens": worker_cache_read,
+        "grandCacheReadTokens": lead_cache_read + worker_cache_read,
+        "leadBillableEquivalentTokens": lead_billable,
+        "workerBillableEquivalentTokens": worker_billable,
+        "grandBillableEquivalentTokens": lead_billable + worker_billable,
+        "estimatedCostUsd": {
+            "lead": round(lead_cost, 4),
+            "claudeWorkers": round(worker_cost, 4),
+            "cliWorkers": round(cli_cost, 4),
+            "grandTotal": round(lead_cost + worker_cost + cli_cost, 4),
+        },
+    }
+
 
+def _unmatched_usage_models(lead: dict, workers: list[dict]) -> list[str]:
     unmatched_models: list[str] = []
     if (
         lead.get("model")
@@ -1270,27 +1373,28 @@ def _populate_usage_summary(
             unmatched_models.append(u["model"])
         if u.get("cliModel") and u.get("cliEstimatedCostUsd") is None and (u.get("cliTotalTokens") or 0) > 0:
             unmatched_models.append(u["cliModel"])
+    return sorted(set(unmatched_models))
+
+
+def _populate_usage_summary(
+    state: dict,
+    *,
+    team_name: str,
+    sessions_found: int,
+    unattributed_sessions: list[str] | None = None,
+    unattributed_usage: dict[str, Any] | None = None,
+    needle_source: str = "observed-team-names",
+) -> None:
+    workers = accounting_workers(state)
+    unattributed_usage = _unattributed_usage(state, unattributed_usage)
+    lead = state.get("leadUsage") or {}
     state["usageSummary"] = {
-        "leadTotalTokens": lead_total,
-        "workerTotalTokens": worker_total,
-        "grandTotalTokens": lead_total + worker_total,
-        "leadCacheReadTokens": lead_cache_read,
-        "workerCacheReadTokens": worker_cache_read,
-        "grandCacheReadTokens": lead_cache_read + worker_cache_read,
-        "leadBillableEquivalentTokens": lead_billable,
-        "workerBillableEquivalentTokens": worker_billable,
-        "grandBillableEquivalentTokens": lead_billable + worker_billable,
-        "estimatedCostUsd": {
-            "lead": round(lead_cost, 4),
-            "claudeWorkers": round(worker_cost, 4),
-            "cliWorkers": round(cli_cost, 4),
-            "grandTotal": round(lead_cost + worker_cost + cli_cost, 4),
-        },
+        **_usage_summary_totals(lead, workers, unattributed_usage),
         "collectedAt": utc_now(),
         "teamName": team_name,
         "needleSource": needle_source,
         "sessionsFound": sessions_found,
-        "unmatchedModels": sorted(set(unmatched_models)),
+        "unmatchedModels": _unmatched_usage_models(lead, workers),
         "unattributedTeamSessions": unattributed_sessions or [],
         "unattributedWorkerUsage": unattributed_usage,
         "definitions": {
@@ -1302,18 +1406,10 @@ def _populate_usage_summary(
     }
 
 
-def collect_claude_runtime_usage(
-    team_state_path: Path,
-    project_root: Path | None = None,
-    *,
-    incremental: bool = True,
-) -> dict:
-    # incremental: 세션 jsonl 스캔에 byte cursor 캐시 사용 (P6). 캐시는 윈도우
-    # 적용 전 이벤트를 저장하므로 결과는 전체 스캔과 동일 — False 는 캐시 경로를
-    # 완전히 우회하는 정확성 폴백(CLI --no-cache).
-    state = json.loads(team_state_path.read_text())
-    cwd = project_root or _infer_project_root(team_state_path, state)
-    run_since, run_until = resolve_run_window(team_state_path, state)
+def _claude_sessions_for_run(
+    state: dict, team_state_path: Path, cwd: Path,
+    run_since: str | None, run_until: str | None, incremental: bool,
+) -> tuple:
     team_name = resolve_team_name(state)
     lead_sid = (state.get("lead") or {}).get("sessionId")
 
@@ -1341,6 +1437,13 @@ def collect_claude_runtime_usage(
                 if ts and (found_earliest is None or ts < found_earliest):
                     found_earliest = ts
             run_since = relax_window_start(run_since, found_earliest, floor)
+    return team_name, lead_sid, claude_sessions, run_since, needle_source
+
+
+def _claude_session_evidence(
+    state: dict, cwd: Path, claude_sessions: dict, lead_sid: str | None,
+    run_since: str | None, run_until: str | None, incremental: bool,
+) -> tuple:
     by_agent: dict[str, list[tuple[str, Path, dict]]] = {}
     lead_path: Path | None = None
     # Team-tagged non-lead sessions that carry no agentName. These are almost
@@ -1375,7 +1478,7 @@ def collect_claude_runtime_usage(
     if team_create_status in ("implicit", "skipped", "error"):
         worker_prefix_pool = [
             prefix
-            for w in state.get("workers", [])
+            for w in accounting_workers(state)
             for prefix in match_prefixes(w.get("workerId") or "")
         ]
         subagent_parent_sids = [lead_sid] if lead_sid else []
@@ -1394,6 +1497,13 @@ def collect_claude_runtime_usage(
             if agent:
                 by_agent.setdefault(agent, []).append((sid, path, totals))
 
+    return by_agent, lead_path, unattributed_sessions, unattributed_totals
+
+
+def _attach_claude_lead_usage(
+    state: dict, cwd: Path, lead_path: Path | None, lead_sid: str | None,
+    run_since: str | None, run_until: str | None, incremental: bool,
+) -> None:
     # Lead.
     if lead_path is not None:
         totals = claude_session_totals(lead_path, since=run_since, until=run_until,
@@ -1406,84 +1516,93 @@ def collect_claude_runtime_usage(
             f"lead session jsonl not found under {claude_project_dir(cwd)} (sessionId={lead_sid})"
         )
 
+
+
+def _matching_claude_worker_sessions(
+    worker: dict, state: dict, cwd: Path, by_agent: dict,
+    run_since: str | None, run_until: str | None, incremental: bool,
+) -> tuple:
+    sessions_dir = claude_project_dir(cwd)
+    worker_id = worker.get("workerId")
+    prefixes = match_prefixes(worker_id) if worker_id else []
+
+    # pane 워커는 별도 `claude -p` 프로세스라 jsonl 에 agentName 도 teamName
+    # 도 안 남긴다 — 아래 prefix 경로로는 영원히 매칭되지 않는다. dispatch 가
+    # 발급해 적어 둔 이 id 가 그 세션을 짚는 유일한 결정적 단서다. 재시도는
+    # attempt 마다 새 세션이므로 기록된 id 를 전부 합산한다.
+    # 헬퍼에서 worker_id=None 은 "run 전체"라, 이름 없는 워커에 그대로 넘기면
+    # 그 워커가 run 의 모든 세션을 흡수한다.
+    dispatched_sids = usage_session_ids(state, worker_id) if worker_id else []
+    matched: list[tuple[str, Path, dict]] = []
+    matched_sids: set[str] = set()
+    for sid in dispatched_sids:
+        path = sessions_dir / f"{sid}.jsonl"
+        if not path.is_file():
+            continue
+        totals = claude_session_totals(path, since=run_since, until=run_until,
+                                       incremental=incremental)
+        # 창 밖 세션은 여기서 버린다 — agentName 발견 경로가 위에서 같은
+        # `startedAt` 검사로 거르는 것과 같은 이유다. 넣으면 0 토큰 totals 가
+        # usage_block 을 타고 "이 워커는 0 을 썼다"로 보고되어, unavailable 로
+        # 남아야 할 상태를 허위 0 이 덮는다.
+        if not totals.get("startedAt"):
+            continue
+        matched.append((sid, path, totals))
+        matched_sids.add(sid)
+
+    # 조건부 폴백이 아니라 합집합이다. 한 워커의 attempt 1 이 pane(sid 로만
+    # 찾힌다), attempt 2 가 in-process 서브에이전트(agentName 으로만 찾힌다)일
+    # 수 있고, `if not matched:` 로 두면 sid 가 하나라도 맞는 순간 attempt 2 의
+    # 토큰이 통째로 누락된다. 양쪽에서 온 같은 세션은 sid 로 한 번만 센다.
+    for agent_name, entries in by_agent.items():
+        if not agent_matches(agent_name, prefixes):
+            continue
+        for entry in entries:
+            if entry[0] in matched_sids:
+                continue
+            # team-needle 경로는 창 검사 없이 by_agent 를 채운다. 같은 리드
+            # 세션의 다음 run 이 띄운 워커도 같은 needle 에 걸리는데, 창 밖이라
+            # startedAt 이 없어 아래 정렬에서 맨 앞에 서고 `sessionId` 를
+            # 차지한다 — 토큰은 0 이라 합계는 안 틀리고 리포트가 가리키는
+            # 세션만 남의 것이 된다.
+            if not entry[2].get("startedAt"):
+                continue
+            matched.append(entry)
+            matched_sids.add(entry[0])
+
+    return matched, dispatched_sids, prefixes
+
+
+def _collect_claude_workers(
+    state: dict, cwd: Path, by_agent: dict,
+    run_since: str | None, run_until: str | None, incremental: bool,
+) -> set[str]:
     # Workers — dispatch 가 기록한 세션 id 로 짚은 세션과 agentName prefix 로
     # 찾은 세션의 합집합을 합산한다(재배치 `-002`, convergence `-reverify-r1`,
     # implementation `-executor`, report-writer `-impl` / `-2` 등).
-    sessions_dir = claude_project_dir(cwd)
     # sid 로 귀속한 세션 id 전체 — 아래 unattributed 폴드에서 빼는 데 쓴다.
     attributed_sids: set[str] = set()
     cli_windows_by_worker = _codex_worker_windows(cwd, state)
-    for worker in state.get("workers", []):
+    for worker in accounting_workers(state):
         worker_id = worker.get("workerId")
-        agent = worker.get("agent")
-        prefixes = match_prefixes(worker_id) if worker_id else []
-
-        # pane 워커는 별도 `claude -p` 프로세스라 jsonl 에 agentName 도 teamName
-        # 도 안 남긴다 — 아래 prefix 경로로는 영원히 매칭되지 않는다. dispatch 가
-        # 발급해 적어 둔 이 id 가 그 세션을 짚는 유일한 결정적 단서다. 재시도는
-        # attempt 마다 새 세션이므로 기록된 id 를 전부 합산한다.
-        # 헬퍼에서 worker_id=None 은 "run 전체"라, 이름 없는 워커에 그대로 넘기면
-        # 그 워커가 run 의 모든 세션을 흡수한다.
-        dispatched_sids = worker_session_ids(state, worker_id) if worker_id else []
-        matched: list[tuple[str, Path, dict]] = []
-        matched_sids: set[str] = set()
-        for sid in dispatched_sids:
-            path = sessions_dir / f"{sid}.jsonl"
-            if not path.is_file():
-                continue
-            totals = claude_session_totals(path, since=run_since, until=run_until,
-                                           incremental=incremental)
-            # 창 밖 세션은 여기서 버린다 — agentName 발견 경로가 위에서 같은
-            # `startedAt` 검사로 거르는 것과 같은 이유다. 넣으면 0 토큰 totals 가
-            # usage_block 을 타고 "이 워커는 0 을 썼다"로 보고되어, unavailable 로
-            # 남아야 할 상태를 허위 0 이 덮는다.
-            if not totals.get("startedAt"):
-                continue
-            matched.append((sid, path, totals))
-            matched_sids.add(sid)
-            attributed_sids.add(sid)
-
-        # 조건부 폴백이 아니라 합집합이다. 한 워커의 attempt 1 이 pane(sid 로만
-        # 찾힌다), attempt 2 가 in-process 서브에이전트(agentName 으로만 찾힌다)일
-        # 수 있고, `if not matched:` 로 두면 sid 가 하나라도 맞는 순간 attempt 2 의
-        # 토큰이 통째로 누락된다. 양쪽에서 온 같은 세션은 sid 로 한 번만 센다.
-        for agent_name, entries in by_agent.items():
-            if not agent_matches(agent_name, prefixes):
-                continue
-            for entry in entries:
-                if entry[0] in matched_sids:
-                    continue
-                # team-needle 경로는 창 검사 없이 by_agent 를 채운다. 같은 리드
-                # 세션의 다음 run 이 띄운 워커도 같은 needle 에 걸리는데, 창 밖이라
-                # startedAt 이 없어 아래 정렬에서 맨 앞에 서고 `sessionId` 를
-                # 차지한다 — 토큰은 0 이라 합계는 안 틀리고 리포트가 가리키는
-                # 세션만 남의 것이 된다.
-                if not entry[2].get("startedAt"):
-                    continue
-                matched.append(entry)
-                matched_sids.add(entry[0])
-
+        matched, dispatched_sids, prefixes = _matching_claude_worker_sessions(
+            worker, state, cwd, by_agent, run_since, run_until, incremental,
+        )
+        attributed_sids.update(sid for sid, _path, _totals in matched)
         if not matched:
             provider = _cli_assignment_provider(worker)
             if provider and str(worker.get("runner") or "") == "cli-wrapper":
                 worker["usage"] = _worker_cli_usage_block(
-                    provider=provider,
-                    project_root=cwd,
-                    worker=worker,
-                    records=[
-                        dict(record)
-                        for record in worker_dispatch_records(
-                            state, str(worker_id or "").strip()
-                        )
-                    ] if worker_id else [],
-                    fallback_windows=cli_windows_by_worker.get(
-                        str(worker_id or "").strip(), []
-                    ),
+                    provider=provider, project_root=cwd, worker=worker,
+                    records=[dict(record) for record in usage_dispatch_records(state, worker_id)]
+                    if worker_id else [],
+                    fallback_windows=cli_windows_by_worker.get(worker_id, []),
                 )
             else:
-                worker["usage"] = na_block(
+                worker["usage"] = _claude_wrapper_status_usage(
+                    cwd, usage_dispatch_records(state, worker_id) if worker_id else [],
                     "no Claude session jsonl in the run window for dispatched "
-                    f"sessionIds {dispatched_sids} or agentName prefixes {prefixes}"
+                    f"sessionIds {dispatched_sids} or agentName prefixes {prefixes}",
                 )
             continue
 
@@ -1501,21 +1620,20 @@ def collect_claude_runtime_usage(
         # attributable provider transcript usage without treating absence as zero.
         provider = _cli_assignment_provider(worker)
         if provider:
-            windows, status_path, used_fallback = _worker_cli_windows(
-                cwd,
-                worker,
-                [(aggregate.get("startedAt") or "", aggregate.get("endedAt") or "")],
-            )
-            _attach_cli_usage(
-                block,
-                provider,
-                cwd,
-                windows,
-                status_path,
-                used_fallback,
+            cli = _worker_cli_usage_block(
+                provider=provider, project_root=cwd, worker=worker,
+                records=[dict(record) for record in usage_dispatch_records(state, worker_id)],
+                fallback_windows=cli_windows_by_worker.get(worker_id, []),
             )
+            _attach_cli_usage(block, cli)
         worker["usage"] = block
 
+    return attributed_sids
+
+
+def _unattributed_claude_usage(
+    unattributed_sessions: list[str], unattributed_totals: list[dict], attributed_sids: set[str],
+) -> tuple[list[str], dict | None]:
     # Fold team-tagged worker sessions that carry no agentName into the worker
     # pool. They cannot be mapped to a specific workerId (so each named worker
     # row above stays `unavailable`), but the tokens are real team-worker spend —
@@ -1551,12 +1669,31 @@ def collect_claude_runtime_usage(
             "cannot be mapped to a specific workerId."
         )
 
+    return unattributed_sessions, unattributed_usage
+
+
+def collect_claude_runtime_usage(
+    team_state_path: Path, project_root: Path | None = None, *, incremental: bool = True,
+) -> dict:
+    state = json.loads(team_state_path.read_text())
+    state["additionalWorkerUsage"] = unrostered_usage_workers(state)
+    cwd = project_root or _infer_project_root(team_state_path, state)
+    run_since, run_until = resolve_run_window(team_state_path, state)
+    team_name, lead_sid, sessions, run_since, needle_source = _claude_sessions_for_run(
+        state, team_state_path, cwd, run_since, run_until, incremental,
+    )
+    by_agent, lead_path, unattributed_sessions, unattributed_totals = _claude_session_evidence(
+        state, cwd, sessions, lead_sid, run_since, run_until, incremental,
+    )
+    _attach_claude_lead_usage(state, cwd, lead_path, lead_sid, run_since, run_until, incremental)
+    attributed = _collect_claude_workers(state, cwd, by_agent, run_since, run_until, incremental)
+    unattributed_sessions, unattributed_usage = _unattributed_claude_usage(
+        unattributed_sessions, unattributed_totals, attributed,
+    )
+    _remove_shared_codex_usage(state)
     _populate_usage_summary(
-        state,
-        team_name=team_name,
-        sessions_found=len(claude_sessions),
-        unattributed_sessions=unattributed_sessions,
-        unattributed_usage=unattributed_usage,
+        state, team_name=team_name, sessions_found=len(sessions),
+        unattributed_sessions=unattributed_sessions, unattributed_usage=unattributed_usage,
         needle_source=needle_source,
     )
     return state

package/runtime/python/okstra_token_usage/cursor.py

@@ -18,9 +18,8 @@ from pathlib import Path
 
 from okstra_project.dirs import okstra_home
 
-# v2: usage 이벤트에 `p`(lead PROGRESS 마커) 키 추가 — v1 캐시는 이미 스캔한
-# 구간의 마커가 없으므로 폐기하고 전체 재스캔한다(fail-open).
-CACHE_SCHEMA_VERSION = 2
+# 응답 ID가 없는 이전 캐시는 중복 여부를 복구할 수 없어 원본부터 재스캔한다.
+CACHE_SCHEMA_VERSION = 3
 IDENTITY_PREFIX_BYTES = 256
 MAX_NEEDLES = 16