okstra 0.200.0 → 0.201.0

package/runtime/python/okstra_ctl/technical_verification.py

@@ -0,0 +1,195 @@
+"""미확정 사실의 시험 입력과 관측 결과를 연결하며 도입 승인은 만들지 않는다."""
+
+from __future__ import annotations
+
+import hashlib
+import re
+from collections.abc import Mapping
+from pathlib import Path
+from typing import Any, TypedDict
+
+from .clarification_items import USER_INPUT_BLOCKS, progress_blocking_ids
+from .final_report_schema import load_schema_for_data, validate
+from .implementation_direction import validate_task_artifact_path
+from .json_boundary import load_owned_object_snapshot, serialize_owned_object
+
+
+class VerificationFact(TypedDict):
+    id: str
+    candidateId: str
+    factIndex: int
+    fact: str
+    whyItMatters: str
+    evidence: list[str]
+
+
+class VerificationInput(TypedDict):
+    sourceReport: str
+    sourceDataSha256: str
+    scope: str
+    facts: list[VerificationFact]
+
+
+class TechnicalVerificationError(ValueError):
+    """시험 입력 또는 관측 결과가 원본 사실과 일치하지 않는다."""
+
+
+def technical_verification_facts(data: Mapping[str, Any]) -> list[VerificationFact]:
+    """안전 차단이 없는 후보의 명시적인 기술 검증 사실만 추출한다."""
+    blockers = progress_blocking_ids(
+        data.get("clarificationItems"), USER_INPUT_BLOCKS, report_data=data
+    )
+    if blockers:
+        raise TechnicalVerificationError(
+            "unresolved user decisions: " + ", ".join(blockers)
+        )
+    selection = data.get("implementationOptionSelection") or {}
+    facts: list[VerificationFact] = []
+    for candidate in selection.get("candidateAudit") or []:
+        if candidate.get("safetyBlockers"):
+            continue
+        for index, fact in enumerate(candidate.get("unresolvedFeasibilityFacts") or []):
+            if fact.get("resolutionKind") != "technical-verification":
+                continue
+            facts.append(
+                {
+                    "id": f"TV-{len(facts) + 1:03d}",
+                    "candidateId": candidate["id"],
+                    "factIndex": index,
+                    "fact": fact["fact"],
+                    "whyItMatters": fact["whyItMatters"],
+                    "evidence": fact["evidence"],
+                }
+            )
+    if not facts:
+        raise TechnicalVerificationError("no eligible technical-verification facts")
+    return facts
+
+
+def resolve_technical_verification_input(
+    report: Path, project_root: Path, task_root: Path, task_key: str
+) -> VerificationInput:
+    """같은 작업의 후보 비교 기록을 시험 입력으로 고정한다."""
+    report = report if report.is_absolute() else project_root / report
+    validate_task_artifact_path(report, task_root, "technical verification source")
+    expected_parent = task_root / "runs/implementation-option-selection/reports"
+    if report.parent != expected_parent or not re.fullmatch(
+        r"final-report-implementation-option-selection-\d{3,}\.data\.json", report.name
+    ):
+        raise TechnicalVerificationError(
+            "source must be this task's option-selection record"
+        )
+    snapshot = load_owned_object_snapshot(
+        report, artifact="technical verification source"
+    )
+    data = snapshot.value
+    errors = validate(data, load_schema_for_data(data))
+    if errors:
+        raise TechnicalVerificationError("invalid source report: " + "; ".join(errors))
+    if data["header"]["taskKey"] != task_key:
+        raise TechnicalVerificationError(
+            "source taskKey does not match verification task"
+        )
+    return {
+        "sourceReport": report.relative_to(project_root).as_posix(),
+        "sourceDataSha256": hashlib.sha256(snapshot.raw_bytes).hexdigest(),
+        "scope": "technical-evidence-only",
+        "facts": technical_verification_facts(data),
+    }
+
+
+def write_technical_verification_input(
+    payload: VerificationInput, run_root: Path, seq: str
+) -> Path:
+    """실행 순번별 입력을 저장해 후속 실행이 이전 시험 범위를 덮지 않게 한다."""
+    path = run_root / "state" / f"technical-verification-input-{seq}.json"
+    serialized = serialize_owned_object(path, payload, artifact="technical verification input")
+    path.parent.mkdir(parents=True, exist_ok=True)
+    with path.open("x", encoding="utf-8") as output:
+        output.write(serialized)
+    return path
+
+
+def _check_execution_evidence(
+    check: Mapping[str, Any], project_root: Path, run_root: Path, seq: str
+) -> list[str]:
+    """관측 판정은 실행 기록과 실행별 시험 디렉터리를 요구한다."""
+    errors = []
+    commands = check.get("commands") or []
+    if check.get("status") != "not-run" and not commands:
+        errors.append(f"{check['id']}: an observed result requires command evidence")
+    for command in commands:
+        try:
+            log = project_root / command["logPath"]
+            experiment_root = run_root / "experiments" / seq
+            validate_task_artifact_path(log, experiment_root, "verification log")
+            if not log.read_text(encoding="utf-8").strip():
+                errors.append(f"{check['id']}: verification log is empty")
+            cwd = project_root / command["cwd"]
+            cwd.resolve(strict=True).relative_to(experiment_root.resolve(strict=True))
+            relative = cwd.relative_to(experiment_root)
+            current = run_root
+            for part in ("experiments", seq, *relative.parts):
+                current = current / part
+                if current.is_symlink():
+                    raise TechnicalVerificationError(
+                        "experiment cwd contains a symlink"
+                    )
+            if not cwd.is_dir() or cwd.is_symlink():
+                errors.append(f"{check['id']}: experiment cwd must be a directory")
+        except (OSError, ValueError) as exc:
+            errors.append(f"{check['id']}: invalid execution evidence: {exc}")
+        if check.get("status") == "supported" and command.get("exitCode") != 0:
+            errors.append(f"{check['id']}: a supported result has a failed command")
+    return errors
+
+
+def validate_technical_verification_report(
+    data: Mapping[str, Any], report_path: Path, project_root: Path
+) -> list[str]:
+    """발행·최종 검증에서 같은 사실 집합과 실제 시험 산출물을 대조한다."""
+    if (data.get("header") or {}).get("taskType") != "technical-verification":
+        return []
+    match = re.fullmatch(
+        r"final-report-technical-verification-(\d{3,})\.data\.json", report_path.name
+    )
+    if match is None:
+        return ["technical verification report must use its canonical record path"]
+    run_root = report_path.parent.parent
+    path = run_root / "state" / f"technical-verification-input-{match[1]}.json"
+    try:
+        validate_task_artifact_path(path, run_root, "technical verification input")
+        source = load_owned_object_snapshot(
+            path, artifact="technical verification input"
+        ).value
+    except (OSError, ValueError) as exc:
+        return [str(exc)]
+    block = data.get("technicalVerification") or {}
+    errors = []
+    for key in ("sourceReport", "sourceDataSha256", "scope"):
+        if block.get(key) != source.get(key):
+            errors.append(f"technicalVerification.{key} must match the run input")
+    expected = {fact["id"]: fact for fact in source["facts"]}
+    checks = block.get("checks") or []
+    ids = [check.get("id") for check in checks]
+    if len(ids) != len(set(ids)) or set(ids) != set(expected):
+        errors.append(
+            "technicalVerification.checks must cover each input fact exactly once"
+        )
+    for check in checks:
+        fact = expected.get(check.get("id"))
+        if fact is None:
+            continue
+        for key in ("candidateId", "factIndex", "fact"):
+            if check.get(key) != fact[key]:
+                errors.append(f"{check['id']}: {key} must preserve the input fact")
+        errors.extend(
+            _check_execution_evidence(check, project_root, run_root, match[1])
+        )
+    if (block.get("routing") or {}).get(
+        "nextTaskType"
+    ) != "implementation-option-selection":
+        errors.append(
+            "technical verification returns only to implementation-option-selection"
+        )
+    return errors

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,