okstra 0.60.0 → 0.60.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "okstra",
-  "version": "0.60.0",
+  "version": "0.60.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.60.0",
-  "builtAt": "2026-06-09T03:55:13.411Z",
+  "package": "0.60.2",
+  "builtAt": "2026-06-09T06:03:11.725Z",
   "repoRoot": "/home/runner/work/okstra/okstra"
 }

package/runtime/python/okstra_ctl/wizard.py

@@ -1457,11 +1457,14 @@ def _pick_snippet(value: str, style: str) -> str:
 def _build_optional_cached_pick(state: WizardState, spec: _OptionalCachedPickSpec) -> Prompt:
     suggestion = spec.suggest(state)
     t = _p(state.workspace_root, spec.prompt_key)
-    options: list[Option] = [_opt(PICK_SKIP, t["options"][PICK_SKIP])]
+    # 추천(이전 directive·siblings·최근 리포트·프로젝트 기본)을 가장 먼저 노출하고,
+    # '건너뛰기'는 중간, '직접 입력'은 항상 마지막에 둔다 (run-prompt 추천 규칙).
+    options: list[Option] = []
     if suggestion:
         snippet = _pick_snippet(suggestion, spec.snippet_style)
         options.append(_opt(spec.recommend_token, t["labels"][spec.label_key].format(snippet=snippet)))
         setattr(state, spec.cache_attr, suggestion)
+    options.append(_opt(PICK_SKIP, t["options"][PICK_SKIP]))
     options.append(_opt(PICK_TYPE_CUSTOM, t["options"][PICK_TYPE_CUSTOM]))
     return Prompt(
         step=spec.step, kind="pick",
@@ -1625,9 +1628,13 @@ def _critic_provider_label(provider: str, t: dict) -> str:
 def _build_critic_pick(state: WizardState) -> Prompt:
     t = _p(state.workspace_root, "critic_pick")
     off_label = t["options"].get("off", "off")
-    options = [_opt("off", off_label)]
-    for provider in _critic_provider_choices():
-        options.append(_opt(provider, _critic_provider_label(provider, t)))
+    # 추천(claude critic)을 가장 먼저, 'off'(critic 미사용)를 마지막에 둔다
+    # (run-prompt 추천 규칙: 추천이 항상 첫 옵션).
+    options = [
+        _opt(provider, _critic_provider_label(provider, t))
+        for provider in _critic_provider_choices()
+    ]
+    options.append(_opt("off", off_label))
     return Prompt(
         step=S_CRITIC_PICK, kind="pick",
         label=t["label"],
@@ -2212,14 +2219,16 @@ STEPS: list[Step] = [
                             and S_REPORT_WRITER_MODEL not in s.answered),
          build=_build_report_writer_model, submit=_submit_report_writer_model,
          owns=("report_writer_model",)),
+    # directive(이번 run 의 추가 지시)는 기본값/커스터마이즈와 무관하게 항상
+    # 묻는다 — 매 run 마다 줄 수 있는 입력이므로 'Use defaults' 분기 뒤에 숨기지
+    # 않는다. (use_defaults is not None: defaults_or_custom 답 이후에만 등장)
     Step(S_DIRECTIVE_PICK,
-         applies=lambda s: (s.use_defaults is False
-                            and S_DIRECTIVE_PICK not in s.answered),
+         applies=lambda s: (S_DIRECTIVE_PICK not in s.answered
+                            and s.use_defaults is not None),
          build=_build_directive_pick, submit=_submit_directive_pick,
          owns=("directive", "directive_pending_text")),
     Step(S_DIRECTIVE,
-         applies=lambda s: (s.use_defaults is False
-                            and s.directive_pending_text
+         applies=lambda s: (s.directive_pending_text
                             and S_DIRECTIVE not in s.answered),
          build=_build_directive, submit=_submit_directive,
          owns=("directive", "directive_pending_text")),
@@ -2516,6 +2525,7 @@ def confirmation_block(state: WizardState) -> str:
     lines: list[str] = [header]
     lines.append(f"  task-type     : {state.task_type}")
     lines.append(f"  task-key      : {state.task_group}/{state.task_id}")
+    lines.append(f"  brief         : {state.brief_path or '(none)'}")
     if state.reuse_worktree:
         lines.append("  base-ref      : (reusing existing worktree)")
     else:
@@ -2538,6 +2548,8 @@ def confirmation_block(state: WizardState) -> str:
     if state.report_writer_model:
         lines.append(f"  report-writer : {state.report_writer_model}")
     lines.append(f"  directive     : {state.directive or '(none)'}")
+    if state.related_tasks_raw:
+        lines.append(f"  related-tasks : {state.related_tasks_raw}")
     if state.task_type in ("requirements-discovery", "error-analysis", "implementation-planning", "final-verification"):
         lines.append(f"  critic        : {state.critic or '(off)'}")
     if state.task_type in _STAGE_SCOPED_TASK_TYPES:

package/runtime/python/okstra_token_usage/claude.py

@@ -7,8 +7,21 @@ from .jsonl_io import iter_jsonl
 from .paths import claude_project_dir
 
 
-def claude_session_totals(jsonl_path: Path) -> dict:
-    """Return totals + agentName + assistant model + time window for a Claude session jsonl."""
+def claude_session_totals(
+    jsonl_path: Path, *, since: str | None = None, until: str | None = None
+) -> dict:
+    """Return totals + agentName + assistant model + time window for a Claude session jsonl.
+
+    ``since`` / ``until`` are ISO-8601 timestamp strings (UTC ``...Z``). When
+    given, only records whose ``timestamp`` falls within ``[since, until]`` are
+    counted toward tokens / tool_uses / duration. This is the run-scoping seam:
+    an **in-session** lead writes its run into the user's whole-session jsonl,
+    so without a window the totals swallow every unrelated turn (observed:
+    lead billed 1.7억 tokens / $416 / 3h for a single requirements-discovery
+    run). ``agentName`` / ``model`` are session metadata and are read from the
+    whole file regardless of the window. Records without a timestamp are kept
+    (conservative — never silently drop usage when we can't place it in time).
+    """
     input_t = output_t = cache_create_t = cache_read_t = 0
     cache_create_5m_t = cache_create_1h_t = 0
     tool_uses = 0
@@ -20,6 +33,12 @@ def claude_session_totals(jsonl_path: Path) -> dict:
         if agent_name is None and rec.get("agentName"):
             agent_name = rec["agentName"]
         msg = rec.get("message") or {}
+        ts = rec.get("timestamp") or (msg.get("timestamp") if isinstance(msg, dict) else None)
+        in_window = not (ts and ((since and ts < since) or (until and ts > until)))
+        if rec.get("type") == "assistant" and model is None and msg.get("model"):
+            model = msg["model"]
+        if not in_window:
+            continue
         usage = msg.get("usage")
         if usage:
             input_t += usage.get("input_tokens", 0) or 0
@@ -39,12 +58,9 @@ def claude_session_totals(jsonl_path: Path) -> dict:
             else:
                 cache_create_5m_t += cc_total
         if rec.get("type") == "assistant":
-            if model is None and msg.get("model"):
-                model = msg["model"]
             for block in (msg.get("content") or []):
                 if isinstance(block, dict) and block.get("type") == "tool_use":
                     tool_uses += 1
-        ts = rec.get("timestamp") or (msg.get("timestamp") if isinstance(msg, dict) else None)
         if ts:
             if first_ts is None or ts < first_ts:
                 first_ts = ts
@@ -58,7 +74,12 @@ def claude_session_totals(jsonl_path: Path) -> dict:
             duration_ms = max(0, int((b - a).total_seconds() * 1000))
         except ValueError:
             duration_ms = 0
-    total = input_t + output_t + cache_create_t + cache_read_t
+    # '처리 토큰' total 에서 cache_read 는 제외한다. claude 는 매 턴 직전까지의
+    # 컨텍스트 전체를 캐시에서 재읽기(cache_read)하므로, 단순 합산하면 같은 토큰을
+    # 턴 수만큼 중복 카운트해 처리량이 비현실적으로 부풀려진다(예: in-session
+    # lead 가 1.7억으로 표시됨). cache_read 는 cacheReadTokens 로 따로 노출되고,
+    # 비용은 pricing 이 0.1x 단가로 별도 반영하므로 total 에서 빼도 비용은 불변.
+    total = input_t + output_t + cache_create_t
     return {
         "totalTokens": total,
         "inputTokens": input_t,

package/runtime/python/okstra_token_usage/collect.py

@@ -2,7 +2,7 @@
 from __future__ import annotations
 
 import json
-from datetime import datetime
+from datetime import datetime, timezone
 from pathlib import Path
 from okstra_project.dirs import OKSTRA_RELATIVE
 
@@ -86,9 +86,61 @@ def _aggregate_totals(items: list[dict]) -> dict:
     return aggregate
 
 
+def _run_window_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 을 집어 윈도우가 한 달로 벌어짐)."""
+    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"
+    try:
+        return json.loads(p.read_text()).get("createdAt")
+    except (OSError, json.JSONDecodeError):
+        return None
+
+
+def _run_end_estimate(run_dir: Path, suffix: str) -> str | None:
+    """run 종료 근사 — 같은 run 의 status 산출물 mtime(reconcile 후 고정, Phase 7
+    재렌더로도 바뀌지 않음). 완료 전(status 부재)이면 None."""
+    p = run_dir / "status" / f"final-{suffix}.status"
+    try:
+        mtime = p.stat().st_mtime
+    except OSError:
+        return None
+    return datetime.fromtimestamp(mtime, tz=timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ")
+
+
+def _resolve_run_window(team_state_path: Path, state: dict) -> tuple[str | None, str | None]:
+    """이 run 의 [시작, 종료] ISO 윈도우.
+
+    in-session lead 는 자기 run 을 사용자의 *세션 전체* jsonl 에 기록하므로,
+    윈도우 없이 합산하면 무관한 모든 턴(다른 작업·대화)이 lead 토큰·시간에
+    섞여 폭증한다(관측: requirements-discovery 한 run 에 lead 1.7억 토큰 /
+    $416 / 3h). 토큰 집계를 이 윈도우로 스코핑해 그 run 분만 센다. 시작 =
+    이 run 의 run-manifest createdAt, 종료 = team-state.runEndedAt → 이 run 의
+    status mtime → 현재 시각(아직 진행 중) 순으로 해소한다. 접미사를 못 뽑으면
+    (None, None) — 윈도우 없이 전체를 세는 기존 동작으로 안전 폴백."""
+    suffix = _run_window_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)
+    until = state.get("runEndedAt") or _run_end_estimate(run_dir, suffix) or utc_now()
+    return since, until
+
+
 def collect(team_state_path: Path, project_root: Path | None = None) -> dict:
     state = json.loads(team_state_path.read_text())
     cwd = project_root or _infer_project_root(team_state_path, state)
+    run_since, run_until = _resolve_run_window(team_state_path, state)
     task_key = state.get("taskKey", "")
     # Prefer the team name actually persisted in team-state (set during Phase 3
     # when TeamCreate succeeded); only fall back to the `okstra-<task-id>`
@@ -130,7 +182,7 @@ def collect(team_state_path: Path, project_root: Path | None = None) -> dict:
         if sid == lead_sid:
             lead_path = path
             continue
-        totals = claude_session_totals(path)
+        totals = claude_session_totals(path, since=run_since, until=run_until)
         agent = totals.get("agentName")
         if agent:
             by_agent.setdefault(agent, []).append((sid, path, totals))
@@ -139,7 +191,7 @@ def collect(team_state_path: Path, project_root: Path | None = None) -> dict:
 
     # Lead.
     if lead_path is not None:
-        totals = claude_session_totals(lead_path)
+        totals = claude_session_totals(lead_path, since=run_since, until=run_until)
         state["leadUsage"] = usage_block(totals, source="claude-jsonl")
         state["leadUsage"]["sessionId"] = lead_sid
     else: