okstra 0.200.1 → 0.201.0

package/runtime/python/okstra_ctl/usage_identity.py

@@ -16,6 +16,60 @@ from .execution_manifest import read_execution_manifest
 from .json_boundary import load_owned_object
 
 
+def unrostered_usage_workers(state: Mapping[str, Any]) -> list[dict[str, Any]]:
+    """초기 명부에 없는 번역·비평 실행을 사용량 전용 행으로 투영한다."""
+    from .dispatch_state import v2_worker_state_key
+
+    known = {str(row.get("workerId")) for row in state.get("workers") or []
+             if isinstance(row, Mapping)}
+    additional: dict[str, dict[str, Any]] = {}
+    for record in usage_dispatch_records(state):
+        key = str(record.get("workerId") or "")
+        if not key and record.get("assignmentRef"):
+            key = v2_worker_state_key(record)
+        if not key or key in known:
+            continue
+        row = additional.setdefault(key, {
+            "workerId": key, "role": record.get("role") or record.get("audience") or key,
+            "provider": record.get("provider"), "agent": record.get("provider"),
+            "runner": record.get("runner") or "cli-wrapper", "usageAttempts": [],
+            **stored_identity(record),
+        })
+        row.update(status=record.get("status"), promptPath=record.get("promptPath"),
+                   model=record.get("modelExecutionValue") or record.get("model"))
+        attempt = {name: record.get(name) for name in ("invocationRef", "attempt", "status")}
+        if attempt not in row["usageAttempts"]:
+            row["usageAttempts"].append(attempt)
+    return list(additional.values())
+
+
+def usage_dispatch_records(
+    state: Mapping[str, Any], worker_id: str | None = None,
+) -> list[Mapping[str, Any]]:
+    from .dispatch_state import worker_dispatch_records
+
+    records: list[Mapping[str, Any]] = []
+    seen: set[tuple] = set()
+    for collection in ("workerDispatches", "agentDispatches"):
+        source = state.get(collection)
+        for record in source if isinstance(source, list) else []:
+            if not isinstance(record, Mapping):
+                continue
+            reference = record.get("invocationRef") or record.get("promptPath")
+            key = (reference, record.get("attempt", 1))
+            if reference and key in seen:
+                continue
+            seen.add(key)
+            records.append(record)
+    return worker_dispatch_records({"workerDispatches": records}, worker_id)
+
+
+def usage_session_ids(state: Mapping[str, Any], worker_id: str) -> list[str]:
+    from .dispatch_state import worker_session_ids
+
+    return worker_session_ids({"workerDispatches": usage_dispatch_records(state)}, worker_id)
+
+
 def run_execution_manifest(run_root: Path) -> ExecutionManifest:
     """Load the first run-manifest under ``run_root/manifests``."""
     return read_execution_manifest(_manifest_path(run_root))

package/runtime/python/okstra_ctl/usage_report.py

@@ -17,6 +17,7 @@ from okstra_ctl.time_report import (
 from okstra_ctl.json_boundary import load_owned_object
 from okstra_ctl.fixed_text import line
 from okstra_project import ResolverError, list_project_tasks, resolve_project_root
+from okstra_token_usage.blocks import accounting_workers, normalize_usage_block, usage_blocks
 
 UTC = dt.timezone.utc
 UNAVAILABLE_KEYS = (
@@ -81,8 +82,7 @@ def _usage_block(value: Any) -> dict:
 
 
 def _usage_blocks(state: dict) -> tuple[dict, list[dict]]:
-    workers = state.get("workers")
-    worker_entries = workers if isinstance(workers, list) else []
+    worker_entries = accounting_workers(state)
     return _usage_block(state.get("leadUsage")), [
         _usage_block(worker.get("usage"))
         for worker in worker_entries
@@ -117,8 +117,15 @@ def _run_metrics(run: dict, project_root: Path) -> tuple[dict | None, str | None
     cost = costs.get("grandTotal", 0) if isinstance(costs, dict) else 0
     unmatched = summary.get("unmatchedModels")
     unmatched_models = unmatched if isinstance(unmatched, list) else []
+    original_blocks = usage_blocks(state)
+    normalized = [normalize_usage_block(block) for block in original_blocks]
+    cache_adjustment = sum(_int_value(block.get("totalTokens")) for block in original_blocks)
+    cache_adjustment -= sum(_int_value(block.get("totalTokens")) for block in normalized)
     return {
-        "rawTokens": _int_value(summary.get("grandTotalTokens")),
+        "rawTokens": _int_value(summary.get("grandTotalTokens")) - cache_adjustment,
+        "reportedRawTokens": _int_value(summary.get("grandTotalTokens")),
+        "legacyCacheReadAdjustmentTokens": cache_adjustment,
+        "cacheReadTokens": sum(_int_value(block.get("cacheReadTokens")) for block in normalized),
         "billableTokens": _int_value(summary.get("grandBillableEquivalentTokens")),
         "costUsd": _float_value(cost),
         "cpuSumMs": sum(positive_durations),
@@ -136,6 +143,9 @@ def _new_bucket(task_type: str, first_run_at: dt.datetime) -> dict:
         "runs": 0,
         "collectedRuns": 0,
         "rawTokens": 0,
+        "reportedRawTokens": 0,
+        "legacyCacheReadAdjustmentTokens": 0,
+        "cacheReadTokens": 0,
         "billableTokens": 0,
         "costUsd": 0.0,
         "cpuSumMs": 0,
@@ -162,10 +172,7 @@ def _collect_usage(
         runs, timeline_warning = load_runs(Path(entry["_resolvedTaskRoot"]))
         warnings["missingOrInvalidTimelines"] += int(timeline_warning)
         for run in runs:
-            if not isinstance(run, dict):
-                unavailable["invalidRunTimestamp"] += 1
-                continue
-            run_at = _parse_timestamp(run.get("runTimestamp"))
+            run_at = _parse_timestamp(run.get("runTimestamp") if isinstance(run, dict) else None)
             if run_at is None:
                 unavailable["invalidRunTimestamp"] += 1
                 continue
@@ -191,7 +198,8 @@ def _collect_usage(
                 continue
             collected_runs += 1
             bucket["collectedRuns"] += 1
-            for key in ("rawTokens", "billableTokens", "cpuSumMs", "wallClockMs"):
+            for key in ("rawTokens", "reportedRawTokens", "legacyCacheReadAdjustmentTokens",
+                        "cacheReadTokens", "billableTokens", "cpuSumMs", "wallClockMs"):
                 bucket[key] += metrics[key]
             bucket["costUsd"] += metrics["costUsd"]
             unmatched_models.update(metrics["unmatchedModels"])
@@ -223,6 +231,9 @@ def build_usage_report(project_root: Path, days: int, now: dt.datetime) -> dict:
         "runs": total_runs,
         "collectedRuns": collected_runs,
         "rawTokens": sum(row["rawTokens"] for row in rows),
+        "reportedRawTokens": sum(row["reportedRawTokens"] for row in rows),
+        "legacyCacheReadAdjustmentTokens": sum(row["legacyCacheReadAdjustmentTokens"] for row in rows),
+        "cacheReadTokens": sum(row["cacheReadTokens"] for row in rows),
         "billableTokens": sum(row["billableTokens"] for row in rows),
         "costUsd": round(_float_value(sum(row["costUsd"] for row in rows)), 4),
         "cpuSumMs": sum(row["cpuSumMs"] for row in rows),
@@ -325,6 +336,9 @@ def render_usage_text(payload: dict) -> str:
         rows.append(line(f"Task type {index} wall clock ms", item.get("wallClockMs")))
     totals = payload.get("totals") if isinstance(payload.get("totals"), dict) else {}
     for label, key in (("Raw tokens", "rawTokens"), ("Billable tokens", "billableTokens"),
+                       ("Reported raw tokens", "reportedRawTokens"),
+                       ("Legacy cache read adjustment tokens", "legacyCacheReadAdjustmentTokens"),
+                       ("Cache read tokens", "cacheReadTokens"),
                        ("Cost USD", "costUsd"), ("CPU sum ms", "cpuSumMs"),
                        ("Wall clock ms", "wallClockMs")):
         rows.append(line(label, totals.get(key)))

package/runtime/python/okstra_ctl/verification_target.py

@@ -10,9 +10,17 @@ both readers ask the same question.
 from __future__ import annotations
 
 import hashlib
+import argparse
+import json
 import re
+import subprocess
 from pathlib import Path
 
+from .execution_mutation_audit import source_content_snapshot
+from .json_boundary import load_owned_object
+from .path_hints import hydrate_active_run_context
+from .qa_commands import verification_command_defects
+
 TARGET_FIELD_RES = {
     "scope": re.compile(r"\*\*Verification scope:\*\*\s*`([^`]*)`"),
     "worktree": re.compile(r"\*\*Worktree:\*\*\s*`([^`]*)`"),
@@ -66,3 +74,69 @@ def read_verification_target(project_root: Path, relative: str) -> dict | None:
         else set()
     )
     return parsed
+
+
+def capture_verification_target(
+    project_root: Path, manifest_path: Path, expected_head: str, command: str,
+) -> dict:
+    """실제 검사 명령은 실행하지 않고 대상과 소스 지문만 확인한다."""
+    root = project_root.resolve()
+    manifest_path = (root / manifest_path).resolve()
+    manifest = load_owned_object(manifest_path, artifact="run manifest")
+    context = hydrate_active_run_context(load_owned_object(
+        root / manifest["activeRunContextPath"], artifact="active run context",
+    ))
+    if manifest.get("taskType") == "implementation":
+        target = context["executorWorktree"]["path"]
+    elif manifest.get("taskType") == "final-verification":
+        target = context["verificationTarget"]["worktreePath"]
+    else:
+        raise ValueError("verification-target requires implementation or final-verification")
+    if not target or not Path(target).is_absolute():
+        raise ValueError("active run context has no absolute verification worktree")
+    worktree = Path(target).resolve()
+    defects = verification_command_defects(command)
+    if defects:
+        raise ValueError("; ".join(defects))
+    git = ["git", "-C", str(worktree), "rev-parse"]
+    head = subprocess.check_output([*git, "HEAD"], text=True).strip()
+    actual_root = subprocess.check_output([*git, "--show-toplevel"], text=True).strip()
+    if head != expected_head or Path(actual_root).resolve() != worktree:
+        raise ValueError(f"verification target mismatch: expected HEAD {expected_head}, actual {head}, root {actual_root}")
+    files = source_content_snapshot(worktree, frozenset({".okstra"}))
+    digest = hashlib.sha256(json.dumps(files, sort_keys=True).encode()).hexdigest()
+    return {
+        "schemaVersion": "1.0", "runManifest": str(manifest_path),
+        "taskKey": manifest["taskKey"], "cwd": str(worktree),
+        "head": head, "sourceDigest": digest, "command": command,
+    }
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = argparse.ArgumentParser(
+        prog="okstra verification-target",
+        description="Check the recorded verification target without executing the command",
+    )
+    parser.add_argument("--project-root", type=Path, required=True)
+    parser.add_argument("--run-manifest", type=Path, required=True)
+    parser.add_argument("--expected-head", required=True)
+    parser.add_argument("--command", required=True, help="declared command to check, never executed")
+    parser.add_argument("--baseline", type=Path, help="compare against a prior verification-target JSON result")
+    args = parser.parse_args(argv)
+    try:
+        snapshot = capture_verification_target(
+            args.project_root, args.run_manifest, args.expected_head, args.command,
+        )
+        if args.baseline:
+            baseline = load_owned_object(args.baseline, artifact="verification target baseline")
+            if baseline.get("ok") is not True or baseline.get("target") != snapshot:
+                raise ValueError("verification target changed; do not reuse the previous verification result")
+        result = {"ok": True, "target": snapshot}
+    except (OSError, ValueError, KeyError, TypeError, subprocess.SubprocessError) as exc:
+        result = {"ok": False, "reason": str(exc)}
+    print(json.dumps(result, ensure_ascii=False, indent=2))
+    return 0 if result["ok"] else 1
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

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

@@ -141,8 +141,8 @@ from .engine import (
 from .render import (
     render_args,
     render_role_args,
-    wizard_outcome,
 )
+from .outcome import wizard_outcome
 from .cli import (
     main,
 )

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

@@ -17,7 +17,8 @@ from .engine import (
     prompt_payload,
     submit,
 )
-from .render import render_args, wizard_outcome
+from .render import render_args
+from .outcome import wizard_outcome
 
 
 # ---- CLI entrypoint -----------------------------------------------------

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

@@ -7,7 +7,7 @@ from typing import Optional
 from okstra_ctl.registry.host_registry import default_host_registry
 from okstra_ctl.clarification_items import sidecar_answers, user_response_sidecars
 from okstra_ctl.incremental_scope import CARRY_ALL_SCOPE
-from okstra_ctl.wizard_stage_intent import wizard_stage_confirmation_label
+from okstra_ctl.wizard_stage_intent import wizard_stage_confirmation_label, resolve_wizard_stage_intent
 from okstra_ctl.worktree import (
     compute_worktree_path,
     preview_worktree_decision,
@@ -15,6 +15,7 @@ from okstra_ctl.worktree import (
 )
 from okstra_ctl.work_categories import resolve_work_category
 
+from .render import render_args
 from .ids import S_CONFIRM, _STAGE_SCOPED_TASK_TYPES
 from .state import (
     Prompt,
@@ -107,9 +108,16 @@ def _build_confirm(state: WizardState) -> Prompt:
     같은 블록을 낸다.
     """
     t = _p(state.workspace_root, "confirm")
+    if not state.confirmation_prompt:
+        state.confirmation_stages = resolve_wizard_stage_intent(
+            task_type=state.task_type, selected_stage=state.selected_stage,
+            selected_stages=state.selected_stages,
+        ).chain_stages
+        state.confirmation_scope = render_args(state)
+        state.confirmation_prompt = f"{confirmation_block(state)}\n\n{t['label']}"
     return Prompt(
         step=S_CONFIRM, kind="pick",
-        label=f"{confirmation_block(state)}\n\n{t['label']}",
+        label=state.confirmation_prompt,
         options=[_opt(k, v) for k, v in t["options"].items()],
         echo_template=t["echo_template"],
     )
@@ -118,11 +126,31 @@ def _build_confirm(state: WizardState) -> Prompt:
 def _submit_confirm(state: WizardState, value: str) -> Optional[str]:
     if value == "abort":
         state.aborted = True
+        state.user_authorization = {}
         return "confirm: abort"
     if value not in ("proceed", "edit"):
         raise WizardError(
             f"expected 'proceed' / 'edit' / 'abort', got: {value!r}"
         )
+    if value == "proceed":
+        stages = resolve_wizard_stage_intent(
+            task_type=state.task_type, selected_stage=state.selected_stage,
+            selected_stages=state.selected_stages,
+        ).chain_stages
+        if (not state.confirmation_prompt or state.confirmation_scope != render_args(state)
+                or state.confirmation_stages != stages):
+            raise WizardError("confirmation scope changed; display the confirmation again before proceeding")
+        state.user_authorization = {
+            "schemaVersion": "1.0", "source": "wizard-confirmation",
+            "response": value, "prompt": state.confirmation_prompt,
+            "scope": state.confirmation_scope.copy(),
+            "stageScope": state.confirmation_stages.split(",") if state.confirmation_stages else [],
+        }
+    else:
+        state.user_authorization = {}
+        state.confirmation_prompt = ""
+        state.confirmation_scope = {}
+        state.confirmation_stages = ""
     state.confirmed = value == "proceed"
     return f"confirm: {value}"
 
@@ -340,6 +368,14 @@ def confirmation_block(state: WizardState) -> str:
         lines.append(f"  pr-template   : {state.pr_template_path} ({state.pr_template_scope or 'once'})")
     if state.fix_cycle:
         lines.append(f"  fix-cycle     : {state.fix_cycle}")
+    report_writer_models = state.role_models.get("report-writer", [])
+    translator_model = (
+        report_writer_models[0] if report_writer_models
+        else f"{state.report_writer_provider or 'claude'}/{state.report_writer_model or 'default'}"
+    )
+    lines.append(_msg(
+        state.workspace_root, "confirmation", "translation_scope", model=translator_model,
+    ))
     lines.append(_msg(
         state.workspace_root, "confirmation", "provider_data_scope",
         project_root=state.project_root,

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

@@ -395,11 +395,14 @@ def submit(state: WizardState, value: str) -> dict[str, Any]:
     Returns {"echo": "...", "next": <Prompt JSON>}. Raises WizardError on
     validation failure (caller may re-prompt).
     """
+    confirmation_was_displayed = bool(state.confirmation_prompt)
     prompt = next_prompt(state)
     if prompt.kind in ("done", "aborted"):
         return {"echo": "", "next": prompt_payload(state, prompt)}
     plan = _interaction_plan(state, prompt)
     value = _normalize_interaction_answer(state, prompt, plan, value)
+    if prompt.step == S_CONFIRM and value == "proceed" and not confirmation_was_displayed:
+        return {"echo": "", "next": prompt_payload(state, prompt)}
     if is_split_picker(prompt):
         # 질문 묶음으로 잘린 픽 — 탭별 CSV 를 한 줄로 합쳐 원본 step 의 제출
         # 경로로 보낸다. 원본의 선택지로 검증한다.

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

@@ -21,6 +21,7 @@ TASK_TYPES: list[tuple[str, str]] = [
     ("improvement-discovery", "Find improvement candidates within a codebase scope and lens whitelist"),
     *zip(ANALYSIS_TASK_TYPES, _ANALYSIS_TASK_TYPE_DESCRIPTIONS),
     ("error-analysis", "Evidence-based root-cause analysis (no code changes)"),
+    ("technical-verification", "Test unresolved technical facts in isolated experiment copies"),
     ("implementation-option-selection", "Compare implementation options (read-only)"),
     ("implementation-planning", "Plan options + request user approval"),
     ("implementation", "Execute approved plan (requires approved final-report)"),

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

@@ -0,0 +1,63 @@
+"""승인된 상태에서 실행 인자와 확인 화면을 조립한다."""
+from __future__ import annotations
+
+from typing import Any
+
+from .confirmation import confirmation_block
+from .render import _stage_intent, render_args
+from .state import WizardError, WizardState
+
+
+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": state.user_authorization.get("prompt") or confirmation_block(state),
+        "userAuthorization": state.user_authorization or None,
+    }

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

@@ -34,8 +34,8 @@ def split_picker(
 
     질문 수는 옵션이 들어가는 최소 개수이고 옵션은 질문에 고르게 나눈다 —
     마지막 질문이 한 줄짜리가 되면 호스트 최소 옵션 수(2)에 걸려 묶음 전체가
-    네이티브에 못 실린다. 추천은 원래 목록의 앞머리 run 이라 어느 조각에서도
-    앞머리 run 이 된다(`Prompt._check_recommendations`). `max_questions` 도
+    네이티브에 못 실린다. 모델 선택은 제공자 순서와 추천 표시를 각 조각에서도
+    보존한다(`Prompt._check_recommendations`). `max_questions` 도
     넘으면 자르지 않고 그대로 돌려준다.
     """
     if prompt.kind != "pick" or len(prompt.options) <= max_options:

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

@@ -752,7 +752,7 @@ STEPS: list[Step] = [
                                  or bool(s.fix_cycle))
                             and s.confirmed is None),
          build=_build_confirm, submit=_submit_confirm,
-         owns=("confirmed", "edit_target")),
+         owns=("confirmed", "edit_target", "confirmation_prompt", "confirmation_stages", "confirmation_scope", "user_authorization")),
     Step(S_EDIT_TARGET,
          applies=lambda s: s.confirmed is False and not s.edit_target,
          build=_build_edit_target, submit=_submit_edit_target,

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