okstra 0.200.1 → 0.201.0

package/runtime/python/okstra_ctl/wizard/state.py

@@ -147,6 +147,10 @@ class WizardState:
     # "" | "yes" | "no" — done(release-handoff) task 재진입의 fix-cycle 기록 여부
     fix_cycle: str = ""
     confirmed: Optional[bool] = None
+    confirmation_stages: str = ""
+    confirmation_prompt: str = ""
+    confirmation_scope: dict[str, Any] = field(default_factory=dict)
+    user_authorization: dict[str, Any] = field(default_factory=dict)
     edit_target: str = ""
     # terminal: user picked 중단 — no further prompt ever applies
     aborted: bool = False
@@ -225,26 +229,28 @@ class Prompt:
         self._check_recommendations()
 
     def _check_recommendations(self) -> None:
-        """단일 선택의 추천은 정확히 하나이고 1번이다. 탈출구는 추천이 아니다.
+        """단일 추천은 하나다. 모델 선택은 제공자 순서, 그 외에는 추천이 앞이다.
 
         실측(2026-09-09, task 선택 화면): 남은 task 세 줄이 전부 `(추천)` 을
         달고 나왔고, 리드는 산문에서 2번을 권했다. 추천이 여럿이면 라벨은
         아무것도 고르지 않은 것이고, 추천이 1번이 아니면 사용자는 목록을
-        끝까지 읽어야 추천을 찾는다. 체크박스(`multi`)는 추천이 기본 선택
-        집합이라 여럿일 수 있되 앞머리에 모여 있다. 그리고 `직접 입력` /
+        끝까지 읽어야 추천을 찾는다. 모델 선택은 제공자별 묶음을 우선한다.
+        그 외 체크박스(`multi`)는 추천이 여럿일 수 있되 앞머리에 모인다.
+        그리고 `직접 입력` /
         `중단` 은 앞의 선택지가 전부 맞지 않을 때의 탈출구이므로 추천 대상이
         될 수 없다.
         """
         flags = [option.recommended for option in self.options]
+        grouped_models = self.step.startswith(("role-models:", "role-model:"))
         if any(flags):
             if self.multi:
-                if any(flags[index] for index in range(1, len(flags))
+                if not grouped_models and any(flags[index] for index in range(1, len(flags))
                        if not flags[index - 1]):
                     raise WizardError(
                         f"wizard step {self.step!r}: recommended options must "
                         "be the leading run of the list"
                     )
-            elif sum(flags) != 1 or not flags[0]:
+            elif sum(flags) != 1 or (not grouped_models and not flags[0]):
                 raise WizardError(
                     f"wizard step {self.step!r}: a single-select step carries "
                     "exactly one recommendation and it is the first option"
@@ -684,7 +690,8 @@ _FIELD_DEFAULTS: dict[str, Any] = {
     "pr_template_path": "", "pr_template_pending_text": False,
     "pr_template_scope": "",
     "fix_cycle": "",
-    "confirmed": None, "edit_target": "",
+    "confirmed": None, "edit_target": "", "confirmation_prompt": "", "confirmation_stages": "",
+    "confirmation_scope": {}, "user_authorization": {},
 }
 
 

package/runtime/python/okstra_ctl/wizard/steps_plan.py

@@ -12,6 +12,7 @@ from okstra_ctl.incremental_scope import CARRY_ALL_SCOPE
 from okstra_ctl.implementation_direction import (
     DirectionSelectionError,
     lexical_absolute_path,
+    resolve_selected_direction,
     validate_task_artifact_path,
 )
 from okstra_ctl.final_report_paths import final_report_data_path
@@ -191,6 +192,13 @@ def _submit_selected_direction_pick(
     candidates = _selected_direction_candidates(state)
     if value not in candidates:
         raise WizardError(t["errors"]["unknown"].format(value=value))
+    try:
+        resolve_selected_direction(
+            Path(state.project_root) / value,
+            expected_task_key=f"{state.project_id}:{state.task_group}:{state.task_id}",
+        )
+    except DirectionSelectionError as exc:
+        raise WizardError(str(exc)) from exc
     state.selected_direction_path = value
     # 두 입력은 상호 배타다 — 방향이 정해진 순간 이 런은 새 계획이고,
     # clarification 자리에 남은 값은 render-bundle 이 거절할 이유일 뿐이다.

package/runtime/python/okstra_ctl/worker_liveness.py

@@ -162,7 +162,8 @@ def probe_launch(
     """Whether the wrapper behind *prompt* ever started."""
     log, status = _log_path(prompt), Path(f"{prompt}.status.json")
     probe = {"kind": "launch", "path": str(prompt)}
-    if log.exists() or status.exists():
+    if any(path.is_file() and path.stat().st_mtime >= dispatched_at.timestamp()
+           for path in (log, status)):
         return {**probe, "state": "live", "reason": ""}
     waited = (now - dispatched_at).total_seconds()
     if waited <= grace:
@@ -273,7 +274,8 @@ def probe_all(
 def result_ready(target: ProbeTarget) -> bool:
     """Whether this worker's result file has landed with content in it."""
     path = target.result_path
-    return bool(path and path.is_file() and path.stat().st_size > 0)
+    return bool(path and path.is_file() and path.stat().st_size > 0
+                and path.stat().st_mtime >= target.dispatched_at.timestamp())
 
 
 def wait_for_results(
@@ -370,53 +372,58 @@ def _dispatch_worker_id(record: Mapping[str, Any]) -> str:
     return ""
 
 
-def _dispatch_fallback(state: Mapping[str, Any], worker_id: str) -> dict:
-    """같은 워커의 디스패치 행 중 마지막 것.
-
-    로스터 행에 없는 키를 여기서 보충한다. 재디스패치는 같은 워커의 행을 뒤에
-    덧붙이므로 마지막 행이 이번 시도다.
-    """
-    records = state.get("workerDispatches")
-    if not isinstance(records, list):
-        return {}
+def _dispatch_fallback(state: Mapping[str, Any], worker_id: str, dispatch_id: str = "") -> dict:
+    """명시한 배정 또는 하나로 확정되는 구형 배정만 선택한다."""
+    records = state.get("workerDispatches") or []
     matches = [
-        row for row in records
-        if isinstance(row, Mapping) and _dispatch_worker_id(row) == worker_id
+        row for row in records if isinstance(row, Mapping)
+        and (row.get("dispatchId") == dispatch_id if dispatch_id
+             else _dispatch_worker_id(row) == worker_id)
     ]
-    return dict(matches[-1]) if matches else {}
-
+    if len(matches) > 1:
+        raise DispatchError(f"multiple dispatches for {worker_id or dispatch_id}; pass --dispatch-id")
+    if dispatch_id and not matches:
+        raise DispatchError(f"team-state has no dispatchId={dispatch_id}")
+    return dict(matches[0]) if matches else {}
 
-def _worker_row(team_state_path: Path, worker_id: str) -> dict:
-    """이 워커의 프로브 입력 — 로스터 행에 디스패치 행을 덧댄 것.
 
-    `livenessMode` 는 디스패치 행에만 실린다(`dispatch_core._dispatch_record`);
-    로스터 행은 그 키를 갖지 않는다. 로스터만 읽으면 cmux 백엔드의 모든 run 에서
-    프로브가 전면 거부되고, 리드는 계약이 금지한 자체 폴링으로 밀려난다.
-    보충은 로스터에 없거나 빈 키에만 적용한다 — `startedAt` 처럼 로스터가 정본인
-    값을 디스패치 행이 덮어쓰면 grace 앵커가 이번 시도에서 어긋난다.
-    """
+def _worker_row(team_state_path: Path, worker_id: str, dispatch_id: str = "") -> dict:
+    """새 배정의 필드는 원자적으로 읽고 구형 단일 기록만 보완한다."""
     state = load_json_object(team_state_path, "team-state")
+    dispatch = _dispatch_fallback(state, worker_id, dispatch_id)
+    if dispatch.get("dispatchId") and dispatch.get("startedAt"):
+        result = dispatch.get("resultPath")
+        root = _project_root_for_team_state(team_state_path)
+        if result and any(
+            isinstance(row, Mapping) and row.get("dispatchId") != dispatch["dispatchId"]
+            and row.get("status") not in {"completed", "error", "timeout", "not-run"}
+            and row.get("resultPath")
+            and (root / row["resultPath"]).resolve() == (root / result).resolve()
+            for row in state.get("workerDispatches", [])
+        ):
+            raise DispatchError("resultPath is shared by dispatches; use an attempt-specific result path")
+        return dispatch
     workers = state.get("workers")
     if not isinstance(workers, list):
         raise DispatchError(f"team-state workers must be an array: {team_state_path}")
-    worker = next(
-        (
-            row for row in workers
-            if isinstance(row, dict) and row.get("workerId") == worker_id
-        ),
-        None,
-    )
+    selected_worker = _dispatch_worker_id(dispatch) if dispatch_id else worker_id
+    worker = next((row for row in workers if isinstance(row, dict)
+                   and row.get("workerId") == selected_worker), None)
     if worker is None:
-        raise DispatchError(f"team-state has no workerId={worker_id}: {team_state_path}")
+        raise DispatchError(f"team-state has no workerId={selected_worker}: {team_state_path}")
+    if dispatch and worker.get("promptPath") and dispatch.get("promptPath"):
+        root = _project_root_for_team_state(team_state_path)
+        if (root / worker["promptPath"]).resolve() != (root / dispatch["promptPath"]).resolve():
+            raise DispatchError("dispatch has no startedAt and roster promptPath differs; repair the recorded attempt")
     merged = dict(worker)
-    for key, value in _dispatch_fallback(state, worker_id).items():
+    for key, value in dispatch.items():
         current = merged.get(key)
         if key not in merged or (isinstance(current, str) and not current.strip()):
             merged[key] = value
     return merged
 
 
-def probe_target(team_state_value: str, worker_id: str) -> ProbeTarget:
+def probe_target(team_state_value: str, worker_id: str, *, dispatch_id: str = "") -> ProbeTarget:
     """Resolve one worker's probe target from team-state.
 
     ``livenessMode`` is authoritative — never infer the transport from the
@@ -424,7 +431,7 @@ def probe_target(team_state_value: str, worker_id: str) -> ProbeTarget:
     worker for a wrapper log that will never exist.
     """
     team_state_path = Path(team_state_value).resolve()
-    worker = _worker_row(team_state_path, worker_id)
+    worker = _worker_row(team_state_path, worker_id, dispatch_id)
     mode = worker.get("livenessMode")
     field = _ARTIFACT_FIELD_BY_MODE.get(mode) if isinstance(mode, str) else None
     if field is None:
@@ -492,6 +499,8 @@ def main(argv: list[str] | None = None) -> int:
                         help="team-state path for a pending worker (repeatable)")
     parser.add_argument("--worker", action="append", default=[],
                         help="worker id paired with --team-state (repeatable)")
+    parser.add_argument("--dispatch-id", action="append", default=[],
+                        help="exact dispatch id paired with --team-state; do not mix with --worker")
     parser.add_argument("--max-idle", type=float, default=HEARTBEAT_MAX_GAP_SECONDS,
                         help="heartbeat staleness budget in seconds")
     parser.add_argument("--launch-grace", type=float, default=DEFAULT_LAUNCH_GRACE_SECONDS,
@@ -520,15 +529,19 @@ def main(argv: list[str] | None = None) -> int:
     )
     args = parser.parse_args(argv)
 
-    if len(args.team_state) != len(args.worker):
-        parser.error("each --team-state must have one paired --worker")
+    if args.worker and args.dispatch_id:
+        parser.error("use --worker or --dispatch-id, not both")
+    selectors = args.dispatch_id or args.worker
+    if len(args.team_state) != len(selectors):
+        parser.error("each --team-state must have one paired --worker or --dispatch-id")
     if not args.team_state:
         parser.error("pass at least one --team-state/--worker pair")
 
     try:
         targets = [
-            probe_target(team_state, worker)
-            for team_state, worker in zip(args.team_state, args.worker, strict=True)
+            probe_target(team_state, "" if args.dispatch_id else worker,
+                         dispatch_id=worker if args.dispatch_id else "")
+            for team_state, worker in zip(args.team_state, selectors, strict=True)
         ]
     except DispatchError as exc:
         parser.error(str(exc))
@@ -547,7 +560,7 @@ def main(argv: list[str] | None = None) -> int:
         return 0 if result["ok"] else 1
 
     unwaitable = [
-        worker for target, worker in zip(targets, args.worker, strict=True)
+        worker for target, worker in zip(targets, selectors, strict=True)
         if target.result_path is None
     ]
     if unwaitable:

package/runtime/python/okstra_ctl/worker_prompt_policy.py

@@ -49,6 +49,7 @@ FINAL_VERIFICATION_HEADERS = (
     "**Verification target digest:**",
 )
 SUPPORTED_TASK_TYPES = frozenset({
+    "technical-verification",
     "requirements-discovery",
     "error-analysis",
     "implementation-option-selection",
@@ -65,6 +66,7 @@ SUPPORTED_TASK_TYPES = frozenset({
 # something else gets its own. A task type absent from this map takes the
 # observational default below: describe the area, do not design for it.
 ANALYSIS_DUTY_BY_TASK_TYPE: dict[str, AgentAudience] = {
+    "technical-verification": "technical-verification-worker",
     "requirements-discovery": "discovery-worker",
     "improvement-discovery": "discovery-worker",
     "error-analysis": "diagnosis-worker",

package/runtime/python/okstra_ctl/workflow.py

@@ -39,6 +39,14 @@ ERROR_ANALYSIS_ROUTING_DIRECTIONS = {
 # prompt template 에 그대로 박혀 lead 가 읽는다. forbidden actions 는 이 dict 가
 # 아니라 prompts/profiles/forbidden-actions.json (load_phase_forbidden) 이 SSOT.
 PHASE_RULES: dict[str, dict[str, str]] = {
+    "technical-verification": {
+        "allowed": (
+            "  - falsifiable experiment plans for the frozen unresolved facts\n"
+            "  - dependency installation, source experiments, tests and builds only in this run's experiment copies\n"
+            "  - command logs, observed signals and per-fact supported/refuted/inconclusive/not-run results\n"
+            "  - return to implementation-option-selection with evidence, without adoption or plan approval"
+        ),
+    },
     "requirements-discovery": {
         "allowed": (
             "  - work-category classification (bugfix / feature / refactor / ops / improvement)\n"

package/runtime/python/okstra_ctl/write_policy.py

@@ -3,6 +3,7 @@ from __future__ import annotations
 
 import hashlib
 import json
+import re
 import subprocess
 from collections.abc import Mapping, Sequence
 from dataclasses import dataclass
@@ -120,6 +121,27 @@ def _role_qa_artifact_paths(role: str, task_root: Path | None) -> tuple[Path, ..
     return ()
 
 
+
+def _technical_experiment_paths(
+    artifact_paths: Sequence[Path], task_root: Path | None,
+) -> tuple[Path, ...]:
+    """정규 작업 결과 경로에서 해당 작업자의 시험 디렉터리만 파생한다."""
+    if task_root is None:
+        return ()
+    run_root = task_root / "runs" / "technical-verification"
+    paths = set()
+    for artifact in artifact_paths:
+        if artifact.parent != run_root / "worker-results":
+            continue
+        match = re.fullmatch(
+            r"([a-z0-9][a-z0-9-]*)-worker-technical-verification-(\d{3,})\.md",
+            artifact.name,
+        )
+        if match:
+            paths.add(run_root / "experiments" / match[2] / match[1])
+    return tuple(sorted(paths))
+
+
 def build_invocation_write_contract(
     *,
     role: str,
@@ -142,6 +164,7 @@ def build_invocation_write_contract(
             _relative_to_root(path, root, "artifact")
             for path in (
                 *artifact_paths,
+                *_technical_experiment_paths(artifact_paths, task_root),
                 *_role_qa_artifact_paths(role, task_root),
             )
         )

package/runtime/python/okstra_token_usage/blocks.py

@@ -1,12 +1,62 @@
 """Per-source usage block constructors (consumed by collect())."""
 from __future__ import annotations
 
+from collections.abc import Mapping
+from typing import Any
+
 from .paths import utc_now
 from .pricing import (
     claude_billable_equivalent,
     claude_cost_usd,
 )
 
+_CACHE_INCLUDED_SOURCES = frozenset({"codex-cli", "grok-cli", "kimi-cli"})
+
+
+def accounting_workers(state: Mapping[str, Any]) -> list[dict]:
+    """초기 명부와 명부 밖 실행의 사용량 행을 같은 소비 경로로 전달한다."""
+    rows = []
+    for key in ("workers", "additionalWorkerUsage"):
+        collection = state.get(key)
+        if isinstance(collection, list):
+            rows.extend(row for row in collection if isinstance(row, dict))
+    return rows
+
+
+def usage_blocks(state: dict) -> list[dict]:
+    blocks = [state.get("leadUsage") or {}]
+    blocks.extend(worker.get("usage") or {} for worker in accounting_workers(state))
+    unattributed = (state.get("usageSummary") or {}).get("unattributedWorkerUsage")
+    if isinstance(unattributed, dict):
+        blocks.append(unattributed)
+    return [block for block in blocks if isinstance(block, dict)]
+
+
+def normalize_usage_block(block: dict) -> dict:
+    """과거 캐시 포함 합계를 정규화하고 게시 당시 합계를 별도로 보존한다."""
+    normalized = dict(block)
+    cached = block.get("cachedInputTokens") or 0
+    if (
+        block.get("source") not in _CACHE_INCLUDED_SOURCES
+        or "cacheReadTokens" in block
+        or block.get("accountingBasis") == "cache-read-excluded"
+        or not isinstance(cached, int)
+        or isinstance(cached, bool)
+        or cached <= 0
+    ):
+        return normalized
+    total = block.get("totalTokens")
+    if not isinstance(total, int) or total < cached:
+        return normalized
+    normalized["reportedTotalTokens"] = total
+    normalized["totalTokens"] = total - cached
+    normalized["cacheReadTokens"] = cached
+    normalized["accountingBasis"] = "cache-read-excluded"
+    if isinstance(block.get("cliTotalTokens"), int):
+        normalized["reportedCliTotalTokens"] = block["cliTotalTokens"]
+        normalized["cliTotalTokens"] = max(0, block["cliTotalTokens"] - cached)
+    return normalized
+
 
 def usage_block(totals: dict, source: str, note: str | None = None) -> dict:
     block = {
@@ -65,4 +115,3 @@ def na_block(reason: str) -> dict:
         "collectedAt": utc_now(),
         "note": reason,
     }
-

package/runtime/python/okstra_token_usage/claude.py

@@ -4,12 +4,12 @@ from __future__ import annotations
 import json
 import sys
 import re
-from datetime import datetime
 from pathlib import Path
 
 from .cursor import MAX_NEEDLES, fresh_cache, load_cache, save_cache
 from .paths import claude_project_dir, ts_in_window
 from okstra_ctl.wrapper_status import read_wrapper_status
+from okstra_ctl.usage_cells import duration_ms_from_bounds
 
 # lead 의 단계 체크포인트 라인(prompts/lead/okstra-lead-contract.md "Progress reporting") — phase id 가
 # `phase-<digit>` 로 시작하는 라인만 마커로 인정해 일반 대화의 오탐을 줄인다.
@@ -45,19 +45,13 @@ def claude_code_status_total(status_path: Path) -> dict:
     }
 
 
-def _event_from_record(rec: dict) -> dict | None:
-    """jsonl 레코드 1개 → 압축 이벤트. 집계에 기여하지 않으면 None.
-
-    키: t=timestamp, i/o=input/output, c=cache_creation 합, c5/c1=ephemeral
-    5m/1h, r=cache_read, u=tool_use 수. 0/부재 필드는 생략(캐시 크기 절약).
-    ts-only 레코드도 보존한다 — 임의 윈도우의 first/last ts 산출에 필요.
-    """
-    msg = rec.get("message")
-    if not isinstance(msg, dict):
-        msg = {}
+def _usage_from_message(msg: dict) -> dict:
+    """응답 식별자를 남겨 여러 출력 조각의 사용량을 한 번만 집계한다."""
     ev: dict = {}
     usage = msg.get("usage")
-    if usage:
+    if isinstance(usage, dict):
+        if isinstance(msg.get("id"), str) and msg["id"]:
+            ev["m"] = msg["id"]
         for src, key in (("input_tokens", "i"), ("output_tokens", "o"),
                          ("cache_read_input_tokens", "r")):
             v = usage.get(src, 0) or 0
@@ -79,6 +73,15 @@ def _event_from_record(rec: dict) -> dict | None:
         elif cc_total:
             # API 분해가 없으면 전부 5m 티어로(1.25x — 더 싼 가정, 기존 동작).
             ev["c5"] = cc_total
+    return ev
+
+
+def _event_from_record(rec: dict) -> dict | None:
+    """사용량과 별개로 각 조각의 도구·진행·시각 이벤트를 보존한다."""
+    msg = rec.get("message")
+    if not isinstance(msg, dict):
+        msg = {}
+    ev = _usage_from_message(msg)
     if rec.get("type") == "assistant":
         tools = sum(1 for b in (msg.get("content") or [])
                     if isinstance(b, dict) and b.get("type") == "tool_use")
@@ -102,6 +105,31 @@ def _event_from_record(rec: dict) -> dict | None:
     return ev or None
 
 
+def _response_usage_events(events: list[dict], since: str | None, until: str | None):
+    """응답별 누적 스냅샷의 창 안 증가량만 세며 도구 이벤트는 그대로 둔다."""
+    latest: dict[str, int] = {}
+    baseline: dict[str, dict] = {}
+    for index, event in enumerate(events):
+        message_id = event.get("m")
+        timestamp = event.get("t")
+        if message_id and (not timestamp or ts_in_window(timestamp, None, until)):
+            latest[message_id] = index
+            if timestamp and since and not ts_in_window(timestamp, since, None):
+                baseline[message_id] = event
+    usage_keys = {"i", "o", "c", "c5", "c1", "r"}
+    for index, event in enumerate(events):
+        message_id = event.get("m")
+        if not message_id:
+            yield event
+            continue
+        projected = {key: value for key, value in event.items() if key not in usage_keys}
+        if latest.get(message_id) == index:
+            previous = baseline.get(message_id) or {}
+            projected.update({key: max(0, event.get(key, 0) - previous.get(key, 0))
+                              for key in usage_keys})
+        yield projected
+
+
 def _session_meta_from_record(rec: dict) -> tuple[str | None, str | None]:
     """레코드에서 (agentName, model) 후보 추출 — 둘 다 first-non-null 정책."""
     agent = rec.get("agentName") or None
@@ -213,7 +241,7 @@ def _totals_from_events(events: list[dict], agent_name: str | None,
     progress_markers: list[dict] = []
     first_ts: str | None = None
     last_ts: str | None = None
-    for ev in events:
+    for ev in _response_usage_events(events, since, until):
         ts = ev.get("t")
         if ts and not ts_in_window(ts, since, until):
             continue
@@ -231,14 +259,7 @@ def _totals_from_events(events: list[dict], agent_name: str | None,
                 first_ts = ts
             if last_ts is None or ts > last_ts:
                 last_ts = ts
-    duration_ms = 0
-    if first_ts and last_ts:
-        try:
-            a = datetime.fromisoformat(first_ts.replace("Z", "+00:00"))
-            b = datetime.fromisoformat(last_ts.replace("Z", "+00:00"))
-            duration_ms = max(0, int((b - a).total_seconds() * 1000))
-        except ValueError:
-            duration_ms = 0
+    duration_ms = duration_ms_from_bounds(first_ts, last_ts) or 0
     # '처리 토큰' total 에서 cache_read 는 제외한다. claude 는 매 턴 직전까지의
     # 컨텍스트 전체를 캐시에서 재읽기(cache_read)하므로, 단순 합산하면 같은 토큰을
     # 턴 수만큼 중복 카운트해 처리량이 비현실적으로 부풀려진다(예: in-session

package/runtime/python/okstra_token_usage/codex.py

@@ -3,6 +3,7 @@ from __future__ import annotations
 
 import json
 import os
+import re
 from datetime import datetime, timezone
 from pathlib import Path
 from .jsonl_io import iter_jsonl
@@ -12,6 +13,22 @@ from .paths import CODEX_SESSIONS, codex_session_roots, ts_in_window
 _DEFAULT_CODEX_SESSIONS = CODEX_SESSIONS
 
 
+def codex_wrapper_session_ids(log_path: Path) -> set[str]:
+    """사용자 프롬프트 앞 실행기 헤더에서만 세션 ID를 읽는다."""
+    try:
+        with log_path.open(encoding="utf-8", errors="replace") as stream:
+            for line in stream:
+                clean = re.sub(r"\x1b\[[0-9;]*m", "", line).strip()
+                if clean == "user" or clean.endswith("[worker]user"):
+                    break
+                match = re.search(r"(?:^|\[worker\])session id:\s*([\w-]+)\s*$", clean)
+                if match:
+                    return {match.group(1)}
+    except OSError:
+        return set()
+    return set()
+
+
 def codex_session_total(jsonl_path: Path) -> dict:
     """Return last token_count snapshot from a codex rollout jsonl."""
     last: dict | None = None