okstra 0.107.2 → 0.108.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "okstra",
-  "version": "0.107.2",
+  "version": "0.108.0",
   "description": "Multi-agent cross-verification orchestrator runtime + Claude Code skills.",
   "license": "MIT",
   "author": "devonshin",

package/runtime/BUILD.json

@@ -1,5 +1,5 @@
 {
-  "package": "0.107.2",
-  "builtAt": "2026-07-01T09:21:00.281Z",
+  "package": "0.108.0",
+  "builtAt": "2026-07-02T01:43:53.766Z",
   "repoRoot": "/home/runner/work/okstra/okstra"
 }

package/runtime/prompts/lead/okstra-lead-contract.md

@@ -87,7 +87,7 @@ User-utterance interpretation rule:
 
 ## Progress reporting (BLOCKING)
 
-A single okstra run frequently spans 30–120 minutes of wall-clock time with multi-minute silent windows while workers run. Without explicit progress signals the user cannot distinguish "still working" from "hung", so Lead MUST emit a single short progress line at each of the checkpoints below — as plain user-facing text in a separate brief message (not buried inside a tool call). One line per checkpoint, format: `PROGRESS: <phase-id> <verb-phrase>`.
+A single okstra run frequently spans 30–120 minutes of wall-clock time with multi-minute silent windows while workers run. Without explicit progress signals the user cannot distinguish "still working" from "hung", so Lead MUST emit a single short progress line at each of the checkpoints below — as plain user-facing text in a separate brief message (not buried inside a tool call). One line per checkpoint, format: `PROGRESS: <phase-id> <verb-phrase>`. Emit the line raw — the literal `PROGRESS:` token must begin the line. Do NOT wrap it in inline-code backticks (`` `PROGRESS: ...` ``) or a ```` ``` ```` code fence; markdown wrapping is what the post-hoc conformance validator scrapes around, and raw emit keeps the signal unambiguous.
 
 Required checkpoints:
 

package/runtime/prompts/profiles/_common-contract.md

@@ -40,7 +40,8 @@ profile document.
     - **Only confirmed-complete teammates, never the lead.** NEVER send a shutdown_request to a teammate whose result file has not yet appeared. In particular the critic runs CONCURRENTLY with the first reverify round (see `convergence` "Coverage critic pass"), so it MUST NOT be shut down until its own result is collected. NEVER target the lead's own session.
     - Only individual completed teammates are dismissed here; the rest of the roster stays for the remaining batches. There is no `TeamDelete` tool (removed in CC v2.1.178) — the implicit team itself ends with the session; teardown only dismisses teammates.
     - Silent-skip in `tmux-pane` backend runs (external-lead workers are not session teammates); otherwise the on-disk existence check at run-end teardown is the authority on whether a roster exists.
-  - Both (a) and (b) run **automatically without any interactive prompt**. After running them, emit the checkpoint line `PROGRESS: phase-batch-cleanup panes=<n> teammates=<m>` (counts only — NEVER expose `%NNN`, `lead-pane.id`, or raw Agent names) and proceed; this is the BLOCKING checkpoint the Phase 7 validator requires before each convergence round and before the report-writer dispatch (`prompts/lead/okstra-lead-contract.md` "Progress reporting (BLOCKING)"). **Effect caveat:** Claude Code exposes no tool to surgically delete a roster entry mid-run, so a dismissed teammate may still show as an idle pill; the shutdown still reclaims its session and prevents the roster from growing with live members. On the FIRST batch of a run nothing has been dispatched yet — both steps no-op.
+  - **(c) record the current session into team-state (축1 — re-issued session generation capture).** batch cleanup 직후(그리고 아래 `PROGRESS: phase-batch-cleanup` 방출 전), lead 는 재발급된 세션 세대가 Phase 7 토큰·PROGRESS 수집에서 누락되지 않도록 현재 live 세션을 team-state 에 기록한다: `okstra token-usage "<TEAM_STATE_PATH>" --record-observed-session --project-root "<PROJECT_ROOT>"` 를 1회 호출한다(`<TEAM_STATE_PATH>` 와 `<PROJECT_ROOT>` 는 shell 변수·`$(...)` 없이 리터럴 절대경로로 치환 — `Bash(okstra:*)` 매칭 유지). `--project-root` 는 **필수**다: 생략하면 collector 가 team-state 의 상위 디렉터리(run/state 경로)를 project root 로 잘못 추론해 엉뚱한 `~/.claude/projects/<encoded-cwd>/` 를 뒤지고 조용히 no-op 하므로 축1 이 꺼진다. 실패는 무시 가능한 best-effort — worker 세션이거나 이미 기록된 세대이면 no-op 다. `python3 "$HOME/..."` 직접 호출은 금지(`$HOME` 확장이 리터럴-토큰 permission 매칭을 깨고 매 호출 확인 프롬프트를 유발) — 반드시 `okstra token-usage` 서브커맨드를 쓴다.
+  - Both (a), (b), and (c) run **automatically without any interactive prompt**. After running them, emit the checkpoint line `PROGRESS: phase-batch-cleanup panes=<n> teammates=<m>` (counts only — NEVER expose `%NNN`, `lead-pane.id`, or raw Agent names) and proceed; this is the BLOCKING checkpoint the Phase 7 validator requires before each convergence round and before the report-writer dispatch (`prompts/lead/okstra-lead-contract.md` "Progress reporting (BLOCKING)"). **Effect caveat:** Claude Code exposes no tool to surgically delete a roster entry mid-run, so a dismissed teammate may still show as an idle pill; the shutdown still reclaims its session and prevents the roster from growing with live members. On the FIRST batch of a run nothing has been dispatched yet — the pane/teammate steps (a)/(b) no-op; step (c) still records the current session.
 - Phase wrap-up — okstra pane disposition (shared, runs AFTER Phase 7 persistence/token collection and BEFORE teammate teardown):
   - At run end the only residual okstra panes are the LAST phase's (e.g. the `report-writer-worker` agent pane and any codex/antigravity trace pane). `okstra-trace-cleanup.sh --list --run-dir "<RUN_DIR>"` returns one tab-separated `<pane_id>\t<pane_title>` line per residual okstra pane (worker-agent + trace) for this run.
   - After the final-report file has been written and the routing recommendation has been issued, the lead MUST ALWAYS run `$HOME/.okstra/bin/okstra-trace-cleanup.sh --list --run-dir "<RUN_DIR>"` exactly once — NEVER gating this call on its own reading of `lead-pane.id`. The output lists every residual okstra pane (worker-agent + trace) for this run, never the lead's own pane; outside tmux it is a safe no-op (empty output).

package/runtime/python/okstra_ctl/session.py

@@ -5,6 +5,7 @@ bash session.sh 의 python 구현. claude session id 생성, resume command
 """
 from __future__ import annotations
 
+import json
 import os
 import uuid
 from pathlib import Path
@@ -48,6 +49,49 @@ def resolve_inproc_lead_session_id(project_root: Path) -> str:
         return ""
 
 
+def _session_has_agent_name(jsonl_path: Path) -> bool:
+    """세션 jsonl 에 agentName 이 있으면 worker 세션(lead 아님)."""
+    try:
+        with jsonl_path.open(encoding="utf-8") as fh:
+            for raw in fh:
+                try:
+                    rec = json.loads(raw)
+                except (json.JSONDecodeError, UnicodeDecodeError):
+                    continue
+                if rec.get("agentName"):
+                    return True
+    except OSError:
+        return False
+    return False
+
+
+def record_observed_lead_session(project_root: Path, team_state_path: Path) -> str:
+    """현재 live lead 세션을 관측해 team-state 에 append(멱등). 워커 세션이거나
+    관측 실패·중복이면 '' 반환. 재발급으로 갈린 세대를 축1 이 여기에 모은다.
+    """
+    sid = resolve_inproc_lead_session_id(project_root)
+    if not sid:
+        return ""
+    proj_dir = _claude_projects_dir_for(project_root)
+    jsonl = proj_dir / f"{sid}.jsonl"
+    if _session_has_agent_name(jsonl):
+        return ""
+    try:
+        state = json.loads(team_state_path.read_text(encoding="utf-8"))
+    except (OSError, json.JSONDecodeError):
+        return ""
+    lead_ids = state.setdefault("leadSessionIds", [])
+    if sid in lead_ids:
+        return ""
+    lead_ids.append(sid)
+    team = f"session-{sid[:8]}"
+    observed = state.setdefault("observedTeamNames", [])
+    if team not in observed:
+        observed.append(team)
+    team_state_path.write_text(json.dumps(state, indent=2), encoding="utf-8")
+    return sid
+
+
 def write_claude_resume_command_file(
     *,
     resume_command_path: Path,

package/runtime/python/okstra_token_usage/claude.py

@@ -280,13 +280,18 @@ def _cached_needle_scan(jsonl_path: Path, cache: dict, needle_lower: str) -> boo
 
 def find_claude_team_sessions(
     cwd: Path,
-    team_name: str,
+    team_needles,
     lead_sid: str | None = None,
     projects_root: Path | None = None,
     *,
     incremental: bool = False,
 ) -> dict[str, Path]:
-    """Map sessionId -> jsonl path for all jsonls tagged with `team_name`.
+    """Map sessionId -> jsonl path for all jsonls tagged with any of `team_needles`.
+
+    `team_needles` is an ``Iterable[str]`` of teamName generations; a jsonl is
+    included when it matches any one of them (union). The lead re-issue
+    fragments an implicit-team session into multiple `session-<leadSid>`
+    generations, so a single string is no longer sufficient.
 
     Matching is case-insensitive on the teamName needle to tolerate runs where
     the lead recorded `team.teamName` with a different case than the harness
@@ -306,17 +311,18 @@ def find_claude_team_sessions(
     out: dict[str, Path] = {}
     if not proj_dir.is_dir():
         return out
-    needle_lower = f'"teamname":"{(team_name or "").lower()}"'
-    if team_name:
-        for p in proj_dir.glob("*.jsonl"):
+    needles_lower = [f'"teamname":"{n.lower()}"' for n in team_needles if n]
+    for p in proj_dir.glob("*.jsonl"):
+        for needle_lower in needles_lower:
             if incremental:
                 cache = load_cache(p)
-                if _cached_needle_scan(p, cache, needle_lower):
-                    out[p.stem] = p
+                hit = _cached_needle_scan(p, cache, needle_lower)
                 save_cache(p, cache)
             else:
-                if _needle_scan(p, {"offset": 0, "found": False}, needle_lower):
-                    out[p.stem] = p
+                hit = _needle_scan(p, {"offset": 0, "found": False}, needle_lower)
+            if hit:
+                out[p.stem] = p
+                break
     if lead_sid:
         direct = proj_dir / f"{lead_sid}.jsonl"
         if direct.is_file():

package/runtime/python/okstra_token_usage/cli.py

@@ -60,12 +60,35 @@ def main() -> int:
             "See schemas/final-report-v1.0.schema.json for the data shape."
         ),
     )
+    parser.add_argument(
+        "--record-observed-session",
+        action="store_true",
+        help=(
+            "Observe the current live lead session and append it to the "
+            "team-state's leadSessionIds/observedTeamNames (idempotent), "
+            "print the appended sid, then exit"
+        ),
+    )
     args = parser.parse_args()
 
     if not args.team_state.is_file():
         print(f"team-state not found: {args.team_state}", file=sys.stderr)
         return 2
 
+    if args.record_observed_session:
+        from okstra_ctl.session import record_observed_lead_session
+
+        from .collect import _infer_project_root
+
+        if args.project_root is not None:
+            project_root = args.project_root
+        else:
+            state = json.loads(args.team_state.read_text())
+            project_root = _infer_project_root(args.team_state, state)
+        sid = record_observed_lead_session(project_root, args.team_state)
+        print(sid)
+        return 0
+
     updated = collect(args.team_state, args.project_root,
                       incremental=not args.no_cache)
 

package/runtime/python/okstra_token_usage/collect.py

@@ -131,6 +131,53 @@ def _run_end_estimate(run_dir: Path, suffix: str) -> str | None:
     return datetime.fromtimestamp(mtime, tz=timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ")
 
 
+def _project_root_from_team_state(team_state_path: Path) -> Path | None:
+    """team-state path(`<root>/.okstra/tasks/.../state/team-state-*.json`)에서
+    프로젝트 루트(`.okstra` 를 담은 디렉토리)를 되짚는다. 못 찾으면 None."""
+    for parent in team_state_path.resolve().parents:
+        if parent.name == OKSTRA_RELATIVE.name:
+            return parent.parent
+    return None
+
+
+def _session_first_ts(jsonl_path: Path) -> str | None:
+    """세션 jsonl 의 최소 timestamp — reconstruct_needles_from_workers 와 동일한
+    top-level `timestamp` 규칙. 파일 부재/파싱 실패 레코드는 건너뛴다."""
+    first_ts: str | None = None
+    try:
+        with jsonl_path.open(encoding="utf-8") as fh:
+            for raw in fh:
+                try:
+                    rec = json.loads(raw)
+                except (json.JSONDecodeError, UnicodeDecodeError):
+                    continue
+                ts = rec.get("timestamp")
+                if ts and (first_ts is None or ts < first_ts):
+                    first_ts = ts
+    except OSError:
+        return None
+    return first_ts
+
+
+def _earliest_lead_session_ts(state: dict, team_state_path: Path) -> str | None:
+    """`state["leadSessionIds"]` 각 lead 세션 jsonl 첫 ts 중 최소값. 부재하거나
+    어느 세션에서도 ts 를 못 찾으면 None. proj_dir 은 team-state path 에서 되짚은
+    프로젝트 루트에 `claude_project_dir` 규칙을 적용해 해소한다."""
+    lead_ids = [sid for sid in (state.get("leadSessionIds") or []) if sid]
+    if not lead_ids:
+        return None
+    project_root = _project_root_from_team_state(team_state_path)
+    if project_root is None:
+        return None
+    proj_dir = claude_project_dir(project_root)
+    earliest: str | None = None
+    for sid in lead_ids:
+        ts = _session_first_ts(proj_dir / f"{sid}.jsonl")
+        if ts and (earliest is None or ts < earliest):
+            earliest = ts
+    return earliest
+
+
 def resolve_run_window(team_state_path: Path, state: dict) -> tuple[str | None, str | None]:
     """이 run 의 [시작, 종료] ISO 윈도우.
 
@@ -140,12 +187,21 @@ def resolve_run_window(team_state_path: Path, state: dict) -> tuple[str | None,
     $416 / 3h). 토큰 집계를 이 윈도우로 스코핑해 그 run 분만 센다. 시작 =
     이 run 의 run-manifest createdAt, 종료 = team-state.runEndedAt → 이 run 의
     status mtime → 현재 시각(아직 진행 중) 순으로 해소한다. 접미사를 못 뽑으면
-    (None, None) — 윈도우 없이 전체를 세는 기존 동작으로 안전 폴백."""
+    (None, None) — 윈도우 없이 전체를 세는 기존 동작으로 안전 폴백.
+
+    시작 완화: run-manifest createdAt 이 이 run 의 실제 lead/worker 세션보다
+    늦게 찍히면(관측: dev-9902 — createdAt 11:43Z 가 05:34Z 시작 세션보다 늦음)
+    since 가 앞선 세션을 잘라낸다. Task 3 이 기록한 `leadSessionIds[]` 세션의
+    첫 ts 최소값이 createdAt 보다 앞서면 그 값으로 since 를 앞당긴다.
+    `leadSessionIds` 부재(legacy)면 createdAt 그대로 — 기존 동작 불변."""
     suffix = run_artifact_suffix(team_state_path)
     if not suffix:
         return None, None
     run_dir = team_state_path.parent.parent
     since = _run_manifest_created_at(run_dir, suffix)
+    earliest = _earliest_lead_session_ts(state, team_state_path)
+    if earliest and (since is None or earliest < since):
+        since = earliest
     until = state.get("runEndedAt") or _run_end_estimate(run_dir, suffix) or utc_now()
     return since, until
 
@@ -214,6 +270,55 @@ def resolve_team_name(state: dict) -> str:
     return team_name
 
 
+def resolve_team_needles(state: dict) -> list[str]:
+    """이 run 에 속한 harness teamName(`session-<leadSid-prefix>`) 전체.
+
+    lead 재발급마다 세대가 갈리므로 team-state.teamName 단일값으로는 후속
+    세대 워커를 놓친다. 축1 이 기록한 `observedTeamNames[]` 를 정본으로 쓰고,
+    수동 정정으로 teamName 에 직접 박힌 `session-*` 값도 흡수한다.
+    audit label(`okstra-<task-key>`) 은 harness needle 이 아니므로 제외한다.
+    """
+    needles: set[str] = set()
+    for name in state.get("observedTeamNames") or []:
+        if isinstance(name, str) and name.startswith("session-"):
+            needles.add(name)
+    label = resolve_team_name(state)
+    if label.startswith("session-"):
+        needles.add(label)
+    return sorted(needles)
+
+
+def resolve_team_needles_with_source(
+    state: dict, cwd, since, until, projects_root=None,
+) -> tuple[list[str], str]:
+    """세 소비처(collect + 두 validator) 공통 needle 조립 규칙.
+
+    needle 은 `resolve_team_needles(state)` 만으로 조립한다 — 축1 의
+    `observedTeamNames[]` 세대들 + `session-*` 형태의 수동 정정 라벨. audit
+    label(`okstra-<task-key>`)은 needle 로 절대 쓰지 않는다: 하네스 jsonl 은
+    `session-*` teamName 만 실어(okstra-lead-contract.md), 라벨은 여러 run 이
+    공유하는 task-key 파생값이라 needle 로 쓰면 같은 task-key 의 다른 run 세션을
+    끌어와 cross-run mis-attribution 을 일으킨다(spec §2.1 이 배제하는 바로 그
+    실패). `resolve_team_name` 은 표시 라벨(`usageSummary.teamName`) 전용.
+
+    `resolve_team_needles` 가 비면(observedTeamNames 미기록 legacy run) 축4 의
+    `reconstruct_needles_from_workers` 로 run window 안 워커 jsonl 의 `session-*`
+    teamName 을 best-effort 복구하고 `reconstructed-from-workers` provenance 를
+    돌려준다 — window 로 스코핑되므로 타 run 을 안전하게 배제한다. 그마저 비면
+    `none`. 반환한 source 는 각 소비처가 자기 관례대로 표면화한다
+    (collect → usageSummary.needleSource).
+    """
+    needles = resolve_team_needles(state)
+    if needles:
+        return needles, "observed-team-names"
+    reconstructed = reconstruct_needles_from_workers(
+        cwd, since, until, projects_root=projects_root
+    )
+    if reconstructed:
+        return reconstructed, "reconstructed-from-workers"
+    return [], "none"
+
+
 def _resolve_project_path(project_root: Path, raw_path: str) -> Path | None:
     if not raw_path:
         return None
@@ -407,7 +512,8 @@ def _collect_codex_runtime_usage(state: dict, project_root: Path) -> dict:
             _aggregate_totals(totals),
             session_paths,
         )
-    _populate_usage_summary(state, team_name=resolve_team_name(state), sessions_found=0)
+    _populate_usage_summary(state, team_name=resolve_team_name(state),
+                            sessions_found=0, needle_source="none")
     return state
 
 
@@ -418,6 +524,7 @@ def _populate_usage_summary(
     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 {}
@@ -462,6 +569,7 @@ def _populate_usage_summary(
         },
         "collectedAt": utc_now(),
         "teamName": team_name,
+        "needleSource": needle_source,
         "sessionsFound": sessions_found,
         "unmatchedModels": sorted(set(unmatched_models)),
         "unattributedTeamSessions": unattributed_sessions or [],
@@ -490,9 +598,24 @@ def collect(team_state_path: Path, project_root: Path | None = None, *,
 
     # 1) Claude sessions (lead + claude-side workers). Cache totals at scan
     # time so we don't re-read the jsonl when a worker matches multiple
-    # sessions.
-    claude_sessions = find_claude_team_sessions(cwd, team_name, lead_sid,
+    # sessions. needle 집합(observedTeamNames 여러 세대)으로 스캔하고, 없으면
+    # 워커 jsonl 에서 복구한다 — team_name 은 표시 라벨 전용.
+    team_needles, needle_source = resolve_team_needles_with_source(
+        state, cwd, run_since, run_until
+    )
+    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 는 완화하지 않는다(오귀속 방지).
+    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
     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
@@ -623,6 +746,7 @@ def collect(team_state_path: Path, project_root: Path | None = None, *,
         sessions_found=len(claude_sessions),
         unattributed_sessions=unattributed_sessions,
         unattributed_usage=unattributed_usage,
+        needle_source=needle_source,
     )
     return state
 
@@ -637,3 +761,38 @@ def _infer_project_root(team_state_path: Path, state: dict) -> Path:
             return p
         p = p.parent
     raise SystemExit(f"could not infer project root from {team_state_path}")
+
+
+def reconstruct_needles_from_workers(cwd, since, until, projects_root=None) -> list[str]:
+    """observedTeamNames 가 없는 과거 run 의 best-effort 복구: run window 안
+    워커 jsonl(agentName 존재)이 달고 있는 session-* teamName variant 집합.
+    """
+    from okstra_token_usage.paths import claude_project_dir, ts_in_window
+    proj_dir = claude_project_dir(cwd, projects_root)
+    found: set[str] = set()
+    if not proj_dir.is_dir():
+        return []
+    for p in proj_dir.glob("*.jsonl"):
+        agent = team = first_ts = None
+        try:
+            with p.open(encoding="utf-8") as fh:
+                for raw in fh:
+                    try:
+                        rec = json.loads(raw)
+                    except (json.JSONDecodeError, UnicodeDecodeError):
+                        continue
+                    if agent is None and rec.get("agentName"):
+                        agent = rec["agentName"]
+                    if team is None and rec.get("teamName"):
+                        team = rec["teamName"]
+                    ts = rec.get("timestamp")
+                    if ts and (first_ts is None or ts < first_ts):
+                        first_ts = ts
+        except OSError:
+            continue
+        # 의도적 divergence: 이 untrusted best-effort 경로에서는 ts 를 못 구한
+        # 워커를 제외한다 (ts_in_window 의 파싱 실패→포함 정책과 반대).
+        if agent and team and str(team).startswith("session-") \
+                and first_ts and ts_in_window(first_ts, since, until):
+            found.add(team)
+    return sorted(found)

package/runtime/validators/forbidden_actions.py

@@ -122,13 +122,19 @@ def scan_forbidden_actions(
     """Return human-readable violation strings (empty = clean)."""
     _ensure_token_usage_importable()
     from okstra_token_usage.claude import find_claude_team_sessions
-    from okstra_token_usage.collect import resolve_run_window, resolve_team_name
+    from okstra_token_usage.collect import (
+        resolve_run_window,
+        resolve_team_needles_with_source,
+    )
 
     since, until = resolve_run_window(team_state_path, team_state)
     lead_sid = (team_state.get("lead") or {}).get("sessionId") or ""
+    team_needles, _needle_source = resolve_team_needles_with_source(
+        team_state, project_root, since, until, projects_root=claude_projects_dir
+    )
     sessions = find_claude_team_sessions(
         project_root,
-        resolve_team_name(team_state),
+        team_needles,
         lead_sid,
         projects_root=claude_projects_dir,
     )

package/runtime/validators/validate_session_conformance.py

@@ -33,7 +33,13 @@ _WORKER_DISPATCH_MODES = {"cli-wrapper", "mixed", "tmux-pane"}
 _ATTEMPTED_STATUSES = {"completed", "timeout", "error"}
 
 # lead 의 체크포인트 라인 — assistant text 블록 안에서 line-anchored 로만 인정.
-_PROGRESS_LINE_RE = re.compile(r"^PROGRESS:[ \t]+(?P<phase>\S+)(?P<rest>.*)$", re.MULTILINE)
+# lead 는 계약상 raw 로 emit 해야 하지만 실측(dev-9902)에서 `` `PROGRESS: ...` ``
+# 인라인 코드나 코드펜스로 감싸 emit 하는 경우가 있어, 라인 양끝의 backtick 과
+# 선행 들여쓰기를 허용한다. phase 는 backtick 을 포함하지 않는다.
+_PROGRESS_LINE_RE = re.compile(
+    r"^[ \t]*`*[ \t]*PROGRESS:[ \t]+(?P<phase>[^\s`]+)(?P<rest>[^`\n]*)`*[ \t]*$",
+    re.MULTILINE,
+)
 
 # claude-worker audit 사이드카의 heartbeat 라인 (claude-worker.md "Heartbeat").
 _HEARTBEAT_LINE_RE = re.compile(
@@ -139,7 +145,8 @@ def _scan_one_jsonl(
                     continue
                 if block.get("type") == "text":
                     for m in _PROGRESS_LINE_RE.finditer(block.get("text") or ""):
-                        progress.append((ts, m.group("phase"), m.group(0).strip()))
+                        line = f"PROGRESS: {m.group('phase')}{m.group('rest')}".rstrip()
+                        progress.append((ts, m.group("phase"), line))
                 elif block.get("type") == "tool_use" and block.get("name") == "Read":
                     base = Path(str((block.get("input") or {}).get("file_path") or "")).name
                     if base in _SIDECAR_BASENAMES:
@@ -160,14 +167,29 @@ def _collect_lead_evidence(
     agentName 없음)를 흡수한다 — worker 세션은 agentName 이 있어 자연 배제된다.
     """
     from okstra_token_usage.claude import find_claude_team_sessions
-    from okstra_token_usage.collect import resolve_run_window, resolve_team_name
+    from okstra_token_usage.collect import (
+        resolve_run_window,
+        resolve_team_needles_with_source,
+    )
     from okstra_token_usage.paths import claude_project_dir
 
     since, until = resolve_run_window(team_state_path, team_state)
     lead_sid = (team_state.get("lead") or {}).get("sessionId") or ""
+    team_needles, _needle_source = resolve_team_needles_with_source(
+        team_state, project_root, since, until, projects_root=projects_root
+    )
     sessions = find_claude_team_sessions(
-        project_root, resolve_team_name(team_state), lead_sid, projects_root=projects_root
+        project_root, team_needles, lead_sid, projects_root=projects_root
     )
+    # `claude --resume` 로 fork 되거나 leadSessionIds[] 에 기록된 lead 세대는
+    # team 태그 needle 로 안 잡힐 수 있어 명시적으로 후보에 추가한다.
+    proj_dir = claude_project_dir(project_root, projects_root)
+    for sid in (team_state.get("leadSessionIds") or []):
+        if not isinstance(sid, str) or not sid:
+            continue
+        candidate = proj_dir / f"{sid}.jsonl"
+        if candidate.is_file():
+            sessions.setdefault(sid, candidate)
     evidence = _LeadEvidence(window=(since, until))
     for sid, path in sorted(sessions.items()):
         progress, reads, agent_name = _scan_one_jsonl(path, since, until)
@@ -178,7 +200,6 @@ def _collect_lead_evidence(
         for base, ts_list in reads.items():
             evidence.sidecar_reads.setdefault(base, []).extend(ts_list)
     if not evidence.scanned_files:
-        proj_dir = claude_project_dir(project_root, projects_root)
         return None, (
             f"lead session jsonl not found under {proj_dir} "
             f"(lead.sessionId={lead_sid or '<empty>'}) — PROGRESS checkpoint / "