okstra 0.187.0 → 0.188.0

package/runtime/python/okstra_ctl/worker_runner.py

@@ -73,7 +73,7 @@ def run_worker(
 
     try:
         with guard:
-            exit_code, timed_out, idle_seconds, raw_model = _launch(
+            exit_code, timed_out, idle_seconds, raw_model, usage = _launch(
                 command,
                 log_path,
                 presentation=presentation,
@@ -94,6 +94,11 @@ def run_worker(
         raise
 
     status = _closed(status, started_monotonic)
+    if usage is not None:
+        # 스트림이 마지막으로 보고한 토큰 스냅샷, 공급자 어휘 그대로. 토큰
+        # 수집기(`okstra_token_usage`)가 홈 트랜스크립트가 없는 공급자의
+        # 사용량을 여기서 읽는다.
+        status["usage"] = dict(usage)
     if served_model_normalizer is not None:
         attestation = served_model_normalizer(raw_model)
         status["servedModelAttestation"] = _attestation_payload(attestation)
@@ -172,11 +177,14 @@ def _launch(
     presentation: str,
     idle_timeout_seconds: int,
     on_spawn: Callable[[subprocess.Popen[bytes]], None],
-) -> tuple[int, bool, int, str | None]:
+) -> tuple[int, bool, int, str | None, Mapping[str, Any] | None]:
     live = presentation == LIVE
     transcript = SessionTranscript(log_path, live=live)
     observation = _ServedModelObservation()
-    strategy = _with_served_model_observation(command.presentation, observation)
+    usage_observation = _UsageObservation()
+    strategy = _with_stream_observations(
+        command.presentation, observation, usage_observation
+    )
     try:
         # The strategy decided where this provider runs — some CLIs work in the
         # stage tree, others in the project root and reach the tree by flag.
@@ -205,27 +213,38 @@ def _launch(
             idle_timeout_seconds=idle_timeout_seconds,
             stdin_text=command.stdin_text,
         )
-        return exit_code, timed_out, idle_seconds, observation.raw_model
+        return (
+            exit_code,
+            timed_out,
+            idle_seconds,
+            observation.raw_model,
+            usage_observation.usage,
+        )
     finally:
         transcript.close()
 
 
-def _with_served_model_observation(
+def _with_stream_observations(
     presentation: Presentation,
     observation: _ServedModelObservation,
+    usage_observation: _UsageObservation,
 ) -> Presentation:
-    """JSON 경로의 서빙 모델 관측을 러너가 모아 둔다.
+    """JSON 경로의 서빙 모델·토큰 사용량 관측을 러너가 모아 둔다.
 
-    해석 전략은 이벤트를 보고 모델 문자열만 돌려준다. 그 값을 사이드카에
-    적는 일은 러너의 것이라, 여기서 한 번 감싼다.
+    해석 전략은 이벤트를 보고 모델 문자열과 사용량 스냅샷만 돌려준다. 그 값을
+    사이드카에 적는 일은 러너의 것이라, 여기서 한 번 감싼다. 사용량은 어댑터가
+    읽는 법을 넘긴 어휘에서만 관측된다.
     """
     if not isinstance(presentation, JsonEvents):
         return presentation
     original = presentation.observe
+    original_usage = presentation.observe_usage
 
     def observe(event: Mapping[str, Any]) -> str | None:
         observed = original(event)
         observation.record(observed)
+        if original_usage is not None:
+            usage_observation.record(original_usage(event))
         return observed
 
     # 필드를 손으로 옮기지 않는다 — 그렇게 하던 동안 어댑터가 선언한
@@ -242,6 +261,21 @@ class _ServedModelObservation:
             self.raw_model = raw_model
 
 
+class _UsageObservation:
+    """스트림이 보고한 마지막 사용량 스냅샷.
+
+    첫 값이 아니라 마지막 값이다 — 단계별 스냅샷을 내는 CLI 도 종결 이벤트에
+    합계를 싣고, 그 이벤트가 스트림의 끝에 온다.
+    """
+
+    def __init__(self) -> None:
+        self.usage: Mapping[str, Any] | None = None
+
+    def record(self, usage: Mapping[str, Any] | None) -> None:
+        if isinstance(usage, Mapping) and usage:
+            self.usage = usage
+
+
 class _AbnormalExit:
     """Close the status sidecar for the exits that raise nothing at all.
 

package/runtime/python/okstra_token_usage/antigravity.py

@@ -1,18 +1,64 @@
 """Antigravity (`agy`) CLI usage collector.
 
 공식 headless 문서는 ``--output-format json`` / ``stream-json`` 의 최종
-``usage`` 객체에 토큰을 둔다. okstra 는 이미 ``stream-json`` 으로 호출하고
-그 줄을 워커 로그에 남긴다. 정본은 마지막 ``result.usage`` 이다.
+``usage`` 객체에 토큰을 둔다. okstra 는 ``stream-json`` 으로 호출하고, 러너가
+스트림의 마지막 ``usage`` 스냅샷을 래퍼 status 사이드카의 ``usage`` 에 적는다
+(`worker_runner`) — 그것이 정본이다. 워커 로그는 러너가 사람이 읽는 줄로 옮겨
+적은 것이라 stream-json 이 아니다. raw stream-json 로그를 읽는 경로는 러너
+이전의 로그를 위해 남긴다.
 """
 from __future__ import annotations
 
+import json
 from pathlib import Path
+from typing import Any, Mapping
 
 from .jsonl_io import iter_jsonl
 
 
+def _usage_total(usage: Mapping[str, Any], model: str | None) -> dict:
+    return {
+        "totalTokens": usage.get("total_tokens", 0) or 0,
+        "inputTokens": usage.get("input_tokens", 0) or 0,
+        "outputTokens": usage.get("output_tokens", 0) or 0,
+        "thoughtsTokens": usage.get("thinking_tokens", 0) or 0,
+        "cacheReadTokens": usage.get("cache_read_tokens", 0) or 0,
+        "model": model,
+        "available": True,
+    }
+
+
+def _read_status(status_path: Path) -> dict | None:
+    try:
+        data = json.loads(status_path.read_text(encoding="utf-8"))
+    except (OSError, ValueError):
+        return None
+    return data if isinstance(data, dict) else None
+
+
+def status_carries_usage(path: Path) -> bool:
+    """이 경로가 ``usage`` 스냅샷을 실은 래퍼 status 사이드카인가."""
+    if not path.name.endswith(".status.json"):
+        return False
+    status = _read_status(path)
+    return isinstance((status or {}).get("usage"), dict) and bool(status["usage"])
+
+
+def antigravity_status_total(status_path: Path) -> dict:
+    """래퍼 status 사이드카의 ``usage`` 스냅샷. 모델은 served-model 관측값이다."""
+    status = _read_status(status_path) or {}
+    usage = status.get("usage")
+    if not isinstance(usage, dict) or not usage:
+        return {"totalTokens": 0, "available": False}
+    attestation = status.get("servedModelAttestation")
+    model = (
+        attestation.get("observedModel") if isinstance(attestation, dict) else None
+    )
+    return _usage_total(usage, model if isinstance(model, str) and model else None)
+
+
 def antigravity_session_total(json_path: Path) -> dict:
-    """stream-json 로그에서 마지막 result.usage 를 읽는다."""
+    """raw stream-json 로그에서 마지막 result.usage 를 읽는다."""
     result_usage: dict | None = None
     step_usage: dict | None = None
     model: str | None = None
@@ -35,15 +81,7 @@ def antigravity_session_total(json_path: Path) -> dict:
     usage = result_usage or step_usage
     if usage is None:
         return {"totalTokens": 0, "available": False}
-    return {
-        "totalTokens": usage.get("total_tokens", 0) or 0,
-        "inputTokens": usage.get("input_tokens", 0) or 0,
-        "outputTokens": usage.get("output_tokens", 0) or 0,
-        "thoughtsTokens": usage.get("thinking_tokens", 0) or 0,
-        "cacheReadTokens": usage.get("cache_read_tokens", 0) or 0,
-        "model": model,
-        "available": True,
-    }
+    return _usage_total(usage, model)
 
 
 def find_antigravity_session(project_root: Path, started_at: str, ended_at: str) -> Path | None:

package/runtime/python/okstra_token_usage/collect.py

@@ -21,7 +21,12 @@ from .codex import (
     codex_session_total,
     find_codex_sessions,
 )
-from .antigravity import antigravity_session_total, find_antigravity_sessions
+from .antigravity import (
+    antigravity_session_total,
+    antigravity_status_total,
+    find_antigravity_sessions,
+    status_carries_usage,
+)
 from .grok import (
     find_grok_sessions,
     grok_session_is_non_interactive,
@@ -179,11 +184,50 @@ def _created_at_by_suffix(run_dir: Path, suffix: str) -> str | None:
     return None if data is None else data.get("createdAt")
 
 
-def _run_manifest_created_at(
-    run_dir: Path, suffix: str, team_state_path: Path
+def relaxation_floor(run_dir: Path, suffix: str, manifest: dict | None) -> str | None:
+    """since 완화가 내려갈 수 있는 하한.
+
+    in-session 리드(`entryMode: current-session`)의 세션은 run 을 위해 태어난 것이
+    아니다 — 한 세션이 여러 날에 걸쳐 여러 task 의 run 을 돌린다(관측 2026-09-02,
+    dev-10626 error-analysis r04: 세션 첫 ts 08-17T08:00Z, run createdAt
+    09-02T20:03Z, 리드 소요 398h / $292 로 보고). 그 세션의 첫 ts 는 이 run 의
+    시작에 대해 아무것도 말하지 않으므로 하한은 매니페스트 createdAt 자체다 —
+    완화가 일어나지 않는다. 프로세스를 새로 띄운 리드는 세션이 prep 직전에
+    태어나므로 종전대로 직전 run 의 종료가 하한이다(`_previous_run_end`).
+    """
+    if manifest is not None and manifest.get("entryMode") == "current-session":
+        created = manifest.get("createdAt")
+        if created:
+            return str(created)
+    return _previous_run_end(run_dir, suffix)
+
+
+def window_start_is_pinned(since: str | None, floor: str | None) -> bool:
+    """하한이 시작점 이상이면 완화할 여지가 없다 — 세션 jsonl 을 훑을 이유도 없다."""
+    return bool(since and floor and floor >= since)
+
+
+def relax_window_start(
+    since: str | None, earliest: str | None, floor: str | None
 ) -> str | None:
-    data = _run_manifest_for_team_state(run_dir, suffix, team_state_path)
-    return None if data is None else data.get("createdAt")
+    """`earliest` 가 `since` 보다 앞서면 하한 안에서 시작점을 앞당긴다."""
+    if not earliest:
+        return since
+    if floor and earliest < floor:
+        earliest = floor
+    if since is None or earliest < since:
+        return earliest
+    return since
+
+
+def run_window_relaxation_floor(team_state_path: Path) -> str | None:
+    """collect 의 found-sessions 완화가 쓰는 하한 — `resolve_run_window` 와 같은 규칙."""
+    suffix = run_artifact_suffix(team_state_path)
+    if not suffix:
+        return None
+    run_dir = team_state_path.parent.parent
+    manifest = _run_manifest_for_team_state(run_dir, suffix, team_state_path)
+    return relaxation_floor(run_dir, suffix, manifest)
 
 
 def _run_end_estimate(run_dir: Path, suffix: str) -> str | None:
@@ -319,7 +363,10 @@ def resolve_run_window(
     since 를 앞당긴다. `leadSessionIds` 부재(legacy)면 createdAt 그대로 — 기존
     동작 불변. 완화 하한: 직전 run 의 종료 시각 이전으로는 내려가지 않는다
     (`_previous_run_end`). 세션 jsonl 은 run 마다 새로 생기지 않으므로 하한이
-    없으면 같은 세션의 이전 run 이 이 윈도우에 통째로 들어온다.
+    없으면 같은 세션의 이전 run 이 이 윈도우에 통째로 들어온다. in-session
+    리드(`entryMode: current-session`)는 완화하지 않는다 — 그 세션은 run 보다
+    먼저 태어났고 다른 task 의 run 도 돌렸으므로 첫 ts 는 세션 탄생일이다
+    (`relaxation_floor`).
 
     `relax_start=False` (세션 스코프 검증기 전용 — session-conformance /
     forbidden-actions): 완화를 건너뛰고 since 를 createdAt 에 고정한다. createdAt
@@ -332,14 +379,13 @@ def resolve_run_window(
     if not suffix:
         return None, None
     run_dir = team_state_path.parent.parent
-    since = _run_manifest_created_at(run_dir, suffix, team_state_path)
+    manifest = _run_manifest_for_team_state(run_dir, suffix, team_state_path)
+    since = None if manifest is None else manifest.get("createdAt")
     if relax_start:
-        earliest = _earliest_lead_session_ts(state, team_state_path)
-        if earliest and (since is None or earliest < since):
-            since = earliest
-        floor = _previous_run_end(run_dir, suffix)
-        if floor and since and since < floor:
-            since = floor
+        floor = relaxation_floor(run_dir, suffix, manifest)
+        if not window_start_is_pinned(since, floor):
+            earliest = _earliest_lead_session_ts(state, team_state_path)
+            since = relax_window_start(since, earliest, floor)
     until = state.get("runEndedAt") or _run_end_estimate(run_dir, suffix) or utc_now()
     return since, until
 
@@ -516,10 +562,18 @@ def _codex_worker_windows(project_root: Path, state: dict) -> dict[str, list[tup
     return windows
 
 
+# Claude 의 트랜스크립트는 세션 jsonl 이고, 그것은 이 모듈의 Claude 경로가
+# 읽는다. 별도의 CLI 트랜스크립트가 없으므로 CLI 경로에 태우면 매번
+# `no transcript was found` 가 붙는다 — 세션을 찾아 토큰을 붙인 행에도.
+_SESSION_JSONL_PROVIDERS = frozenset({"claude"})
+
+
 def _cli_assignment_provider(worker: dict) -> str:
     worker_id = str(worker.get("workerId") or "").strip()
     explicit_provider = str(worker.get("provider") or "").strip()
     provider = explicit_provider or str(worker.get("agent") or "").strip()
+    if provider in _SESSION_JSONL_PROVIDERS:
+        return ""
     runner = str(worker.get("runner") or "").strip()
     if runner and runner != "cli-wrapper":
         return ""
@@ -557,7 +611,11 @@ def _cli_session_totals(provider: str, session_paths: list[Path]) -> list[dict]:
         if provider == "codex":
             total = codex_session_total(session_path)
         elif provider == "antigravity":
-            total = antigravity_session_total(session_path)
+            total = (
+                antigravity_status_total(session_path)
+                if status_carries_usage(session_path)
+                else antigravity_session_total(session_path)
+            )
         elif provider == "grok":
             total = grok_session_total(session_path)
         else:
@@ -703,12 +761,23 @@ def _worker_cli_windows(
     return fallback_windows, status_path, True
 
 
-def _antigravity_log_paths(
+def _antigravity_usage_sources(
     project_root: Path,
     worker: dict,
     status_path: Path | None,
 ) -> list[Path]:
-    """agy stream-json 은 워커 로그에 남는다. 홈 세션 디렉터리가 아니다."""
+    """agy 의 토큰 스냅샷이 있는 곳. 홈 세션 디렉터리가 아니다.
+
+    정본은 래퍼 status 사이드카의 `usage` 다 — 러너가 스트림의 마지막
+    `result.usage` 를 종료 시점에 적는다(`worker_runner`). 워커 로그는 러너가
+    사람이 읽는 줄로 옮겨 적은 것이라 stream-json 이 아니고, 그 로그에서
+    usage 를 찾던 동안 antigravity 워커 전부가 `transcript found but no final
+    token snapshot was recorded` 였다(관측 2026-09-02, dev-10626 r01·r02·r04).
+    로그를 읽는 경로는 러너 이전의 raw stream-json 로그를 위해 남긴다 — 스냅샷이
+    있는 run 의 로그는 옮겨 적은 텍스트라 트랜스크립트로 나열하지 않는다.
+    """
+    if status_path is not None and status_carries_usage(status_path):
+        return [status_path]
     paths: list[Path] = []
     prompt_path = _resolve_project_path(project_root, str(worker.get("promptPath") or ""))
     if prompt_path is not None:
@@ -737,9 +806,9 @@ def _worker_cli_usage_block(
     )
     session_paths = _cli_sessions_for_windows(provider, project_root, windows)
     if provider == "antigravity":
-        for log_path in _antigravity_log_paths(project_root, worker, status_path):
-            if log_path not in session_paths:
-                session_paths.append(log_path)
+        for source in _antigravity_usage_sources(project_root, worker, status_path):
+            if source not in session_paths:
+                session_paths.append(source)
     return collect_cli_usage(
         provider=provider,
         status_path=status_path,
@@ -762,8 +831,8 @@ def _attach_cli_usage(
     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 는 워커 로그의 stream-json
-    ``result.usage`` 를 같은 합산 경로에 붙인다.
+    CLI spend is fully reported. antigravity 는 status 사이드카의 ``usage``
+    스냅샷을 같은 합산 경로에 붙인다.
     """
     session_paths = _cli_sessions_for_windows(provider, project_root, windows)
     cli = collect_cli_usage(
@@ -794,7 +863,8 @@ def _collect_cli_runtime_usage(
         provider = _cli_assignment_provider(worker)
         if not provider:
             worker["usage"] = na_block(
-                "worker is host-native or has no registered CLI provider: "
+                "worker usage is not read from a provider CLI transcript "
+                "(host-native, session-jsonl provider, or no registered CLI provider): "
                 f"{worker.get('provider') or worker.get('agent') or worker.get('workerId')}"
             )
             continue
@@ -1024,16 +1094,20 @@ def collect_claude_runtime_usage(
     claude_sessions = find_claude_team_sessions(cwd, team_needles, lead_sid,
                                                 incremental=incremental)
     # Task 9: 축1 기록(observed-team-names)으로 발견한 세션들의 min first-ts 로
-    # run_since 를 완화한다. session-* needle 은 세션 고유라 발견 세션은 이 run
-    # 것이므로 안전. 불확실한 reconstruct/none source 는 완화하지 않는다(오귀속 방지).
+    # run_since 를 완화한다. 불확실한 reconstruct/none source 는 완화하지
+    # 않는다(오귀속 방지). 하한은 `resolve_run_window` 와 같다 — 발견 세션에는
+    # 리드 세션 자신이 들어 있고, in-session 리드의 세션 첫 ts 는 run 이 아니라
+    # 세션의 탄생일이다(관측: 16일 전). 하한 없이 두던 동안 리드 소요 시간과
+    # 비용이 세션 수명 전체로 보고됐다.
     if needle_source == "observed-team-names":
-        found_earliest = None
-        for path in claude_sessions.values():
-            ts = _session_first_ts(path)
-            if ts and (found_earliest is None or ts < found_earliest):
-                found_earliest = ts
-        if found_earliest and (run_since is None or found_earliest < run_since):
-            run_since = found_earliest
+        floor = run_window_relaxation_floor(team_state_path)
+        if not window_start_is_pinned(run_since, floor):
+            found_earliest = None
+            for path in claude_sessions.values():
+                ts = _session_first_ts(path)
+                if ts and (found_earliest is None or ts < found_earliest):
+                    found_earliest = ts
+            run_since = relax_window_start(run_since, found_earliest, floor)
     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

package/runtime/python/okstra_token_usage/pricing.py

@@ -4,7 +4,7 @@ Pricing is matched by substring against the model id recorded in the session
 transcript, so keys must reflect the *actual* model id form emitted by each
 provider:
 
-  * Anthropic — `claude-fable-5*`, `claude-opus-5*`, `claude-opus-4-*`, `claude-sonnet-5*`, `claude-sonnet-4-*`,
+  * Anthropic — `claude-fable-5-1*`, `claude-fable-5*`, `claude-opus-5*`, `claude-opus-4-*`, `claude-sonnet-5*`, `claude-sonnet-4-*`,
     `claude-haiku-4-5-*`, `claude-3-5-sonnet-*`, `claude-3-5-haiku-*`,
     `claude-3-opus-*`, `claude-3-haiku-*`.
   * OpenAI / Codex — `gpt-5*`, `gpt-4o*`, `gpt-4*`.
@@ -15,8 +15,8 @@ Matching prefers the longest key that is a substring of the model id (most
 specific wins), so table ordering does not affect the result. Update when
 providers change list pricing.
 
-Sources (last verified 2026-08-03 — Google table re-verified 2026-08-26,
-public list prices, USD per 1M tokens):
+Sources (last verified 2026-08-03 — Anthropic Fable 5.1 re-verified 2026-09-02,
+Google table re-verified 2026-08-26, public list prices, USD per 1M tokens):
   * Anthropic: https://www.anthropic.com/pricing
   * OpenAI:    https://openai.com/api/pricing
   * Google:    https://ai.google.dev/gemini-api/docs/pricing
@@ -50,6 +50,9 @@ CLAUDE_PRICING = {
     "3-sonnet":   (3.0, 3.75, 0.30, 15.0),     # legacy 3 Sonnet
     "3-haiku":    (0.25, 0.30, 0.03, 1.25),    # Haiku 3
 
+    # Claude Fable 5.1 — input/output match Fable 5; cache_read is 75% lower
+    # ($0.25, not the 0.1x ratio). Longest-key match so this beats "fable-5".
+    "fable-5-1":  (10.0, 12.5, 0.25, 50.0),    # Fable 5.1 (Anthropic 2026-09-01)
     # Claude Fable 5 (tier above Opus).
     "fable-5":    (10.0, 12.5, 1.0, 50.0),     # Fable 5 (cache prices derived from ratios)
 

package/runtime/templates/report-writer-prompt-preamble.md

@@ -36,6 +36,8 @@ These are the only names allowed at the top level:
 
 `Analysis Common`, `Change Impact Analysis`, `End State Coverage`, `Error Analysis`, `Feature Analysis`, `Final Verdict`, `Final Verification`, `Follow Up Tasks`, `Human Summary`, `Implementation`, `Implementation Option Selection`, `Implementation Planning`, `Improvement Discovery`, `Project Analysis`, `Rationale`, `Recommended Next Steps`, `Release Handoff`, `Requirements Discovery`, `Summary`, `Ticket Coverage`, `Verdict Card`
 
+The synthesis packet's Authoring Contract names which of these are **required** for this run and the exact `Verdict Token` value; those lines are read from the frozen report schema, so follow them over memory. `Verdict Token` under `Final Verdict` is pinned by task type: `not-applicable` for `requirements-discovery`, `error-analysis`, `implementation-option-selection`, `implementation-planning`, `implementation`, `release-handoff` and `quick`; one of `accepted`, `conditional-accept`, `blocked` for `final-verification`; one of `analysis-complete`, `analysis-partial`, `blocked` for `project-analysis`, `feature-analysis` and `change-impact-analysis`. `Human Summary`, `Verdict Card`, `Rationale`, `Summary`, `Final Verdict`, `Recommended Next Steps` and `Follow Up Tasks` are required at the top level of every narrative.
+
 Any other top-level name is rejected however reasonable it reads — a section title copied out of a lead procedure document (`Clarification Response Carried In`, `Stage Map`, `Rollback Strategy`) is a heading in that document, not a top-level field here. Nested names come from the task's block in `schemas/final-report-v3.0.schema.json`; when a name is refused, the parser's message lists the names allowed at that exact position, so correct against that list rather than guessing a second time.
 
 ## Pointer record

package/runtime/validators/validate-run.py

@@ -8105,11 +8105,16 @@ def _run_scoped_glob(pattern: str, suffix: str | None) -> str:
     접미사는 확장자 앞에 `*<suffix>` 로 끼운다 — `convergence-*.json` 은
     `convergence-work-<suffix>.json` 같은 중간 산출물까지 종전처럼 포함하고,
     `*-reverify-r*.md` 는 라운드 라벨(`r1`·`r1b`)을 그대로 흡수한다.
+
+    호출부 패턴은 전부 `*` 로 끝나는 stem 이라 그냥 이어 붙이면 `**` 가 된다.
+    Python 3.13+ 는 그것을 `*` 와 같게 읽지만 3.11(CI 기준 버전)은
+    `ValueError: '**' can only be an entire path component` 로 죽는다. 두 버전이
+    같은 결과를 내므로 stem 끝의 `*` 를 흡수해 하나로 만든다.
     """
     if not suffix:
         return pattern
     stem, _dot, ext = pattern.rpartition(".")
-    return f"{stem}*{suffix}.{ext}"
+    return f"{stem.rstrip('*')}*{suffix}.{ext}"
 
 
 def _convergence_states(run_dir, suffix=None):