okstra 0.71.1 → 0.71.2

package/package.json

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

package/runtime/BUILD.json

@@ -1,5 +1,5 @@
 {
-  "package": "0.71.1",
-  "builtAt": "2026-06-11T03:33:31.499Z",
+  "package": "0.71.2",
+  "builtAt": "2026-06-11T04:23:08.954Z",
   "repoRoot": "/home/runner/work/okstra/okstra"
 }

package/runtime/agents/SKILL.md

@@ -89,7 +89,7 @@ Required checkpoints:
 - `PROGRESS: phase-1-intake reading task bundle` — at the start of Phase 1, before issuing parallel Read calls.
 - `PROGRESS: phase-1-intake complete` — after all intake reads return.
 - `PROGRESS: phase-2-prompts preparing <N> worker prompts` — at the start of Phase 2, before any `Write` to the assigned prompt paths.
-- `PROGRESS: phase-3-team-create attempting TeamCreate` — immediately before the `TeamCreate` call.
+- `PROGRESS: phase-3-team-create attempting TeamCreate` — immediately before the `TeamCreate` call. When the launch prompt's "Concurrent-run: no-team background" gate forbids TeamCreate, emit `PROGRESS: phase-3-team-create skipped (concurrent-run)` instead, immediately after recording `teamCreate: { attempted: false, status: "skipped", reason: "concurrent-run" }` in team-state — the checkpoint line itself is still required.
 - `PROGRESS: phase-4-dispatch worker=<role> model=<model>` — once per worker, immediately before the `Agent` / wrapper call.
 - `PROGRESS: phase-5-poll pending=<n> done=<m>` — emitted on each wakeup while the pending set is non-empty.
 - `PROGRESS: phase-5-collect worker=<role> status=<terminal-status>` — once per worker, immediately after the result file is verified.

package/runtime/prompts/profiles/_implementation-executor.md

@@ -30,7 +30,7 @@ until Phase 5 ends, then drop from active context for Phase 6/7.
   - Doc-only / config-only / pure-rename steps that have no observable runtime behaviour are exempt from the failing-test requirement, but the executor MUST cite the exemption per step in the final report (`TDD exemption: <reason>`).
   - When the touched area has no existing test harness, the executor MUST stand up the minimum harness needed to host one regression test for this run rather than skipping TDD entirely. Record the harness-bootstrap step as an `Out-of-plan edit` if it is not in the plan.
 - **DB / IO / SQL changes require real execution — mock-only is NOT validation evidence:** when this run's diff touches DB/IO/SQL (ORM / query-builder code — sequelize / typeorm / prisma / knex / raw SQL — `*.repository.*`, model/entity files, `migrations/**`, `*.sql`, or any changed query string), a mocked unit test cannot observe the SQL the query builder actually emits — a mocked suite once passed while `count({ col: 'FontFamily.fontFamily' })` threw `Unknown column` on the real DB. The executor MUST run the change against a real (or faithful-replica) datastore — the `db-test` validation step (plan `validation` db step, else `project.json.qaCommands.db-test`), targeting a **local / replica** DB — and cite its exact command + exit code in the final report's `Validation evidence`. If no real DB / `db-test` command is reachable, do NOT claim the change verified: label the DB portion `정적 분석상 …, 미검증(실행 안 함)` in the report, surface it in the routing recommendation, and never downplay the real run as "too heavy". `git push` stays forbidden (universal list); the unverified DB state is carried forward so `final-verification` cannot accept it and `release-handoff` cannot push.
-- **Real-IO test isolation (BLOCKING).** A test that exercises a **real** datastore, HTTP endpoint, external service, message queue, or filesystem — a live DB connection / DSN, a real `fetch` / `axios` / `http` request, an actual S3 / queue client, anything the project's normal CI test suite cannot run because that backend is absent — MUST be written under the task's qa directory `<task_root>/qa/` (the `TASK_QA_PATH` token; same directory that holds the Tier 3 conformance manifest). It MUST NOT be written into the project source test tree — `src/**`, `test/**`, `tests/**`, `**/__test__/**`, `**/__tests__/**`, `*.spec.*`, `*.test.*`, or anywhere the project's lint/test globs collect. Two reasons: (a) the project's CI / normal suite has no real DB or network, so a real-IO test placed in source silently breaks the pipeline; (b) it is an okstra verification artifact, and the artifact-home rule confines okstra outputs to `.okstra/`. **The dividing line is the IO, not the intent:** a unit test that stubs/spies only *injected collaborators* (mock — no real socket, no real DB handle) is a TDD red-green artifact and stays in source; the moment a test opens a real connection or makes a real network call it belongs in qa. A stage's real-IO requirement check is a Tier 3 conformance script under `<task_root>/qa/` (declared via the implementation-planning conformance entry) — never smuggle real IO into a `*.spec.*` in source to make it run "as a unit test". The `db-test` real-execution gate above is satisfied by the conformance/db-test path against the replica, NOT by adding a live-DB `*.spec.*` to the project suite. **These qa artifacts stay untracked — never commit them.** `.okstra/**` is gitignored (the artifact-home rule); conformance scripts and their results are *executed* and recorded in the carry sidecar / verifier result, never written into git history. A committed `.okstra/qa` file is a stage-branch defect that leaks okstra internals into the eventual PR (see the `git add` rules below).
+- **Real-IO test isolation (BLOCKING).** A test that exercises a **real** datastore, HTTP endpoint, external service, message queue, or filesystem — a live DB connection / DSN, a real `fetch` / `axios` / `http` request, an actual S3 / queue client, anything the project's normal CI test suite cannot run because that backend is absent — MUST be written under the task's qa scripts directory `<task_root>/qa/scripts/` (`<TASK_QA_PATH>/scripts`; the `qa/` root itself holds only data sidecars — the Tier 3 conformance manifest and `result-*.json`). It MUST NOT be written into the project source test tree — `src/**`, `test/**`, `tests/**`, `**/__test__/**`, `**/__tests__/**`, `*.spec.*`, `*.test.*`, or anywhere the project's lint/test globs collect. Two reasons: (a) the project's CI / normal suite has no real DB or network, so a real-IO test placed in source silently breaks the pipeline; (b) it is an okstra verification artifact, and the artifact-home rule confines okstra outputs to `.okstra/`. **The dividing line is the IO, not the intent:** a unit test that stubs/spies only *injected collaborators* (mock — no real socket, no real DB handle) is a TDD red-green artifact and stays in source; the moment a test opens a real connection or makes a real network call it belongs in qa. A stage's real-IO requirement check is a Tier 3 conformance script under `<task_root>/qa/scripts/` (declared via the implementation-planning conformance entry) — never smuggle real IO into a `*.spec.*` in source to make it run "as a unit test". The `db-test` real-execution gate above is satisfied by the conformance/db-test path against the replica, NOT by adding a live-DB `*.spec.*` to the project suite. **Author qa specs with the project's own test framework — never hand-roll `describe`/`it`/`expect`.** When the project ships a test runner as a devDependency (jest / vitest / pytest …), the qa spec uses it, invoked with the project config plus a discovery override pointing at the qa scripts dir (jest: `npx jest --config <project jest config> --roots <task_root>/qa/scripts --runInBand <spec-name>`) — the project config keeps module aliases resolving while the default sweep never collects the file; never widen the project's own test config to include qa paths. For TypeScript qa specs also write `<task_root>/qa/scripts/tsconfig.json` (`extends` the project tsconfig, adds the runner's `types` entry, `"include": ["**/*.ts"]`) so editors resolve path aliases and test globals — it is a qa artifact like the rest (untracked). **These qa artifacts stay untracked — never commit them.** `.okstra/**` is gitignored (the artifact-home rule); conformance scripts and their results are *executed* and recorded in the carry sidecar / verifier result, never written into git history. A committed `.okstra/qa` file is a stage-branch defect that leaks okstra internals into the eventual PR (see the `git add` rules below).
 - re-read the approved plan end-to-end and parse the `## 5.5 Stage Map`. Read the **Stage** injected in the launch prompt (`Stage for this implementation run`): the single stage number this run owns. The runtime already selected and reserved this stage (one run = one stage) — do NOT recompute the start stage from `consumers.jsonl`.
   - load every `runs/<plan-key>/carry/stage-<i>.json` for `i ∈ depends-on(this stage)` and inject them into the executor's working context as "runtime carry-in". For a `depends-on (none)` stage, no sidecar load — task-brief only.
   - this stage's `depends-on` are all already `status:done`. Its file list, step order, Stage Validation commands, Stage Exit Contract, and rollback path are the authoritative scope.

package/runtime/prompts/profiles/_implementation-verifier.md

@@ -97,7 +97,7 @@ Re-running commands proves the diff *builds and passes*; it does NOT prove the d
   - **Untruthful name:** a read-named function (`get*` / `find*` / `load*`) that writes/inserts/mutates; an adapter or repository name encoding the caller's use-case (`*ForInit`) or hiding a domain rule (`findValid*` / `findActive*`).
   - **Hexagonal (only when the overlay is loaded):** business logic inside a port body; an adapter method that is not pure I/O (post-fetch JS filtering on domain state, domain-rule evaluation); a domain object declared outside the `domain/` boundary.
   - **okstra artifact committed to the branch:** any path in the `git diff --name-only <base>...HEAD` enumeration that lives under `.okstra/` (or `.project-docs/` when the legacy symlink is present). `.okstra/**` is gitignored, so a committed okstra file means the executor force-staged it (`git add -f`) — leaking verification artifacts (qa scripts, conformance results) into the eventual PR. Cite the path; recommend `git rm --cached <path>` to untrack it while keeping the file on disk. Conformance/qa evidence belongs in the carry sidecar / verifier result, never in git history.
-  - **Real-IO test in source tree:** a changed/added test under the project source test tree — `src/**`, `test/**`, `tests/**`, `**/__test__/**`, `**/__tests__/**`, `*.spec.*`, `*.test.*` — that opens a **real** DB connection / DSN, makes a real `fetch` / `axios` / `http` request, or otherwise hits real external IO without mocking the injected collaborator (a live handle, not a stub/spy). Real-IO tests MUST live under `<task_root>/qa/` per the executor's *Real-IO test isolation* rule — a live-IO test in source silently breaks the project's CI suite and violates the artifact-home rule. Cite the test file + the real-IO line; recommend moving it to `<task_root>/qa/` (or declaring it as a Tier 3 conformance script). Mock-only unit tests in source are NOT a hit.
+  - **Real-IO test in source tree:** a changed/added test under the project source test tree — `src/**`, `test/**`, `tests/**`, `**/__test__/**`, `**/__tests__/**`, `*.spec.*`, `*.test.*` — that opens a **real** DB connection / DSN, makes a real `fetch` / `axios` / `http` request, or otherwise hits real external IO without mocking the injected collaborator (a live handle, not a stub/spy). Real-IO tests MUST live under `<task_root>/qa/scripts/` per the executor's *Real-IO test isolation* rule — a live-IO test in source silently breaks the project's CI suite and violates the artifact-home rule. Cite the test file + the real-IO line; recommend moving it to `<task_root>/qa/scripts/` (or declaring it as a Tier 3 conformance script). Mock-only unit tests in source are NOT a hit.
 - **Advisory findings (recorded as recommendations; verdict MAY still PASS):** function >50 effective lines, a single body mixing read+write stages, weak readability, a missing-but-non-critical outcome assertion, newly orphaned private/public code that is safe to remove but not on a critical path, or weak-but-not-misleading names. These land in the verifier result as `should-fix` / `nit` recommendations, not as a `FAIL`.
 - **Output.** Every finding — blocking or advisory — is a structured item in the verifier's worker result (`path:line`, rule, severity, suggested fix) so it carries into Phase 5.5 convergence and the final report. A blocking hit sets the verifier verdict to `FAIL` with the rule cited, using the same verdict machinery as the Discrepancy rule above. `Claude lead` MUST NOT silently downgrade a cited blocking finding to advisory during synthesis; an override requires a concrete cited reason, exactly as for the Discrepancy rule.
 

package/runtime/prompts/profiles/implementation-planning.md

@@ -72,9 +72,9 @@
     - `### Carry-In` — for `depends-on (none)`: task-brief only. Otherwise: each depended-on stage's static exit contract + runtime sidecar path `runs/<impl-key>/carry/stage-<i>.json` placeholder.
     - `### Stepwise Execution Order` — bite-sized table with `step | action | files | command | expected`. **Effective row count ≤ 6** (excluding header / divider / blank). Each step is one action completable in 2–5 minutes; for code steps include actual code or diff sketch. **TDD ordering is MUST, not a preference:** the **first** effective step's `action` cell MUST start with the literal `RED:` and describe the failing test that captures this stage's `Acceptance` (`expected` = FAIL); at least one later `action` cell MUST start with the literal `GREEN:` and describe the minimal implementation that makes it pass (`expected` = PASS); an optional refactor step starts with `REFACTOR:`. **Exemption:** doc-only / config-only / pure-rename stages with no observable runtime behaviour may omit RED/GREEN by declaring one line `TDD exemption: <reason>` in the stage section (mirrors the executor's per-step exemption in `_implementation-executor.md`). Validator S10c enforces RED-first + GREEN, or the exemption line.
     - **Per-stage conformance declaration (mandatory one line, in the stage section — same placement freedom as `TDD exemption:`):** the stage MUST carry exactly one of:
-      - `Conformance tests: stage-<N> — <task_root>/qa/stage-<N>.<ext> (requires=[db|io|http|external,...])` — a Tier3 verification script that proves this stage's upstream requirements (brief / requirements-discovery / error-analysis / improvement-discovery → this stage's `Acceptance`) hold against **real** DB rows, real endpoints, or the real external API — NOT mocks. When you emit this line you MUST also (a) write the script to `<task_root>/qa/stage-<N>.<ext>` and (b) add a matching entry to `<task_root>/qa/conformance-manifest.json` with fields `stageKey` (= `<task-id>-stage-<N>`), `script`, `runCommand`, `requirementIds`, `requires` (subset of `{db, io, http, external}`), `passContract`, `exemption: null`, `waiver: null`. The script's standard interface: a `main` that exits `0`=PASS / non-zero=FAIL, and whose stdout ends with `QA-RESULT: PASS|FAIL` followed by one `REQ <id>: PASS|FAIL: <근거>` line per requirement.
+      - `Conformance tests: stage-<N> — <task_root>/qa/scripts/stage-<N>.<ext> (requires=[db|io|http|external,...])` — a Tier3 verification script that proves this stage's upstream requirements (brief / requirements-discovery / error-analysis / improvement-discovery → this stage's `Acceptance`) hold against **real** DB rows, real endpoints, or the real external API — NOT mocks. When you emit this line you MUST also (a) write the script to `<task_root>/qa/scripts/stage-<N>.<ext>` and (b) add a matching entry to `<task_root>/qa/conformance-manifest.json` with fields `stageKey` (= `<task-id>-stage-<N>`), `script`, `runCommand`, `requirementIds`, `requires` (subset of `{db, io, http, external}`), `passContract`, `exemption: null`, `waiver: null`. The script's standard interface: a `main` that exits `0`=PASS / non-zero=FAIL, and whose stdout ends with `QA-RESULT: PASS|FAIL` followed by one `REQ <id>: PASS|FAIL: <근거>` line per requirement. When the verification body is a test spec, author it with the project's own test framework (devDependency) invoked via a discovery override at `<task_root>/qa/scripts/` (jest: `--config <project config> --roots <task_root>/qa/scripts`) — never hand-roll `describe`/`expect` and never widen the project's own test config; for TypeScript specs also write `<task_root>/qa/scripts/tsconfig.json` extending the project tsconfig with the runner's `types` entry so editors resolve the file.
       - `Conformance exemption: <reason>` — only for stages that touch no db/io/http/external surface, or where unit tests fully cover the increment. (If the eventual `implementation` diff actually touches one of those surfaces, `validate-run.py`'s diff-surface cross-check is BLOCKING — an exemption cannot hide a real db/io/http/external change.)
-      The manifest lives at the **task level** (`<task_root>/qa/`, path token `TASK_QA_PATH`) and is shared across planning → implementation → final-verification. This declaration is enforced at three layers: `validators/validate-implementation-plan-stages.py` check **S11** forces every stage to carry one of the two lines; the manifest JSON structure is enforced by `validate_conformance_manifest` (run / validate-run); and the result gate (each script's `QA-RESULT`) is enforced by the verifier Tier3 + validate-run.
+      The manifest lives at the **task level** (`<task_root>/qa/`, path token `TASK_QA_PATH`) and is shared across planning → implementation → final-verification. Layout split: executable scripts (conformance + any real-IO test) live under `<task_root>/qa/scripts/`; data sidecars (`conformance-manifest.json`, `result-*.json`) stay at the `qa/` root. This declaration is enforced at three layers: `validators/validate-implementation-plan-stages.py` check **S11** forces every stage to carry one of the two lines; the manifest JSON structure — including each entry's `script` living under `qa/scripts/` — is enforced by `validate_conformance_manifest` (run / validate-run); and the result gate (each script's `QA-RESULT`) is enforced by the verifier Tier3 + validate-run.
     - `### Stage Exit Contract` — predicted added/modified files, newly exposed identifiers/types/endpoints, downstream-usable resources.
     - `### Stage Validation` — pre / mid / post exact commands or observable outcomes for this stage only.
   - **Vertical-slice-first partition rule (1st-class):** the grouping anchor is a **thin end-to-end vertical slice** — one stage delivers a single user-observable increment, crossing whatever layers are needed (data → service → API → UI) to make that one increment work. File/module proximity is demoted to the **intra-slice grouping rule**: within a slice, keep steps touching the same file/directory/module together so the diff, PR, and rollback unit stay cohesive. **Horizontal layer-splitting is forbidden** — never carve "the DB layer" into one stage and "the service layer" into the next; that produces stages that ship no standalone user value. A stage is split ONLY when (a) a real `depends-on` data/contract dependency exists, (b) effective steps would exceed 6, or (c) it is a distinct vertical slice (a different user-value increment). Maximising the number of parallel stages is NOT a reason to split — parallelism is an emergent property of independent stages, never a partitioning goal.

package/runtime/python/okstra_ctl/conformance.py

@@ -66,6 +66,11 @@ def _check_entry(entry: object, idx: int, errors: list[str]) -> None:
         return
     _check_nonempty_str(entry.get("stageKey"), f"{path}.stageKey", errors)
     _check_nonempty_str(entry.get("script"), f"{path}.script", errors)
+    script = entry.get("script")
+    # 실행 스크립트는 qa/scripts/ 하위 격리가 계약(implementation-planning §conformance);
+    # qa/ 루트는 manifest·result-*.json 데이터 사이드카 전용이다.
+    if isinstance(script, str) and script.strip() and "qa/scripts/" not in script:
+        errors.append(f"{path}.script must live under the task qa scripts dir (qa/scripts/), got {script!r}")
     _check_nonempty_str(entry.get("runCommand"), f"{path}.runCommand", errors)
     _check_nonempty_str(entry.get("passContract"), f"{path}.passContract", errors)
     req_ids = entry.get("requirementIds")

package/runtime/python/okstra_ctl/render.py

@@ -1127,6 +1127,14 @@ def render_run_manifest(run_manifest_path: str, ctx: dict) -> None:
         if isinstance(task_manifest.get("workflow"), dict)
         else {}
     )
+    # prepare 가 감지한 동시-run 사실의 영속 앵커. validator 는 이 prepare-측
+    # 기록이 있을 때만 no-team(teamCreate skipped) 경로를 legal 로 인정한다 —
+    # lead 의 team-state 자기 선언만으로는 열리지 않는다.
+    concurrent_run_stages = [
+        int(s)
+        for s in str(ctx.get("CONCURRENT_RUN_STAGES", "") or "").split(",")
+        if s.strip().isdigit()
+    ]
     payload = {
         "schemaVersion": "1.0",
         "okstraVersion": ctx.get("OKSTRA_VERSION", ""),
@@ -1173,6 +1181,10 @@ def render_run_manifest(run_manifest_path: str, ctx: dict) -> None:
         "validatorScriptPath": ctx.get("RUN_VALIDATOR_RELATIVE_PATH", ""),
         "claudeSessionId": ctx.get("CLAUDE_SESSION_ID", ""),
         "resumeCommandPath": ctx.get("CLAUDE_RESUME_COMMAND_RELATIVE_PATH", ""),
+        "concurrentRun": {
+            "detected": bool(concurrent_run_stages),
+            "activeStages": concurrent_run_stages,
+        },
         "workflowSnapshot": {
             "phaseSequence": workflow.get("phaseSequence", []),
             "currentPhase": workflow.get(
@@ -1674,7 +1686,11 @@ def inject_lead_prompt_computed_tokens(ctx: dict) -> None:
             "2. Before any dispatch, record in team-state:\n"
             '   `teamCreate: { attempted: false, status: "skipped",'
             f' reason: "concurrent-run", concurrentStages: [{concurrent_stages}] }}`.\n'
-            "3. Dispatch every worker with `run_in_background: true` and NO\n"
+            "3. Immediately after recording it, emit the checkpoint line\n"
+            "   `PROGRESS: phase-3-team-create skipped (concurrent-run)` — the\n"
+            "   phase-3 checkpoint is still required in no-team mode and the\n"
+            "   session-conformance validator fails the run without it.\n"
+            "4. Dispatch every worker with `run_in_background: true` and NO\n"
             "   `team_name` (the Phase 5 fallback). Worker completion is detected by\n"
             "   result-file polling, so analysis output is equivalent — only the\n"
             "   Teams split-pane view is lost."

package/runtime/python/okstra_token_usage/claude.py

@@ -243,6 +243,19 @@ def _needle_scan(jsonl_path: Path, entry: dict, needle_lower: str) -> bool:
     return False
 
 
+def _cached_needle_scan(jsonl_path: Path, cache: dict, needle_lower: str) -> bool:
+    """`cache['needles']` 의 per-needle cursor 를 유지하며 `_needle_scan` 수행.
+    파일당 MAX_NEEDLES 개까지 오래된 순으로 교체 보존한다."""
+    needles = cache.setdefault("needles", {})
+    entry = needles.get(needle_lower)
+    if entry is None:
+        entry = {"offset": 0, "found": False}
+        while len(needles) >= MAX_NEEDLES:
+            needles.pop(next(iter(needles)))
+        needles[needle_lower] = entry
+    return _needle_scan(jsonl_path, entry, needle_lower)
+
+
 def find_claude_team_sessions(
     cwd: Path,
     team_name: str,
@@ -276,14 +289,7 @@ def find_claude_team_sessions(
         for p in proj_dir.glob("*.jsonl"):
             if incremental:
                 cache = load_cache(p)
-                needles = cache.setdefault("needles", {})
-                entry = needles.get(needle_lower)
-                if entry is None:
-                    entry = {"offset": 0, "found": False}
-                    while len(needles) >= MAX_NEEDLES:
-                        needles.pop(next(iter(needles)))
-                    needles[needle_lower] = entry
-                if _needle_scan(p, entry, needle_lower):
+                if _cached_needle_scan(p, cache, needle_lower):
                     out[p.stem] = p
                 save_cache(p, cache)
             else:
@@ -294,3 +300,53 @@ def find_claude_team_sessions(
         if direct.is_file():
             out.setdefault(lead_sid, direct)
     return out
+
+
+_TEAM_TAG_NEEDLE = '"teamname":"'
+
+
+def find_claude_agent_sessions(
+    cwd: Path,
+    agent_prefixes: list[str],
+    projects_root: Path | None = None,
+    *,
+    incremental: bool = False,
+) -> dict[str, Path]:
+    """Map sessionId -> jsonl path for non-team sessions whose recorded
+    `agentName` matches one of ``agent_prefixes``.
+
+    no-team run(teamCreate `skipped`(concurrent-run) / `error` fallback)의
+    worker 세션은 team 태그가 없어 teamName needle 로는 발견되지 않는다. 대신
+    하네스가 dispatch `name` 인자로 기록하는 `agentName` 을 needle 로 찾되,
+    team 태그가 있는 세션은 제외한다 — 그것은 동시 team-mode run 의 worker 다.
+
+    같은 agentName 을 쓰는 다른 run 의 세션도 걸릴 수 있으므로, 호출자는 반드시
+    run 윈도우로 totals 를 스코핑하고 in-window 이벤트가 없는 세션을 버려야
+    한다. 윈도우가 겹치는 두 no-team run 이 같은 role 을 dispatch 한 경우의
+    교차 귀속은 구조적으로 분리 불가 — usage 블록의 sessionId 목록으로만
+    추적 가능하다.
+    """
+    proj_dir = claude_project_dir(cwd, projects_root)
+    out: dict[str, Path] = {}
+    if not proj_dir.is_dir():
+        return out
+    agent_needles = [f'"agentname":"{p.lower()}' for p in agent_prefixes if p]
+    if not agent_needles:
+        return out
+    for p in proj_dir.glob("*.jsonl"):
+        if incremental:
+            cache = load_cache(p)
+            matched = any(_cached_needle_scan(p, cache, n) for n in agent_needles)
+            team_tagged = matched and _cached_needle_scan(p, cache, _TEAM_TAG_NEEDLE)
+            save_cache(p, cache)
+        else:
+            matched = any(
+                _needle_scan(p, {"offset": 0, "found": False}, n)
+                for n in agent_needles
+            )
+            team_tagged = matched and _needle_scan(
+                p, {"offset": 0, "found": False}, _TEAM_TAG_NEEDLE
+            )
+        if matched and not team_tagged:
+            out[p.stem] = p
+    return out

package/runtime/python/okstra_token_usage/collect.py

@@ -7,7 +7,11 @@ from pathlib import Path
 from okstra_project.dirs import OKSTRA_RELATIVE
 
 from .blocks import na_block, usage_block
-from .claude import claude_session_totals, find_claude_team_sessions
+from .claude import (
+    claude_session_totals,
+    find_claude_agent_sessions,
+    find_claude_team_sessions,
+)
 from .codex import codex_session_total, find_codex_session
 from .gemini import find_gemini_session, gemini_session_total
 from .paths import claude_project_dir, utc_now
@@ -197,6 +201,31 @@ def collect(team_state_path: Path, project_root: Path | None = None, *,
             unattributed_sessions.append(sid)
             unattributed_totals.append(totals)
 
+    # no-team run (teamCreate skipped/concurrent-run, or error fallback) —
+    # worker 세션에 team 태그가 없어 위 needle 탐색이 비므로, agentName 기반
+    # 발견으로 보강한다. run 윈도우 밖 세션(in-window 이벤트 없음 = startedAt
+    # 부재)은 같은 agentName 의 타 run 세션이므로 버린다.
+    team_create_status = str((state.get("teamCreate") or {}).get("status", "")).strip()
+    if team_create_status in ("skipped", "error"):
+        worker_prefix_pool = [
+            prefix
+            for w in state.get("workers", [])
+            for prefix in match_prefixes(w.get("workerId") or "")
+        ]
+        agent_sessions = find_claude_agent_sessions(
+            cwd, worker_prefix_pool, incremental=incremental
+        )
+        for sid, path in agent_sessions.items():
+            if sid == lead_sid or sid in claude_sessions:
+                continue
+            totals = claude_session_totals(path, since=run_since, until=run_until,
+                                           incremental=incremental)
+            if not totals.get("startedAt"):
+                continue
+            agent = totals.get("agentName")
+            if agent:
+                by_agent.setdefault(agent, []).append((sid, path, totals))
+
     # Lead.
     if lead_path is not None:
         totals = claude_session_totals(lead_path, since=run_since, until=run_until,

package/runtime/validators/validate-run.py

@@ -334,8 +334,29 @@ def effective_run_task_type(run_manifest: dict, task_manifest: dict) -> str:
     ).strip()
 
 
+def _is_legal_concurrent_run_skip(
+    team_create: object, concurrent_run_authorized: bool
+) -> bool:
+    """prepare 가 run-manifest 에 동시-run 을 기록한 run 에서만, 렌더 게이트
+    ("Concurrent-run: no-team background")가 지시한 teamCreate skipped 형태를
+    legal 터미널 상태로 인정한다. lead 의 team-state 자기 선언만으로는(앵커
+    없이) 열리지 않는다 — 선언이 아닌 prepare-측 사실이 강제 근거다."""
+    if not concurrent_run_authorized or not isinstance(team_create, dict):
+        return False
+    return (
+        team_create.get("attempted") is False
+        and str(team_create.get("status", "")).strip() == "skipped"
+        and str(team_create.get("reason", "")).strip() == "concurrent-run"
+    )
+
+
 def validate_team_state(
-    team_state: dict, project_root: Path, contract: dict, failures: list[str]
+    team_state: dict,
+    project_root: Path,
+    contract: dict,
+    failures: list[str],
+    *,
+    concurrent_run_authorized: bool = False,
 ) -> None:
     artifacts = team_state.get("artifacts")
     if not isinstance(artifacts, dict):
@@ -377,12 +398,18 @@ def validate_team_state(
     )
     if any_dispatched:
         team_create = team_state.get("teamCreate")
-        if not isinstance(team_create, dict) or not team_create.get("attempted"):
+        if _is_legal_concurrent_run_skip(team_create, concurrent_run_authorized):
+            pass
+        elif not isinstance(team_create, dict) or not team_create.get("attempted"):
             failures.append(
                 "team-state.teamCreate.attempted must be true once any worker has "
                 "been dispatched (status in completed/timeout/error/in-progress). "
                 "Phase 3 (TeamCreate) was skipped — workers ran in-process without "
-                "the Teams split-pane surface. See agents/SKILL.md Phase 3."
+                "the Teams split-pane surface. See agents/SKILL.md Phase 3. "
+                "(The no-team concurrent-run path is legal ONLY when the "
+                "run-manifest carries prepare-recorded `concurrentRun.detected: "
+                'true` AND team-state records `teamCreate: { attempted: false, '
+                'status: "skipped", reason: "concurrent-run" }`.)'
             )
         else:
             tc_status = str(team_create.get("status", "")).strip()
@@ -2114,7 +2141,16 @@ def main() -> int:
     if autofix_state == "accuracy-failed":
         failures.extend(autofix_messages)
     contract = extract_contract(run_manifest, task_manifest, failures)
-    validate_team_state(team_state, project_root, contract, failures)
+    concurrent_run_authorized = bool(
+        (run_manifest.get("concurrentRun") or {}).get("detected")
+    )
+    validate_team_state(
+        team_state,
+        project_root,
+        contract,
+        failures,
+        concurrent_run_authorized=concurrent_run_authorized,
+    )
     # Schema validation runs BEFORE markdown substring checks: if the
     # data.json is well-formed, the rendered markdown is guaranteed to
     # contain every required section. Substring checks below are a

package/runtime/validators/validate_session_conformance.py

@@ -271,7 +271,13 @@ def _check_progress_checkpoints(
         str(w.get("status", "")).strip() in _DISPATCHED_STATUSES for w in workers
     )
     require("phase-2-prompts", bool(workers), "before any Write to assigned prompt paths")
-    require("phase-3-team-create", any_dispatched, "immediately before the TeamCreate call")
+    require(
+        "phase-3-team-create",
+        any_dispatched,
+        "immediately before the TeamCreate call — or, in the authorized no-team "
+        "concurrent-run path, the `phase-3-team-create skipped (concurrent-run)` "
+        "variant emitted right after recording teamCreate skipped in team-state",
+    )
     _check_worker_checkpoint_lines(by_phase, analysis_workers, errors)
     require(
         "phase-5.5-convergence",