okstra 0.200.0 → 0.201.0

package/runtime/python/okstra_ctl/wizard/render.py

@@ -2,6 +2,7 @@
 from __future__ import annotations
 
 from typing import Any
+import json
 
 from okstra_ctl.legacy_model_selection import serialize_host_session_context
 from okstra_ctl.wizard_stage_intent import (
@@ -17,7 +18,6 @@ from .state import (
     _role_selection_enabled,
 )
 from .roles import _host_session_context, _selectable_static_requirements
-from .confirmation import confirmation_block
 
 
 def _stage_intent(state: WizardState) -> WizardStageIntent:
@@ -132,58 +132,11 @@ def render_args(state: WizardState) -> dict[str, Any]:
         for index, token in enumerate(role_argv)
         if token == "--role-model"
     ]
+    if state.user_authorization:
+        stages = _stage_intent(state).chain_stages.split(",") if _stage_intent(state).chain_stages else []
+        if state.user_authorization.get("stageScope", []) != stages:
+            raise WizardError("confirmed stage scope changed; obtain confirmation for the changed stages")
+        if state.user_authorization.get("scope") != rendered:
+            raise WizardError("confirmed scope changed; obtain confirmation for the changed inputs")
+        rendered["user-authorization-json"] = json.dumps(state.user_authorization, ensure_ascii=False)
     return rendered
-
-
-def _render_argv(rendered: dict[str, Any], *, host_runtime: str) -> list[str]:
-    """Flatten render arguments into the canonical render-bundle argv."""
-    argv = ["--lead-runtime", host_runtime]
-    for name, raw_value in rendered.items():
-        values = raw_value if isinstance(raw_value, list) else [raw_value]
-        for value in values:
-            if not isinstance(value, str):
-                raise WizardError(
-                    f"wizard render arg --{name} must be a string"
-                )
-            argv.extend([f"--{name}", value])
-    return argv
-
-
-def _wizard_persist_actions(state: WizardState) -> list[dict[str, str]]:
-    if state.task_type != "release-handoff":
-        return []
-    if not state.pr_template_path:
-        return []
-    if state.pr_template_scope not in ("project", "global"):
-        return []
-    return [
-        {
-            "command": "config.set",
-            "key": "pr-template-path",
-            "scope": state.pr_template_scope,
-            "value": state.pr_template_path,
-        }
-    ]
-
-
-def wizard_outcome(state: WizardState) -> dict[str, Any]:
-    """Public outcome for callers that need launch data and follow-up writes.
-
-    `renderArgs` carries only what `okstra render-bundle` accepts, so a caller
-    can pass every entry through unfiltered — which is exactly what the
-    okstra-run skill is told to do. Signals the skill consumes itself, like the
-    unattended stage chain, live under `orchestration`; mixing them into
-    `renderArgs` made the renderer reject the wizard's own output.
-    """
-    if state.aborted:
-        raise WizardError("wizard was aborted by the user — outcome is unavailable")
-    if state.confirmed is not True:
-        raise WizardError("wizard is not complete — outcome is unavailable")
-    rendered = render_args(state)
-    return {
-        "renderArgs": rendered,
-        "renderArgv": _render_argv(rendered, host_runtime=state.host_runtime),
-        "orchestration": {"chainStages": _stage_intent(state).chain_stages},
-        "persistActions": _wizard_persist_actions(state),
-        "confirmationText": confirmation_block(state),
-    }

package/runtime/python/okstra_ctl/wizard/roles.py

@@ -8,8 +8,9 @@ verifier: `max > 1`)은 체크박스 한 장이고, 고른 모델 수가 곧 인
 고정 단일 역할(`min = max = 1`, 예: report-writer·implementer)은 단일 선택 한 장이다.
 
 모델 화면(`role-models:<role>`, `role-model:<role>:1`)은 실행 가능한 전체 후보를
-한 번에 싣는다. 기본 후보(프로젝트 `modelDefaults`, 없으면 카탈로그 기본값)가
-앞이고 권장 수만큼의 앞줄이 추천이다. 호스트 네이티브 선택기의 옵션 한도
+한 번에 제공자별로 묶어 싣는다. 기본 후보(프로젝트 `modelDefaults`, 없으면
+카탈로그 기본값)에서 권장 수만큼 추천하고 제공자 안에서는 기본 후보가 앞이다.
+호스트 네이티브 선택기의 옵션 한도
 (claude-code 4, codex 3, grok 15)를 넘으면 체크박스든 단일 선택이든 네이티브
 질문 묶음에 실리는 크기(claude-code 4×4)까지는 같은 화면의 체크박스 질문 여러
 개로 자르고(`picker_navigation.split_picker`), 그것도 넘으면 체크박스는
@@ -31,6 +32,7 @@ from okstra_ctl.assignment_resolver import (
     resolve_model_assignment,
 )
 from okstra_ctl.domain.host import CurrentSessionModelAttestation, HostSessionContext
+from okstra_ctl.registry.provider_registry import provider_display_order
 from okstra_ctl.dispatch_state import detect_terminal_backend
 from okstra_ctl.registry.host_registry import default_host_registry
 from okstra_ctl.model_defaults import ModelDefaultScopes, default_candidates
@@ -221,9 +223,9 @@ def _role_models_prompt(
     context: AssignmentContext,
     scopes: ModelDefaultScopes,
 ) -> Prompt:
-    """역할 하나의 모델 화면 — 실행 가능한 전체 후보, 기본 후보가 앞이다.
+    """역할 하나의 모델 화면 — 실행 가능한 전체 후보를 제공자별로 묶는다.
 
-    추천은 권장 수만큼의 앞줄이다 — 프로젝트 `modelDefaults`(없으면 카탈로그
+    추천은 정렬 전 권장 수만큼의 후보다 — 프로젝트 `modelDefaults`(없으면 카탈로그
     기본값) 순서가 그 근거다. 권장이 0인 선택 역할은 "추가 안 함" 이 추천이다.
     """
     role = requirement.role
@@ -245,8 +247,6 @@ def _role_models_prompt(
     optional = requirement.min_count == 0
     skip_first = optional and requirement.recommended_count == 0
     options: list[Option] = []
-    if skip_first:
-        options.append(_skip_option(requirement, t, recommended=True))
     for index, model_ref in enumerate(everything):
         model = pool.resolve(model_ref)
         options.append(_opt(
@@ -254,6 +254,9 @@ def _role_models_prompt(
             t["options"]["model"].format(model_ref=model_ref, display=model.display_name),
             recommended=index < requirement.recommended_count,
         ))
+    options.sort(key=lambda option: provider_display_order(option.value.split("/", 1)[0]))
+    if skip_first:
+        options.insert(0, _skip_option(requirement, t, recommended=True))
     if optional and not skip_first:
         options.append(_skip_option(requirement, t, recommended=False))
     return Prompt(
@@ -273,7 +276,7 @@ def _single_model_options(
     context: AssignmentContext,
     scopes: ModelDefaultScopes,
 ) -> list[Option]:
-    """고정 단일 역할의 후보 전체. 기본 후보가 앞이고 첫 줄이 추천이다."""
+    """고정 단일 역할의 후보를 제공자별로 묶고 기존 추천을 유지한다."""
     pool = context.pool
     requirement = next(row for row in profile.roles if row.role == role)
     defaults, everything = _available_role_models(
@@ -308,6 +311,7 @@ def _single_model_options(
     if not options:
         _validate_role_selection_feasibility(state, profile, context, scopes)
         raise WizardError(f"role {role!r} has no executable model candidates")
+    options.sort(key=lambda option: provider_display_order(option.value.split("/", 1)[0]))
     return options
 
 

package/runtime/python/okstra_ctl/wizard/sources.py

@@ -533,6 +533,30 @@ def _same_file(a: Path, b_str: str) -> bool:
         return False
 
 
+
+def _technical_evidence_for_comparison(
+    state: WizardState, source: Path | None, task_root: Path,
+) -> Path | None:
+    """현재 비교 보고서를 검증한 결과만 다음 재비교의 입력으로 추천한다."""
+    if state.task_type != "implementation-option-selection" or source is None:
+        return source
+    project_root = Path(state.project_root)
+    report = _newest_contained_final_report(
+        task_root / "runs", task_root,
+        "technical-verification/reports/final-report-*.data.json", project_root,
+    )
+    if report is None:
+        return source
+    try:
+        data = load_owned_object(report, artifact="technical verification report")
+    except (OSError, ValueError):
+        return source
+    block = data.get("technicalVerification") or {}
+    if block.get("sourceReport") != str(source.relative_to(project_root)):
+        return source
+    return report
+
+
 def _suggest_latest_final_report(state: WizardState) -> str:
     """clarification carry-in 으로 추천할 직전 final-report 의 relpath.
 
@@ -561,7 +585,8 @@ def _suggest_latest_final_report(state: WizardState) -> str:
     revision = _latest_revision_requested_analysis_report(state)
     best = revision
     if best is None and state.task_type:
-        seg = slugify_task_segment(state.task_type)
+        source_type = "implementation-option-selection" if state.task_type == "technical-verification" else state.task_type
+        seg = slugify_task_segment(source_type)
         best = _newest_contained_final_report(
             runs_base,
             task_root,
@@ -573,13 +598,14 @@ def _suggest_latest_final_report(state: WizardState) -> str:
     # 리포트가 없으면 이 런은 새 계획이고, 답은 `--selected-direction` 으로
     # 들어간다 — 전체 phase 폴백은 여기서 직전 후보비교 리포트를 추천했고,
     # 그것을 고른 사용자는 두 상호 배타 입력을 동시에 갖게 됐다.
-    if best is None and state.task_type != "implementation-planning":
+    if best is None and state.task_type not in {"implementation-planning", "technical-verification"}:
         best = _newest_contained_final_report(
             runs_base,
             task_root,
             "*/reports/final-report-*.data.json",
             Path(state.project_root),
         )
+    best = _technical_evidence_for_comparison(state, best, task_root)
     if best is None:
         return ""
     # The approved plan is already wired via --approved-plan. On the first run

package/runtime/python/okstra_ctl/wizard/state.py

@@ -147,6 +147,10 @@ class WizardState:
     # "" | "yes" | "no" — done(release-handoff) task 재진입의 fix-cycle 기록 여부
     fix_cycle: str = ""
     confirmed: Optional[bool] = None
+    confirmation_stages: str = ""
+    confirmation_prompt: str = ""
+    confirmation_scope: dict[str, Any] = field(default_factory=dict)
+    user_authorization: dict[str, Any] = field(default_factory=dict)
     edit_target: str = ""
     # terminal: user picked 중단 — no further prompt ever applies
     aborted: bool = False
@@ -225,26 +229,28 @@ class Prompt:
         self._check_recommendations()
 
     def _check_recommendations(self) -> None:
-        """단일 선택의 추천은 정확히 하나이고 1번이다. 탈출구는 추천이 아니다.
+        """단일 추천은 하나다. 모델 선택은 제공자 순서, 그 외에는 추천이 앞이다.
 
         실측(2026-09-09, task 선택 화면): 남은 task 세 줄이 전부 `(추천)` 을
         달고 나왔고, 리드는 산문에서 2번을 권했다. 추천이 여럿이면 라벨은
         아무것도 고르지 않은 것이고, 추천이 1번이 아니면 사용자는 목록을
-        끝까지 읽어야 추천을 찾는다. 체크박스(`multi`)는 추천이 기본 선택
-        집합이라 여럿일 수 있되 앞머리에 모여 있다. 그리고 `직접 입력` /
+        끝까지 읽어야 추천을 찾는다. 모델 선택은 제공자별 묶음을 우선한다.
+        그 외 체크박스(`multi`)는 추천이 여럿일 수 있되 앞머리에 모인다.
+        그리고 `직접 입력` /
         `중단` 은 앞의 선택지가 전부 맞지 않을 때의 탈출구이므로 추천 대상이
         될 수 없다.
         """
         flags = [option.recommended for option in self.options]
+        grouped_models = self.step.startswith(("role-models:", "role-model:"))
         if any(flags):
             if self.multi:
-                if any(flags[index] for index in range(1, len(flags))
+                if not grouped_models and any(flags[index] for index in range(1, len(flags))
                        if not flags[index - 1]):
                     raise WizardError(
                         f"wizard step {self.step!r}: recommended options must "
                         "be the leading run of the list"
                     )
-            elif sum(flags) != 1 or not flags[0]:
+            elif sum(flags) != 1 or (not grouped_models and not flags[0]):
                 raise WizardError(
                     f"wizard step {self.step!r}: a single-select step carries "
                     "exactly one recommendation and it is the first option"
@@ -684,7 +690,8 @@ _FIELD_DEFAULTS: dict[str, Any] = {
     "pr_template_path": "", "pr_template_pending_text": False,
     "pr_template_scope": "",
     "fix_cycle": "",
-    "confirmed": None, "edit_target": "",
+    "confirmed": None, "edit_target": "", "confirmation_prompt": "", "confirmation_stages": "",
+    "confirmation_scope": {}, "user_authorization": {},
 }
 
 

package/runtime/python/okstra_ctl/wizard/steps_plan.py

@@ -12,6 +12,7 @@ from okstra_ctl.incremental_scope import CARRY_ALL_SCOPE
 from okstra_ctl.implementation_direction import (
     DirectionSelectionError,
     lexical_absolute_path,
+    resolve_selected_direction,
     validate_task_artifact_path,
 )
 from okstra_ctl.final_report_paths import final_report_data_path
@@ -191,6 +192,13 @@ def _submit_selected_direction_pick(
     candidates = _selected_direction_candidates(state)
     if value not in candidates:
         raise WizardError(t["errors"]["unknown"].format(value=value))
+    try:
+        resolve_selected_direction(
+            Path(state.project_root) / value,
+            expected_task_key=f"{state.project_id}:{state.task_group}:{state.task_id}",
+        )
+    except DirectionSelectionError as exc:
+        raise WizardError(str(exc)) from exc
     state.selected_direction_path = value
     # 두 입력은 상호 배타다 — 방향이 정해진 순간 이 런은 새 계획이고,
     # clarification 자리에 남은 값은 render-bundle 이 거절할 이유일 뿐이다.

package/runtime/python/okstra_ctl/worker_liveness.py

@@ -162,7 +162,8 @@ def probe_launch(
     """Whether the wrapper behind *prompt* ever started."""
     log, status = _log_path(prompt), Path(f"{prompt}.status.json")
     probe = {"kind": "launch", "path": str(prompt)}
-    if log.exists() or status.exists():
+    if any(path.is_file() and path.stat().st_mtime >= dispatched_at.timestamp()
+           for path in (log, status)):
         return {**probe, "state": "live", "reason": ""}
     waited = (now - dispatched_at).total_seconds()
     if waited <= grace:
@@ -273,7 +274,8 @@ def probe_all(
 def result_ready(target: ProbeTarget) -> bool:
     """Whether this worker's result file has landed with content in it."""
     path = target.result_path
-    return bool(path and path.is_file() and path.stat().st_size > 0)
+    return bool(path and path.is_file() and path.stat().st_size > 0
+                and path.stat().st_mtime >= target.dispatched_at.timestamp())
 
 
 def wait_for_results(
@@ -370,53 +372,58 @@ def _dispatch_worker_id(record: Mapping[str, Any]) -> str:
     return ""
 
 
-def _dispatch_fallback(state: Mapping[str, Any], worker_id: str) -> dict:
-    """같은 워커의 디스패치 행 중 마지막 것.
-
-    로스터 행에 없는 키를 여기서 보충한다. 재디스패치는 같은 워커의 행을 뒤에
-    덧붙이므로 마지막 행이 이번 시도다.
-    """
-    records = state.get("workerDispatches")
-    if not isinstance(records, list):
-        return {}
+def _dispatch_fallback(state: Mapping[str, Any], worker_id: str, dispatch_id: str = "") -> dict:
+    """명시한 배정 또는 하나로 확정되는 구형 배정만 선택한다."""
+    records = state.get("workerDispatches") or []
     matches = [
-        row for row in records
-        if isinstance(row, Mapping) and _dispatch_worker_id(row) == worker_id
+        row for row in records if isinstance(row, Mapping)
+        and (row.get("dispatchId") == dispatch_id if dispatch_id
+             else _dispatch_worker_id(row) == worker_id)
     ]
-    return dict(matches[-1]) if matches else {}
-
+    if len(matches) > 1:
+        raise DispatchError(f"multiple dispatches for {worker_id or dispatch_id}; pass --dispatch-id")
+    if dispatch_id and not matches:
+        raise DispatchError(f"team-state has no dispatchId={dispatch_id}")
+    return dict(matches[0]) if matches else {}
 
-def _worker_row(team_state_path: Path, worker_id: str) -> dict:
-    """이 워커의 프로브 입력 — 로스터 행에 디스패치 행을 덧댄 것.
 
-    `livenessMode` 는 디스패치 행에만 실린다(`dispatch_core._dispatch_record`);
-    로스터 행은 그 키를 갖지 않는다. 로스터만 읽으면 cmux 백엔드의 모든 run 에서
-    프로브가 전면 거부되고, 리드는 계약이 금지한 자체 폴링으로 밀려난다.
-    보충은 로스터에 없거나 빈 키에만 적용한다 — `startedAt` 처럼 로스터가 정본인
-    값을 디스패치 행이 덮어쓰면 grace 앵커가 이번 시도에서 어긋난다.
-    """
+def _worker_row(team_state_path: Path, worker_id: str, dispatch_id: str = "") -> dict:
+    """새 배정의 필드는 원자적으로 읽고 구형 단일 기록만 보완한다."""
     state = load_json_object(team_state_path, "team-state")
+    dispatch = _dispatch_fallback(state, worker_id, dispatch_id)
+    if dispatch.get("dispatchId") and dispatch.get("startedAt"):
+        result = dispatch.get("resultPath")
+        root = _project_root_for_team_state(team_state_path)
+        if result and any(
+            isinstance(row, Mapping) and row.get("dispatchId") != dispatch["dispatchId"]
+            and row.get("status") not in {"completed", "error", "timeout", "not-run"}
+            and row.get("resultPath")
+            and (root / row["resultPath"]).resolve() == (root / result).resolve()
+            for row in state.get("workerDispatches", [])
+        ):
+            raise DispatchError("resultPath is shared by dispatches; use an attempt-specific result path")
+        return dispatch
     workers = state.get("workers")
     if not isinstance(workers, list):
         raise DispatchError(f"team-state workers must be an array: {team_state_path}")
-    worker = next(
-        (
-            row for row in workers
-            if isinstance(row, dict) and row.get("workerId") == worker_id
-        ),
-        None,
-    )
+    selected_worker = _dispatch_worker_id(dispatch) if dispatch_id else worker_id
+    worker = next((row for row in workers if isinstance(row, dict)
+                   and row.get("workerId") == selected_worker), None)
     if worker is None:
-        raise DispatchError(f"team-state has no workerId={worker_id}: {team_state_path}")
+        raise DispatchError(f"team-state has no workerId={selected_worker}: {team_state_path}")
+    if dispatch and worker.get("promptPath") and dispatch.get("promptPath"):
+        root = _project_root_for_team_state(team_state_path)
+        if (root / worker["promptPath"]).resolve() != (root / dispatch["promptPath"]).resolve():
+            raise DispatchError("dispatch has no startedAt and roster promptPath differs; repair the recorded attempt")
     merged = dict(worker)
-    for key, value in _dispatch_fallback(state, worker_id).items():
+    for key, value in dispatch.items():
         current = merged.get(key)
         if key not in merged or (isinstance(current, str) and not current.strip()):
             merged[key] = value
     return merged
 
 
-def probe_target(team_state_value: str, worker_id: str) -> ProbeTarget:
+def probe_target(team_state_value: str, worker_id: str, *, dispatch_id: str = "") -> ProbeTarget:
     """Resolve one worker's probe target from team-state.
 
     ``livenessMode`` is authoritative — never infer the transport from the
@@ -424,7 +431,7 @@ def probe_target(team_state_value: str, worker_id: str) -> ProbeTarget:
     worker for a wrapper log that will never exist.
     """
     team_state_path = Path(team_state_value).resolve()
-    worker = _worker_row(team_state_path, worker_id)
+    worker = _worker_row(team_state_path, worker_id, dispatch_id)
     mode = worker.get("livenessMode")
     field = _ARTIFACT_FIELD_BY_MODE.get(mode) if isinstance(mode, str) else None
     if field is None:
@@ -492,6 +499,8 @@ def main(argv: list[str] | None = None) -> int:
                         help="team-state path for a pending worker (repeatable)")
     parser.add_argument("--worker", action="append", default=[],
                         help="worker id paired with --team-state (repeatable)")
+    parser.add_argument("--dispatch-id", action="append", default=[],
+                        help="exact dispatch id paired with --team-state; do not mix with --worker")
     parser.add_argument("--max-idle", type=float, default=HEARTBEAT_MAX_GAP_SECONDS,
                         help="heartbeat staleness budget in seconds")
     parser.add_argument("--launch-grace", type=float, default=DEFAULT_LAUNCH_GRACE_SECONDS,
@@ -520,15 +529,19 @@ def main(argv: list[str] | None = None) -> int:
     )
     args = parser.parse_args(argv)
 
-    if len(args.team_state) != len(args.worker):
-        parser.error("each --team-state must have one paired --worker")
+    if args.worker and args.dispatch_id:
+        parser.error("use --worker or --dispatch-id, not both")
+    selectors = args.dispatch_id or args.worker
+    if len(args.team_state) != len(selectors):
+        parser.error("each --team-state must have one paired --worker or --dispatch-id")
     if not args.team_state:
         parser.error("pass at least one --team-state/--worker pair")
 
     try:
         targets = [
-            probe_target(team_state, worker)
-            for team_state, worker in zip(args.team_state, args.worker, strict=True)
+            probe_target(team_state, "" if args.dispatch_id else worker,
+                         dispatch_id=worker if args.dispatch_id else "")
+            for team_state, worker in zip(args.team_state, selectors, strict=True)
         ]
     except DispatchError as exc:
         parser.error(str(exc))
@@ -547,7 +560,7 @@ def main(argv: list[str] | None = None) -> int:
         return 0 if result["ok"] else 1
 
     unwaitable = [
-        worker for target, worker in zip(targets, args.worker, strict=True)
+        worker for target, worker in zip(targets, selectors, strict=True)
         if target.result_path is None
     ]
     if unwaitable:

package/runtime/python/okstra_ctl/worker_prompt_policy.py

@@ -49,6 +49,7 @@ FINAL_VERIFICATION_HEADERS = (
     "**Verification target digest:**",
 )
 SUPPORTED_TASK_TYPES = frozenset({
+    "technical-verification",
     "requirements-discovery",
     "error-analysis",
     "implementation-option-selection",
@@ -65,6 +66,7 @@ SUPPORTED_TASK_TYPES = frozenset({
 # something else gets its own. A task type absent from this map takes the
 # observational default below: describe the area, do not design for it.
 ANALYSIS_DUTY_BY_TASK_TYPE: dict[str, AgentAudience] = {
+    "technical-verification": "technical-verification-worker",
     "requirements-discovery": "discovery-worker",
     "improvement-discovery": "discovery-worker",
     "error-analysis": "diagnosis-worker",

package/runtime/python/okstra_ctl/workflow.py

@@ -39,6 +39,14 @@ ERROR_ANALYSIS_ROUTING_DIRECTIONS = {
 # prompt template 에 그대로 박혀 lead 가 읽는다. forbidden actions 는 이 dict 가
 # 아니라 prompts/profiles/forbidden-actions.json (load_phase_forbidden) 이 SSOT.
 PHASE_RULES: dict[str, dict[str, str]] = {
+    "technical-verification": {
+        "allowed": (
+            "  - falsifiable experiment plans for the frozen unresolved facts\n"
+            "  - dependency installation, source experiments, tests and builds only in this run's experiment copies\n"
+            "  - command logs, observed signals and per-fact supported/refuted/inconclusive/not-run results\n"
+            "  - return to implementation-option-selection with evidence, without adoption or plan approval"
+        ),
+    },
     "requirements-discovery": {
         "allowed": (
             "  - work-category classification (bugfix / feature / refactor / ops / improvement)\n"

package/runtime/python/okstra_ctl/write_policy.py

@@ -3,6 +3,7 @@ from __future__ import annotations
 
 import hashlib
 import json
+import re
 import subprocess
 from collections.abc import Mapping, Sequence
 from dataclasses import dataclass
@@ -120,6 +121,27 @@ def _role_qa_artifact_paths(role: str, task_root: Path | None) -> tuple[Path, ..
     return ()
 
 
+
+def _technical_experiment_paths(
+    artifact_paths: Sequence[Path], task_root: Path | None,
+) -> tuple[Path, ...]:
+    """정규 작업 결과 경로에서 해당 작업자의 시험 디렉터리만 파생한다."""
+    if task_root is None:
+        return ()
+    run_root = task_root / "runs" / "technical-verification"
+    paths = set()
+    for artifact in artifact_paths:
+        if artifact.parent != run_root / "worker-results":
+            continue
+        match = re.fullmatch(
+            r"([a-z0-9][a-z0-9-]*)-worker-technical-verification-(\d{3,})\.md",
+            artifact.name,
+        )
+        if match:
+            paths.add(run_root / "experiments" / match[2] / match[1])
+    return tuple(sorted(paths))
+
+
 def build_invocation_write_contract(
     *,
     role: str,
@@ -142,6 +164,7 @@ def build_invocation_write_contract(
             _relative_to_root(path, root, "artifact")
             for path in (
                 *artifact_paths,
+                *_technical_experiment_paths(artifact_paths, task_root),
                 *_role_qa_artifact_paths(role, task_root),
             )
         )

package/runtime/python/okstra_token_usage/blocks.py

@@ -1,12 +1,62 @@
 """Per-source usage block constructors (consumed by collect())."""
 from __future__ import annotations
 
+from collections.abc import Mapping
+from typing import Any
+
 from .paths import utc_now
 from .pricing import (
     claude_billable_equivalent,
     claude_cost_usd,
 )
 
+_CACHE_INCLUDED_SOURCES = frozenset({"codex-cli", "grok-cli", "kimi-cli"})
+
+
+def accounting_workers(state: Mapping[str, Any]) -> list[dict]:
+    """초기 명부와 명부 밖 실행의 사용량 행을 같은 소비 경로로 전달한다."""
+    rows = []
+    for key in ("workers", "additionalWorkerUsage"):
+        collection = state.get(key)
+        if isinstance(collection, list):
+            rows.extend(row for row in collection if isinstance(row, dict))
+    return rows
+
+
+def usage_blocks(state: dict) -> list[dict]:
+    blocks = [state.get("leadUsage") or {}]
+    blocks.extend(worker.get("usage") or {} for worker in accounting_workers(state))
+    unattributed = (state.get("usageSummary") or {}).get("unattributedWorkerUsage")
+    if isinstance(unattributed, dict):
+        blocks.append(unattributed)
+    return [block for block in blocks if isinstance(block, dict)]
+
+
+def normalize_usage_block(block: dict) -> dict:
+    """과거 캐시 포함 합계를 정규화하고 게시 당시 합계를 별도로 보존한다."""
+    normalized = dict(block)
+    cached = block.get("cachedInputTokens") or 0
+    if (
+        block.get("source") not in _CACHE_INCLUDED_SOURCES
+        or "cacheReadTokens" in block
+        or block.get("accountingBasis") == "cache-read-excluded"
+        or not isinstance(cached, int)
+        or isinstance(cached, bool)
+        or cached <= 0
+    ):
+        return normalized
+    total = block.get("totalTokens")
+    if not isinstance(total, int) or total < cached:
+        return normalized
+    normalized["reportedTotalTokens"] = total
+    normalized["totalTokens"] = total - cached
+    normalized["cacheReadTokens"] = cached
+    normalized["accountingBasis"] = "cache-read-excluded"
+    if isinstance(block.get("cliTotalTokens"), int):
+        normalized["reportedCliTotalTokens"] = block["cliTotalTokens"]
+        normalized["cliTotalTokens"] = max(0, block["cliTotalTokens"] - cached)
+    return normalized
+
 
 def usage_block(totals: dict, source: str, note: str | None = None) -> dict:
     block = {
@@ -65,4 +115,3 @@ def na_block(reason: str) -> dict:
         "collectedAt": utc_now(),
         "note": reason,
     }
-