okstra 0.186.4 → 0.186.6

package/runtime/python/okstra_ctl/plan_items.py

@@ -649,15 +649,24 @@ def advisory_plan_body_gating(
     return not (isinstance(items, list) and items)
 
 
+CRITIC_WORKER_ID = "critic-worker"
+
+
+def is_critic_worker(worker: str) -> bool:
+    """본문 동수를 가르는 critic 표인지."""
+    name = str(worker or "").strip().lower()
+    return name == CRITIC_WORKER_ID or name.endswith("-critic-worker")
+
+
 def tie_vote_item_ids(
     items: Sequence[Mapping[str, Any]],
     ledger: Mapping[str, str] | None,
     tied_ids: Sequence[str],
 ) -> list[str]:
-    """needs-reverify 동수 항목만 세 번째 표에 보낸다.
+    """needs-reverify 동수 항목만 critic 에 보낸다.
 
     첫 라운드 큐나 self-fix 재검증 큐와 섞지 않는다. 동수가 없으면 빈 목록이고
-    세 번째 워커는 뜨지 않는다.
+    critic 은 이 배치를 띄우지 않는다.
     """
     allowed = set(dispatch_item_ids(items, ledger))
     queue: list[str] = []
@@ -686,6 +695,13 @@ ENVIRONMENT_CORRECTION_PREAMBLE = (
     "a valid answer to any of them.\n"
 )
 
+CRITIC_TIE_PREAMBLE = (
+    "You are the critic tie-break. Only the items below are in dispute. "
+    "Each item already has one AGREE and one DISAGREE from the two plan-body "
+    "verifiers. Decide the item: AGREE or DISAGREE(<kind>). Your verdict "
+    "settles the split. Do not re-open items that are not listed.\n"
+)
+
 
 def item_cites_build_command(item: Mapping[str, Any]) -> bool:
     """이 항목이 계획 워크트리에서 실행 불가한 빌드/테스트 명령을 인용하는가."""
@@ -775,10 +791,15 @@ def blanket_unverifiable_workers(
 
 def _is_tie(item: Mapping[str, Any]) -> bool:
     tokens = [
-        token for _worker, token in _item_votes(item) if not _error_verdict(token)
+        token
+        for worker, token in _item_votes(item)
+        if not _error_verdict(token) and not is_critic_worker(worker)
     ]
     if len(tokens) < 2:
         return False
+    if any(is_critic_worker(worker) and not _error_verdict(token)
+           for worker, token in _item_votes(item)):
+        return False
     disagree = sum(1 for token in tokens if token.upper().startswith("DISAGREE"))
     agree = sum(1 for token in tokens if token.upper() in {"AGREE", "SUPPLEMENT"})
     return disagree == agree and disagree > 0
@@ -828,10 +849,10 @@ def next_dispatch(
     )
     if ties:
         return NextDispatch(
-            kind="queue-reverify",
-            workers=tuple(sorted(_worker_vote_map(items))),
+            kind="critic-tie",
+            workers=(CRITIC_WORKER_ID,),
             item_ids=ties,
-            reason="unsettled tie on a blocking kind",
+            reason="unsettled analyser tie; critic settles",
         )
     return NextDispatch(
         kind="none", workers=(), item_ids=(),
@@ -843,3 +864,8 @@ def correction_prompt_text(queue_markdown: str) -> str:
     """시정 프롬프트. 환경 예외 단락이 큐보다 앞이다."""
     return f"{ENVIRONMENT_CORRECTION_PREAMBLE.rstrip()}\n\n{queue_markdown.lstrip()}"
 
+
+def critic_tie_prompt_text(queue_markdown: str) -> str:
+    """동수 critic 프롬프트. 가르는 지시가 큐보다 앞이다."""
+    return f"{CRITIC_TIE_PREAMBLE.rstrip()}\n\n{queue_markdown.lstrip()}"
+

package/runtime/python/okstra_ctl/plan_items_cli.py

@@ -30,6 +30,7 @@ from .plan_items import (
     advisory_plan_body_gating,
     content_hash,
     correction_prompt_text,
+    critic_tie_prompt_text,
     dispatch_item_ids,
     extract_plan_items,
     next_dispatch,
@@ -154,7 +155,7 @@ def _parser() -> argparse.ArgumentParser:
     )
     prepare.add_argument(
         "--tie-vote", action="store_true",
-        help="dispatch queue is the needs-reverify ties in --state, nothing else",
+        help="dispatch queue is the needs-reverify ties in --state for critic-worker",
     )
     prompt = commands.add_parser("prompt")
     prompt.add_argument("--run-manifest", type=Path, required=True)
@@ -348,6 +349,11 @@ def _prepare(args: argparse.Namespace) -> dict[str, Any]:
         args.run_manifest,
         **_queue_kwargs(args),
     )
+    if getattr(args, "tie_vote", False):
+        envelope["dispatchKind"] = "critic-tie"
+        envelope["tieSplits"] = _tie_splits_from_state(
+            getattr(args, "state", None), envelope["dispatchQueue"],
+        )
     gating = not advisory_plan_body_gating(_planning(source), envelope["items"])
     _sync_task_manifest_gating(args.run_manifest, gating)
     write_json_atomic(output, envelope)
@@ -500,6 +506,44 @@ def _render_payload(item_id: str, payload: object) -> list[str]:
     return rows
 
 
+def _render_analyser_split(verdicts: object) -> str:
+    """동수 항목에 이미 찍힌 분석자 표를 critic 프롬프트에 붙인다."""
+    if not isinstance(verdicts, list):
+        return ""
+    rows: list[str] = []
+    for verdict in verdicts:
+        if not isinstance(verdict, Mapping):
+            continue
+        worker = str(verdict.get("worker") or "").strip()
+        token = str(verdict.get("verdict") or "").strip()
+        if not worker or not token:
+            continue
+        kind = str(verdict.get("breakageKind") or "").strip()
+        label = f"{token}({kind})" if kind else token
+        rows.append(f"- `{worker}`: `{label}`\n")
+    if not rows:
+        return ""
+    return "Analyser split:\n" + "".join(rows)
+
+
+def _tie_splits_from_state(
+    state_path: Path | None, queue: Sequence[str],
+) -> dict[str, list[Any]]:
+    if state_path is None or not state_path.is_file():
+        return {}
+    items = _state_plan_body_items(_load_json_object(state_path), state_path)
+    allowed = set(queue)
+    splits: dict[str, list[Any]] = {}
+    for row in items:
+        if not isinstance(row, Mapping):
+            continue
+        item_id = str(row.get("id") or "")
+        verdicts = row.get("verdicts")
+        if item_id in allowed and isinstance(verdicts, list):
+            splits[item_id] = verdicts
+    return splits
+
+
 def _prompt(args: argparse.Namespace) -> str:
     envelope = _load_json_object(
         _prepared_items_path(args.run_manifest, require_regular=True)
@@ -520,7 +564,17 @@ def _prompt(args: argparse.Namespace) -> str:
         rows.extend((f"\n## Plan item {index}\n", line("Item ID", item_id),
                      line("Subject", item.get("subject"))))
         rows.extend(_render_payload(item_id, item.get("payload")))
-    return "".join(rows)
+        split = _render_analyser_split(
+            (envelope.get("tieSplits") or {}).get(item_id) if isinstance(
+                envelope.get("tieSplits"), Mapping
+            ) else None
+        )
+        if split:
+            rows.append(split)
+    body = "".join(rows)
+    if envelope.get("dispatchKind") == "critic-tie":
+        return critic_tie_prompt_text(body)
+    return body
 
 
 def _validate_prepared(args: argparse.Namespace) -> dict[str, Any]:
@@ -988,7 +1042,7 @@ def _append_item_verdicts(
     round_number: int,
     project_root: Path | None,
 ) -> None:
-    """동수 항목의 세 번째 표. 이미 투표한 워커는 거부한다."""
+    """동수 항목의 critic 표. 이미 투표한 워커는 거부한다."""
     stamped = _stamped_verdicts(incoming, round_number, project_root)
     existing = item.get("verdicts")
     current = existing if isinstance(existing, list) else []

package/runtime/python/okstra_ctl/render_final_report.py

@@ -557,7 +557,9 @@ def _ai_markdown_context(data: dict, schema: dict | None) -> dict:
     context["aiTaskProperty"] = TASK_TYPE_DATA_PROPERTY.get(task_type, "")
     context["aiTaskTemplate"] = _markdown_task_template(task_type)
     context["aiBlockingIds"] = progress_blocking_ids(
-        data.get("clarificationItems", []), USER_INPUT_BLOCKS
+        data.get("clarificationItems", []),
+        USER_INPUT_BLOCKS,
+        report_data=data,
     )
     sections = ReportSections(data, schema or {})
     context["md"] = sections.section

package/runtime/python/okstra_ctl/report_assembly.py

@@ -9,7 +9,11 @@ from pathlib import Path
 from typing import Any, Callable, Mapping, Sequence
 
 from .agent_activity import agent_activity_rows
-from .clarification_items import clarification_disposition, row_blocks_progress
+from .clarification_items import (
+    clarification_disposition,
+    incorporated_clarification_ids,
+    row_blocks_progress,
+)
 from .final_report_schema import load_schema_version, validate
 from .report_inputs import ReportInputPath, report_input_paths, uses_report_contract_v3
 from .json_boundary import JsonBoundaryError, load_owned_object, serialize_owned_object
@@ -131,10 +135,65 @@ def _clarifications(
         if not isinstance(row, Mapping):
             _fail("lead", path, f"activeClarifications[{index}]", "must be an object")
     activity_by_id = {row.get("activityId"): row for row in activities}
-    return [
+    rows = [
         _clarification_row(row, activity_by_id, path)
         for row in active
     ]
+    rows.extend(_carried_clarification_rows(ledger, {row.get("id") for row in rows}, path))
+    return rows
+
+
+def _carried_clarification_rows(
+    ledger: Mapping[str, Any], seen_ids: set[object], path: Path,
+) -> list[dict[str, Any]]:
+    """이월 결정은 active 질문이 아니다. 이번 런 활동 원장을 요구하지 않는다."""
+    carried = ledger.get("carriedDecisions")
+    if not isinstance(carried, list):
+        return []
+    rows: list[dict[str, Any]] = []
+    seen = set(seen_ids)
+    for index, entry in enumerate(carried):
+        if not isinstance(entry, Mapping):
+            _fail("lead", path, f"carriedDecisions[{index}]", "must be an object")
+        decision = entry.get("decision")
+        if not isinstance(decision, Mapping):
+            _fail(
+                "lead", path, f"carriedDecisions[{index}].decision",
+                "must be an object",
+            )
+        cid = decision.get("id")
+        if cid in seen:
+            continue
+        rows.append(_carried_clarification_row(decision))
+        seen.add(cid)
+    return rows
+
+
+def _carried_clarification_row(source: Mapping[str, Any]) -> dict[str, Any]:
+    row = {
+        key: source[key]
+        for key in (
+            "id", "ticketId", "kind", "statement", "expectedForm", "blocks",
+            "origin", "userConfirmation", "options",
+        )
+        if key in source
+    }
+    if "approval" in source:
+        row["approvalContext"] = source["approval"]
+    resolution = source.get("resolutionInput")
+    if not isinstance(resolution, Mapping):
+        row["status"] = "resolved"
+        return row
+    row.update(
+        status="resolved",
+        userInput=resolution.get("userText", ""),
+        resolution={
+            "disposition": resolution.get("disposition"),
+            "userText": resolution.get("userText"),
+            "checkRefs": list(resolution.get("checkRefs") or []),
+        },
+    )
+    return row
 
 
 def _project_relative(project_root: Path, path: Path) -> str:
@@ -330,10 +389,13 @@ def _attach_metadata(data: dict[str, Any], manifest: Mapping[str, Any]) -> None:
     created = str(manifest.get("runTimestamp") or manifest.get("createdAt") or "unknown")
     data["meta"] = {"reportLanguage": str(manifest.get("reportLanguage") or "en")}
     clarifications = data.get("clarificationItems") or []
+    incorporated = incorporated_clarification_ids(data)
     blocked = any(
         isinstance(row, Mapping)
         and row_blocks_progress(
-            str(row.get("status") or ""), clarification_disposition(row)
+            str(row.get("status") or ""),
+            clarification_disposition(row),
+            incorporated=str(row.get("id") or "") in incorporated,
         )
         for row in clarifications
     )

package/runtime/python/okstra_ctl/report_html/run_usage.py

@@ -38,6 +38,10 @@ def _agent_row(row: dict) -> dict[str, str]:
     """
     cli_tokens = _number(row.get("cliTotalTokens")) or 0
     cli_cost = _number(row.get("cliCostUsd")) or 0
+    cost = _number(row.get("costUsd"))
+    if cost is None and cli_cost:
+        cost = cli_cost
+        cli_cost = 0
     return {
         "agent": str(row.get("agent") or ""),
         "role": str(row.get("role") or ""),
@@ -46,7 +50,7 @@ def _agent_row(row: dict) -> dict[str, str]:
         "rawTokens": format_int(row.get("totalTokens")),
         "cacheReadTokens": format_int(row.get("cacheReadTokens")),
         "billableTokens": format_int(row.get("billableTokens")),
-        "cost": format_usd(row.get("costUsd")),
+        "cost": format_usd(cost),
         "duration": format_duration_ms(row.get("durationMs")),
         "cliTokens": format_int(cli_tokens) if cli_tokens else "",
         "cliCost": format_usd(cli_cost) if cli_cost else "",

package/runtime/python/okstra_ctl/report_projections.py

@@ -7,6 +7,7 @@ from typing import Any, Mapping, Sequence
 
 from .design_surfaces import DesignSurfaceTrigger, detect_design_surfaces
 from .report_contract import execution_roles_from_manifest
+from .usage_cells import duration_ms_from_bounds
 
 
 class ReportProjectionError(ValueError):
@@ -48,23 +49,58 @@ def _agent_label(row: Mapping[str, Any]) -> str:
     return _AGENT_LABELS.get(value.lower(), value)
 
 
-def _execution_row(row: Mapping[str, Any], *, lead: bool = False) -> dict[str, Any]:
+def _execution_row(
+    row: Mapping[str, Any],
+    *,
+    lead: bool = False,
+    usage: Mapping[str, Any] | None = None,
+) -> dict[str, Any]:
     role = _text(row.get("role"), "Okstra lead" if lead else "Worker")
+    source = usage if usage is not None else (
+        row.get("usage") if isinstance(row.get("usage"), Mapping) else {}
+    )
+    status = _status(row.get("status"))
+    if lead and status == "not-run" and _usage_ran(source):
+        status = "completed"
     result = {
         "agent": _agent_label(row),
         "role": role,
         "model": _text(row.get("model") or row.get("modelExecutionValue"), "unknown"),
-        "status": _status(row.get("status")),
+        "status": status,
         "summary": _text(
             row.get("summary") or row.get("reason"),
             "Run coordination recorded by team state." if lead
             else "Worker execution recorded by team state.",
         ),
     }
-    _populate_usage(result, row.get("usage") or {})
+    _populate_usage(result, source)
+    if not result.get("durationMs"):
+        duration = _row_duration_ms(row, source)
+        if duration is not None:
+            result["durationMs"] = duration
     return result
 
 
+def _usage_ran(usage: Mapping[str, Any]) -> bool:
+    if usage.get("source") == "unavailable":
+        return False
+    tokens = usage.get("totalTokens") or usage.get("cliTotalTokens") or 0
+    duration = usage.get("durationMs") or 0
+    return bool(tokens or duration)
+
+
+def _row_duration_ms(row: Mapping[str, Any], usage: Mapping[str, Any]) -> int | None:
+    value = usage.get("durationMs") if usage.get("source") != "unavailable" else None
+    if isinstance(value, (int, float)) and not isinstance(value, bool) and value > 0:
+        return int(value)
+    duration = duration_ms_from_bounds(row.get("startedAt"), row.get("endedAt"))
+    if duration is not None:
+        return duration
+    if usage.get("source") == "unavailable":
+        return None
+    return duration_ms_from_bounds(usage.get("startedAt"), usage.get("endedAt"))
+
+
 def _populate_usage(row: dict[str, Any], usage: object) -> None:
     source = usage if isinstance(usage, Mapping) else {}
     mapping = {
@@ -92,11 +128,16 @@ def project_execution(
         "status": "completed",
         "role": "Okstra lead",
     }
+    lead_usage = team_state.get("leadUsage")
     workers = team_state.get("workers")
     worker_rows = workers if isinstance(workers, list) else []
     result: dict[str, Any] = {
         "executionStatus": [
-            _execution_row(lead_row, lead=True),
+            _execution_row(
+                lead_row,
+                lead=True,
+                usage=lead_usage if isinstance(lead_usage, Mapping) else None,
+            ),
             *[
                 _execution_row(row)
                 for row in worker_rows

package/runtime/python/okstra_ctl/run.py

@@ -304,7 +304,7 @@ def _blocking_gate_survives_user_decision(data: dict, gate: str) -> bool:
         for row in rows
     )
     return (not has_approval_row) or bool(
-        progress_blocking_ids(rows, APPROVAL_BLOCKS)
+        progress_blocking_ids(rows, APPROVAL_BLOCKS, report_data=data)
     )
 
 
@@ -1723,7 +1723,7 @@ def _normalize_prepare_model_selection(
     profile_file: Path,
 ) -> tuple[CanonicalModelSelection, RoleProfile]:
     try:
-        _validate_critic_choice(inp.critic)
+        _validate_critic_choice(inp.critic, inp.task_type)
         profile = load_role_profile(profile_file)
         profile_workers = resolve_profile_workers(profile_file)
         has_worker_models = bool(
@@ -2502,7 +2502,7 @@ def _resolve_model_bindings(
 ) -> _ModelBindings:
     """worker 모델 + critic 선택 + executor 바인딩을 한 묶음으로 해소·검증한다."""
     m = _resolve_worker_models(inp, workers, context)
-    critic_choice = _validate_critic_choice(inp.critic)
+    critic_choice = _validate_critic_choice(inp.critic, inp.task_type)
     critic_model_execution = ""
     critic_meta = None
     if critic_choice in provider_ids("critic"):
@@ -2581,12 +2581,27 @@ def _resolve_model_bindings(
     )
 
 
-def _validate_critic_choice(raw_value: str) -> str:
+_CRITIC_REQUIRED_TASK_TYPES = frozenset({
+    "requirements-discovery",
+    "error-analysis",
+    "implementation-planning",
+    "final-verification",
+})
+
+
+def _validate_critic_choice(raw_value: str, task_type: str = "") -> str:
     critic_choice = (raw_value or "").strip().lower()
-    allowed_critics = ["", "off", *provider_ids("critic")]
+    allowed_critics = ["", *provider_ids("critic")]
+    if critic_choice == "off":
+        if task_type in _CRITIC_REQUIRED_TASK_TYPES:
+            raise PrepareError(
+                "--critic off is not allowed; critic is required "
+                f"for {task_type}"
+            )
+        return "off"
     if critic_choice not in allowed_critics:
         raise PrepareError(
-            f"--critic must be one of: {', '.join(allowed_critics[1:])} "
+            f"--critic must be one of: {', '.join(provider_ids('critic'))} "
             f"(got: {critic_choice!r})"
         )
     return critic_choice

package/runtime/python/okstra_ctl/usage_cells.py

@@ -7,6 +7,7 @@ nothing would look like, which is a different claim from "not measured".
 """
 from __future__ import annotations
 
+from datetime import datetime
 from typing import Any
 
 
@@ -28,6 +29,20 @@ def format_usd(value: Any) -> str:
         return "--"
 
 
+def duration_ms_from_bounds(started_at: object, ended_at: object) -> int | None:
+    """두 ISO 시각 사이의 벽시계 ms. 없거나 파싱 불가면 None."""
+    if not isinstance(started_at, str) or not isinstance(ended_at, str):
+        return None
+    if not started_at or not ended_at:
+        return None
+    try:
+        start = datetime.fromisoformat(started_at.replace("Z", "+00:00"))
+        end = datetime.fromisoformat(ended_at.replace("Z", "+00:00"))
+    except ValueError:
+        return None
+    return max(0, int((end - start).total_seconds() * 1000))
+
+
 def format_duration_ms(value: Any) -> str:
     if value is None or not isinstance(value, (str, int, float)):
         return "--"

package/runtime/python/okstra_ctl/user_response.py

@@ -1960,21 +1960,33 @@ def finalize_response(transaction_id: str) -> Path:
 
 def format_list_view(rows: list[dict[str, Any]]) -> str:
     lines = ["USER RESPONSE TASKS", f"Count: {len(rows)}"]
+    picker: list[str] = ["", "Picker:"]
     for index, row in enumerate(rows, start=1):
         status = "unreadable" if row.get("unreadable") else "ready"
+        task_key = row.get("canonicalTaskKey", row.get("taskKey", ""))
+        task_type = row.get("taskType", "")
+        seq = row.get("seq", "")
+        report = row.get("normalizedReportPath", row.get("reportPath", ""))
+        open_items = row.get("openBlockerCount", 0)
         lines.extend([
             "",
             f"[{index}]",
-            f"Task key: {row.get('canonicalTaskKey', row.get('taskKey', ''))}",
-            f"Task type: {row.get('taskType', '')}",
-            f"Run sequence: {row.get('seq', '')}",
-            f"Report: {row.get('normalizedReportPath', row.get('reportPath', ''))}",
-            f"Open items: {row.get('openBlockerCount', 0)}",
+            f"Task key: {task_key}",
+            f"Task type: {task_type}",
+            f"Run sequence: {seq}",
+            f"Report: {report}",
+            f"Open items: {open_items}",
             f"Open approval items: {row.get('openApprovalCount', 0)}",
             f"Plan decision required: {'yes' if row.get('planDecisionRequired') else 'no'}",
             f"Status: {status}",
         ])
-    return "\n".join(lines) + "\n"
+        picker.extend([
+            f"- Label: {task_key}  ·  {task_type}  ·  seq {seq}",
+            f"  Description: Open items: {open_items}. Report: {report}",
+        ])
+    if len(rows) == 0:
+        return "\n".join(lines) + "\n"
+    return "\n".join(lines + picker) + "\n"
 
 
 def _option_view(option: Mapping[str, Any], index: int) -> list[str]:
@@ -1996,6 +2008,59 @@ def _option_view(option: Mapping[str, Any], index: int) -> list[str]:
     ]
 
 
+def _picker_scope(option: Mapping[str, Any]) -> str:
+    """HTML `<select>` 와 같은 범위 축. reach 가 있으면 그걸, 없으면 scopeImpact."""
+    reach = str(option.get("reach") or "").strip()
+    effects = option.get("scopeEffects")
+    extra = (
+        ", ".join(str(item) for item in effects)
+        if isinstance(effects, list) and effects
+        else ""
+    )
+    if reach:
+        return f"{reach}, {extra}" if extra else reach
+    scope = option.get("scopeImpact")
+    if isinstance(scope, list) and scope:
+        return ", ".join(str(item) for item in scope)
+    return "not stated in the report"
+
+
+def _picker_label(option: Mapping[str, Any]) -> str:
+    answer = str(option.get("answer") or "").strip()
+    if option.get("role") == "recommended":
+        return f"{answer} (Recommended)"
+    return answer
+
+
+def _picker_description(option: Mapping[str, Any]) -> str:
+    added = option.get("addedWork") or "not stated in the report"
+    reverse = option.get("directionChange") or "not stated in the report"
+    rationale = option.get("rationale") or "not stated in the report"
+    return (
+        f"If you pick this: {added}. What it reverses: {reverse}. "
+        f"Scope: {_picker_scope(option)}. Why it is on the board: {rationale}."
+    )
+
+
+def _format_picker(options: list[Any]) -> list[str]:
+    """호스트 네이티브 픽커에 그대로 넣을 칸. 순서는 `Option N:` 과 같다.
+
+    HTML 리포트의 `<select>` 값도 `option.answer` 다. 스킬이 이 블록을 카드로
+    옮기면 브라우저 선택과 in-session 선택이 같은 답을 고른다.
+    """
+    lines = ["Picker:"]
+    for option in options:
+        if not isinstance(option, Mapping):
+            continue
+        lines.extend([
+            f"- Label: {_picker_label(option)}",
+            f"  Description: {_picker_description(option)}",
+        ])
+    if len(lines) == 1:
+        return ["Picker: none"]
+    return lines
+
+
 def _option_probe_texts(options: list[Any]) -> list[str]:
     texts: list[str] = []
     for option in options:
@@ -2114,6 +2179,7 @@ def _format_open_row_view(
         ])
     for index, option in enumerate(row["options"], start=1):
         lines.extend(_option_view(option, index))
+    lines.extend(_format_picker(list(row["options"] or [])))
     linked = _linked_plan_items(record, item.row_id)
     lines.extend(_format_ref_list(
         "Linked plan items",

package/runtime/python/okstra_ctl/wizard.py

@@ -4312,7 +4312,7 @@ def _critic_provider_choices() -> list[str]:
 
 
 def _critic_choices() -> list[str]:
-    return ["off", *_critic_provider_choices()]
+    return list(_critic_provider_choices())
 
 
 def _critic_provider_label(provider: str, t: dict) -> str:
@@ -4326,14 +4326,10 @@ 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")
-    # 추천(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"],

package/runtime/python/okstra_token_usage/codex.py

@@ -56,7 +56,7 @@ def find_codex_session(cwd: Path, started_at: str, ended_at: str) -> Path | None
     return sessions[-1] if sessions else None
 
 
-def _session_metadata(path: Path) -> tuple[str, str] | None:
+def _session_meta_payload(path: Path) -> dict | None:
     try:
         with path.open() as fh:
             first = fh.readline()
@@ -70,9 +70,38 @@ def _session_metadata(path: Path) -> tuple[str, str] | None:
         return None
     if record.get("type") != "session_meta":
         return None
-    payload = record.get("payload") or {}
+    payload = record.get("payload")
+    if not isinstance(payload, dict):
+        payload = {}
     timestamp = payload.get("timestamp") or record.get("timestamp") or ""
-    return str(payload.get("cwd") or ""), timestamp
+    return {**payload, "timestamp": timestamp}
+
+
+def _session_metadata(path: Path) -> tuple[str, str] | None:
+    payload = _session_meta_payload(path)
+    if payload is None:
+        return None
+    return str(payload.get("cwd") or ""), str(payload.get("timestamp") or "")
+
+
+def codex_session_is_worker(path: Path) -> bool:
+    """exec 래퍼 세션. 대화형 리드는 originator=codex-tui / source=cli 이다."""
+    payload = _session_meta_payload(path)
+    if not payload:
+        return False
+    originator = str(payload.get("originator") or "").strip()
+    source = str(payload.get("source") or "").strip()
+    return originator == "codex_exec" or source == "exec"
+
+
+def codex_session_ids(path: Path) -> set[str]:
+    ids = {path.name, path.stem}
+    payload = _session_meta_payload(path) or {}
+    for key in ("session_id", "id"):
+        value = str(payload.get(key) or "").strip()
+        if value:
+            ids.add(value)
+    return {item for item in ids if item}
 
 
 def find_codex_sessions(