okstra 0.186.7 → 0.188.0

package/runtime/python/okstra_token_usage/collect.py

@@ -2,6 +2,7 @@
 from __future__ import annotations
 
 import json
+import sys
 import os
 from datetime import datetime, timezone
 from pathlib import Path
@@ -20,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,
@@ -113,22 +119,115 @@ def _aggregate_totals(items: list[dict]) -> dict:
 def run_artifact_suffix(team_state_path: Path) -> str | None:
     """``team-state-<task-type>-<seq>.json`` → ``<task-type>-<seq>``.
 
-    이 접미사로 *같은 run* 의 run-manifest / status 를 정확히 짚는다. task 디렉토리
-    한 곳에 여러 run(재시도·이전 phase·레거시 타임스탬프)의 산출물이 섞여 있어,
-    glob 으로 아무거나 집으면 엉뚱한 run 의 시각을 쓰게 된다(관측: 가장 오래된
-    레거시 manifest 의 createdAt 을 집어 윈도우가 한 달로 벌어짐)."""
+    task 디렉토리 한 곳에 여러 run(재시도·이전 phase·레거시 타임스탬프)의 산출물이
+    섞여 있어, glob 으로 아무거나 집으면 엉뚱한 run 의 시각을 쓰게 된다(관측: 가장
+    오래된 레거시 manifest 의 createdAt 을 집어 윈도우가 한 달로 벌어짐).
+
+    **접미사가 곧 매니페스트 이름은 아니다.** okstra 는 카테고리별로 seq 를 따로
+    매기므로 한 run 이 `manifests: 025` 와 `state: 023` 을 동시에 가질 수 있다.
+    run-manifest 는 `_run_manifest_for_team_state` 가 매니페스트의 `teamStatePath`
+    역참조로 짚는다. status 산출물은 team-state 와 같은 카테고리라 이 접미사로
+    계속 짚는다."""
     name = team_state_path.name
     if not (name.startswith("team-state-") and name.endswith(".json")):
         return None
     return name[len("team-state-"):-len(".json")]
 
 
-def _run_manifest_created_at(run_dir: Path, suffix: str) -> str | None:
-    p = run_dir / "manifests" / f"run-manifest-{suffix}.json"
+def _read_json_or_none(path: Path) -> dict | None:
     try:
-        return json.loads(p.read_text()).get("createdAt")
+        data = json.loads(path.read_text())
     except (OSError, json.JSONDecodeError):
         return None
+    return data if isinstance(data, dict) else None
+
+
+def _run_manifest_for_team_state(
+    run_dir: Path, suffix: str, team_state_path: Path
+) -> dict | None:
+    """이 team-state 가 속한 run 의 매니페스트.
+
+    접미사가 곧 매니페스트 이름이라는 전제는 카테고리별 seq 가 갈리는 순간
+    깨진다. 실측(2026-08-27, fontsninja-nlpvibe `nestjs-migration-…`): 한 run 의
+    `manifests` 가 025, `state`·`prompts`·`worker-results` 가 023, `reports` 가
+    017 이었다. team-state 이름에서 뽑은 `023` 으로 매니페스트를 집으면 **12시간
+    전 run** 의 `createdAt`(04:45:34Z) 이 창의 시작이 되고, 그 사이 같은 세션이
+    돈 이전 run 들이 통째로 창에 들어온다 — `relax_start=False` 가 막으려던 바로
+    그 오탐이다(그 run 에서 로스터에 없는 워커 5명이 이 run 의 위반으로 보고됐다).
+
+    매니페스트는 자기 team-state 를 `teamStatePath` 에 적으므로 그것으로 맞춘다.
+    맞는 것이 없으면 접미사 방식으로 돌아간다 — 그 필드가 없던 옛 매니페스트다.
+    """
+    direct = run_dir / "manifests" / f"run-manifest-{suffix}.json"
+    # `Path.glob` 는 디렉터리가 없어도 빈 결과를 낸다 — 감쌀 예외가 없다.
+    candidates = [
+        direct,
+        *sorted((run_dir / "manifests").glob("run-manifest-*.json")),
+    ]
+    for path in candidates:
+        data = _read_json_or_none(path)
+        if data is None:
+            continue
+        recorded = str(data.get("teamStatePath") or "")
+        if recorded and Path(recorded).name == team_state_path.name:
+            return data
+    return _read_json_or_none(direct)
+
+
+def _created_at_by_suffix(run_dir: Path, suffix: str) -> str | None:
+    """접미사가 곧 매니페스트 이름인 조회.
+
+    **다른** run 을 접미사로 지목할 때만 쓴다(`_previous_run_end`). 이번 run 은
+    team-state 로 맞춰야 한다 — 두 접미사가 갈리는 run 이 실재한다.
+    """
+    data = _read_json_or_none(run_dir / "manifests" / f"run-manifest-{suffix}.json")
+    return None if data is None else data.get("createdAt")
+
+
+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:
+    """`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:
@@ -233,9 +332,15 @@ def _previous_run_end(run_dir: Path, suffix: str) -> str | None:
         ended_at = prev_state.get("runEndedAt")
         if ended_at:
             return str(ended_at)
-    except (OSError, json.JSONDecodeError):
+    except OSError:
+        # expected-miss: 직전 run 이 team-state 를 남기지 않고 끝났으면 파일이
+        # 없다. 아래 두 추정 경로가 바로 그 경우를 위한 폴백이다.
         pass
-    return _run_end_estimate(run_dir, prev) or _run_manifest_created_at(run_dir, prev)
+    except json.JSONDecodeError as exc:
+        # 파일은 있는데 깨진 것은 폴백이 상정한 상황이 아니다.
+        print(f"token-usage: team-state for the previous run ({prev}) is not "
+              f"valid JSON, estimating instead ({exc})", file=sys.stderr)
+    return _run_end_estimate(run_dir, prev) or _created_at_by_suffix(run_dir, prev)
 
 
 def resolve_run_window(
@@ -258,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
@@ -271,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)
+    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
 
@@ -455,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 ""
@@ -496,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:
@@ -642,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:
@@ -676,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,
@@ -701,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(
@@ -733,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
@@ -963,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/cursor.py

@@ -92,4 +92,6 @@ def save_cache(jsonl_path: Path, cache: dict) -> None:
         tmp.write_text(json.dumps(cache, ensure_ascii=False, separators=(",", ":")))
         os.replace(tmp, p)
     except OSError:
+        # expected-miss: 이 캐시는 jsonl 에서 언제든 다시 만들 수 있는 파생물이다.
+        # 저장에 실패해도 집계 결과가 달라지지 않으므로 없는 것이 정상 분기다.
         pass

package/runtime/python/okstra_token_usage/grok.py

@@ -11,7 +11,7 @@ import os
 from datetime import datetime, timezone
 from pathlib import Path
 from typing import Mapping
-from urllib.parse import quote, unquote
+from urllib.parse import unquote
 
 from .jsonl_io import iter_jsonl
 from .paths import ts_in_window
@@ -132,10 +132,6 @@ def find_grok_sessions(
     return sorted(matches)
 
 
-def grok_session_dir_name(cwd: Path) -> str:
-    return quote(str(cwd), safe="")
-
-
 def grok_session_is_non_interactive(updates_path: Path) -> bool:
     """워커 래퍼 세션은 prompt_context.is_non_interactive 가 true 이다."""
     context_path = updates_path.parent / "prompt_context.json"

package/runtime/python/okstra_token_usage/paths.py

@@ -72,3 +72,29 @@ def claude_project_dir(cwd: Path, projects_root: Path | None = None) -> Path:
     # `projects_root` 는 테스트/진단용 주입 시드 — 기본은 실제 ~/.claude/projects.
     encoded = "-" + str(cwd).strip("/").replace("/", "-")
     return (projects_root or CLAUDE_PROJECTS) / encoded
+
+
+def find_session_jsonl(
+    session_id: str, cwd: Path, projects_root: Path | None = None
+) -> Path | None:
+    """세션 id 하나의 transcript 경로. 못 찾으면 None.
+
+    프로젝트로 인코딩된 디렉터리를 먼저 보고, 없으면 projects_root 아래의
+    모든 인코딩 디렉터리를 훑는다. 리드 세션의 cwd 가 대상 프로젝트 루트와
+    다를 수 있기 때문이다 — `okstra preflight --cwd <다른 프로젝트>` 는
+    지원되는 실행 방식이고, 그때 transcript 는 **리드 세션의 cwd** 로 인코딩된
+    디렉터리에 놓인다. 프로젝트 디렉터리만 보면 실재하는 세션을 없다고 답한다.
+
+    세션 id 는 전역 유일하므로 디렉터리를 넓혀도 다른 세션을 잘못 집지 않는다.
+    파일 내용을 읽지 않는 경로 조회다.
+    """
+    if not session_id:
+        return None
+    direct = claude_project_dir(cwd, projects_root) / f"{session_id}.jsonl"
+    if direct.is_file():
+        return direct
+    root = projects_root or CLAUDE_PROJECTS
+    try:
+        return next(iter(sorted(root.glob(f"*/{session_id}.jsonl"))), None)
+    except OSError:
+        return None

package/runtime/python/okstra_token_usage/pricing.py

@@ -4,18 +4,19 @@ 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*`.
-  * Google / Gemini — `gemini-3.6-flash*`, `gemini-3.5-flash*`, `gemini-3.1-pro*`, `gemini-3-flash*`,
+  * Google / Gemini — `gemini-3.7-flash*`, `gemini-3.6-flash*`, `gemini-3.5-flash*`, `gemini-3.1-pro*`, `gemini-3-flash*`,
     `gemini-2.5-pro*`, `gemini-2.5-flash*`, `gemini-2.0-flash*`.
 
 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, 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
@@ -49,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)
 
@@ -74,9 +78,10 @@ CLAUDE_PRICING = {
 # Anthropic 1h ephemeral cache_creation multiplier on the base input rate.
 CLAUDE_CACHE_CREATE_1H_MULT = 2.0
 
-# Legacy / non-selectable codex prices. Selectable-model prices (the aliases the
-# picker offers) live in the model catalog and are merged in below via
-# `catalog_pricing("codex")`. Substring match order is now longest-key-first
+# Codex prices for slugs the provider catalog no longer offers. Prices for
+# registered models -- selectable or hidden -- live in the model catalog and are
+# merged in below via `catalog_pricing("codex")`. Substring match order is
+# longest-key-first
 # (see `_match_pricing`), so this dict's ordering no longer affects matching.
 # For models with no published cached-input rate (o1-pro, o3-pro), cached is set
 # equal to input as a conservative no-discount default.
@@ -84,6 +89,10 @@ _LEGACY_CODEX_PRICING = {
     # model substring -> (input USD/1M, cached_input USD/1M, output USD/1M).
 
     # GPT-5 series.
+    # gpt-5.6 was dropped from the provider catalog; its rate stays so past runs
+    # keep pricing. Substring matching means sol / terra / luna resolve here too
+    # -- the 5.6 family rate, not a per-variant price we have a source for.
+    "gpt-5.6":      (5.00,  0.50,  30.0),
     "gpt-5.2-pro":  (21.0,  2.10,  168.0),
     "gpt-5.1":      (1.25,  0.125, 10.0),
     "gpt-5-mini":   (0.25,  0.025, 2.00),
@@ -126,8 +135,14 @@ GEMINI_PRICING = {
     # forms appear in the wild, so include both for the new 3.x families.
 
     # Gemini 3 series.
-    "3.6-flash":       (1.50, 7.50),
-    "3-6-flash":       (1.50, 7.50),
+    # 3.7 Flash 와 3.6 Flash 는 2026-12-31 까지 도입 요율 $0.75/$3.75 이고
+    # 2027-01-01 에 표준 요율 $1.50/$7.50 으로 오른다(2026-08-26 확인). 이 표에는
+    # 시점 개념이 없으므로 지금 청구되는 값을 담는다 — 그날 이후 두 계열을
+    # (1.50, 7.50) 으로 갱신해야 한다.
+    "3.7-flash":       (0.75, 3.75),
+    "3-7-flash":       (0.75, 3.75),
+    "3.6-flash":       (0.75, 3.75),
+    "3-6-flash":       (0.75, 3.75),
     "3.5-flash":       (1.50, 9.00),
     "3-5-flash":       (1.50, 9.00),
     "3.1-pro":         (2.00, 12.0),

package/runtime/schemas/convergence-critic-results-v1.0.schema.json

@@ -31,6 +31,11 @@
           "items": { "type": "string", "pattern": "\\S" }
         },
         "originEvidence": { "type": "string", "pattern": "\\S" },
+        "duplicateOf": {
+          "type": "string",
+          "pattern": "\\S",
+          "description": "The existing finding id (`F-NNN`) this candidate overlaps. A declared duplicate is recorded and skips gap verification entirely; restating the finding instead costs one verification round to reject it. The shape stays free-form because `findingId` is free-form in convergence-groups-v2.0; `okstra convergence apply-critic-gaps` owns the check that the id names a finding the state actually carries."
+        },
         "severity": { "enum": ["critical", "major", "minor"] },
         "evidenceArtifacts": {
           "type": "array",

package/runtime/schemas/execution-manifest-v2.schema.json

@@ -236,10 +236,7 @@
         "dutyId",
         "dispatchKind",
         "round",
-        "inputDigest",
-        "writePolicy",
-        "writePolicyDigest",
-        "writeEnforcement"
+        "inputDigest"
       ],
       "properties": {
         "invocationRef": {"type": "string", "pattern": "\\S"},
@@ -250,10 +247,7 @@
         "dutyId": {"type": "string", "pattern": "\\S"},
         "dispatchKind": {"type": "string", "pattern": "\\S"},
         "round": {"type": "integer", "minimum": 1},
-        "inputDigest": {"$ref": "#/$defs/Digest"},
-        "writePolicy": {"$ref": "#/$defs/WritePolicy"},
-        "writePolicyDigest": {"$ref": "#/$defs/Digest"},
-        "writeEnforcement": {"$ref": "#/$defs/WriteEnforcement"}
+        "inputDigest": {"$ref": "#/$defs/Digest"}
       },
       "additionalProperties": false
     },
@@ -268,7 +262,10 @@
         "resultPath",
         "errorPath",
         "changeSummary",
-        "evidenceSealRef"
+        "evidenceSealRef",
+        "writePolicy",
+        "writePolicyDigest",
+        "writeEnforcement"
       ],
       "properties": {
         "invocationRef": {"type": "string", "pattern": "\\S"},
@@ -279,7 +276,10 @@
         "resultPath": {"type": ["string", "null"]},
         "errorPath": {"type": ["string", "null"]},
         "changeSummary": {"type": "object"},
-        "evidenceSealRef": {"type": ["string", "null"]}
+        "evidenceSealRef": {"type": ["string", "null"]},
+        "writePolicy": {"$ref": "#/$defs/WritePolicy"},
+        "writePolicyDigest": {"$ref": "#/$defs/Digest"},
+        "writeEnforcement": {"$ref": "#/$defs/WriteEnforcement"}
       },
       "additionalProperties": false
     },

package/runtime/schemas/final-report-v2.0.schema.json

@@ -251,7 +251,7 @@
     },
     "verdictCard": {
       "type": "object",
-      "description": "Top-of-report at-a-glance card. It carries no verdict token — the token lives once, in finalVerdict. `direction` and `nextStep` MUST byte-match finalVerdict and recommendedNextSteps[0].",
+      "description": "Top-of-report at-a-glance card. It carries no verdict token — the token lives once, in finalVerdict, and additionalProperties:false keeps it from being copied here. Authoring guideline: write `direction` to agree with finalVerdict.direction and `nextStep` to agree with recommendedNextSteps[0]. Nothing compares the two copies afterwards — assembly rewrites `nextStep` on both cards together when the plan-body gate passes, and leaves `direction` as the writer wrote it — so a disagreement between them is published as written.",
       "required": [
         "finalConclusion",
         "direction",
@@ -312,9 +312,8 @@
     },
     "summary": {
       "type": "array",
-      "description": "## Summary of the Problem or Verification Target. 3-5 rows.",
+      "description": "## Summary of the Problem or Verification Target. Usually 3-5 rows; no upper limit.",
       "minItems": 1,
-      "maxItems": 8,
       "items": {
         "$ref": "#/$defs/SummaryRow"
       }
@@ -3897,8 +3896,8 @@
         },
         "summary": {
           "type": "string",
-          "minLength": 1,
-          "maxLength": 120
+          "minLength": 1
+          
         },
         "details": {
           "type": "string",
@@ -7527,8 +7526,8 @@
               },
               "summary": {
                 "type": "string",
-                "minLength": 1,
-                "maxLength": 120
+                "minLength": 1
+                
               },
               "details": {
                 "type": "string",
@@ -9030,24 +9029,6 @@
             "type": "string",
             "minLength": 1
           }
-        },
-        "rewrittenPaths": {
-          "type": "array",
-          "description": "data.json paths this round actually rewrote for this cause group. A self-fix round is contractually a targeted correction, not a full draft regeneration; recording the reach is what makes that claim checkable later.",
-          "uniqueItems": true,
-          "items": {
-            "type": "string",
-            "minLength": 1
-          }
-        },
-        "outsideScopePaths": {
-          "type": "array",
-          "description": "The subset of rewrittenPaths that lies outside the sections this group's itemIds point at. Carrying a correction to its contradictions legitimately reaches further than the flagged item, so this is a measurement, not a violation.",
-          "uniqueItems": true,
-          "items": {
-            "type": "string",
-            "minLength": 1
-          }
         }
       }
     },
@@ -9569,10 +9550,12 @@
           "minLength": 1
         },
         "verdict": {
+          "description": "`not-run` is not a rejection: the verifier produced no verdict at all (timeout, error, usage limit). `FAIL` rejects the diff and opens the stage fix cycle, so spending it on a verifier that never ran manufactures a defect nobody found \u2014 see `_implementation-verifier.md` \"All-verifier-failure policy\".",
           "enum": [
             "PASS",
             "CONCERNS",
-            "FAIL"
+            "FAIL",
+            "not-run"
           ]
         },
         "readOnlyCommandLog": {