okstra 0.161.0 → 0.162.1

package/docs/cli.md

@@ -19,6 +19,7 @@
 - [Optional arguments and options](#optional-arguments-and-options)
   - [`--task-key`](#--task-key)
   - [`--clarification-response`](#--clarification-response)
+  - [`--reverify-scope`](#--reverify-scope)
   - [`--resume-clarification`](#--resume-clarification)
   - [`--project-root`](#--project-root)
   - [`--analysis-target`](#--analysis-target)
@@ -249,6 +250,18 @@ scripts/okstra.sh \
   --clarification-response .okstra/tasks/tasks/8852/runs/2026-04-29/error-analysis/reports/final-report-2026-04-29_10-15-30.md
 ```
 
+### `--reverify-scope`
+
+Pins how much of an `implementation-planning` clarification re-run is verified again. Like `--analysis-target` and `--evidence-inputs`, this is an internal `node bin/okstra render-bundle` input collected by the `/okstra-run` wizard — `scripts/okstra.sh` does not accept it.
+
+- Accepted values — exactly three forms; anything else is rejected rather than read as a default:
+  - `auto` (or empty, the default) — leave the call to the lead's deterministic `okstra incremental-scope` decision.
+  - `full` — re-verify every stage. The lead still records the decision, passing `--full-reason "user requested full re-verification"`.
+  - a stage-number list such as `2,3` — the named stages enter the lead's `--impacted` set, unioned with whatever it resolves itself. The CLI's dependency closure and cutoff still apply on top, so a wide enough pin correctly resolves to full.
+- Requires `--clarification-response`, and only `--task-type implementation-planning` accepts a non-empty value. Without a carried report there is no prior Stage Map to narrow against.
+- The wizard asks for this **only when the re-run is narrowable** — that is, when every answered `C-NNN` traces back to a stage in the prior report. When one does not, full is already fixed and the confirmation block's `reverify-scope` line names the unlinked id instead of offering a choice that cannot change the outcome. Direct stage input is validated against the prior report's Stage Map, so a number that plan never had is refused at the prompt.
+- The value reaches the lead as the `REVERIFY_SCOPE_MODE` / `REVERIFY_SCOPE_STAGES` tokens the "Clarification Response Carried In" section of the lead prompt reads. It narrows or widens the inputs to `okstra incremental-scope`; it does not bypass that decision.
+
 ### `--resume-clarification`
 
 Immediately edits the final report from the previous `requirements-discovery` or `error-analysis` run and automatically reruns the same phase. You do not need to manage the `--clarification-response` path manually.
@@ -394,9 +407,10 @@ worker roster contains Claude, Codex, or Antigravity.
 
 `okstra run` defaults to `auto`. `auto` resolves to one of `claude-code`, `codex`, `antigravity`, or `external` based on the host through `src/lib/runtime-resolver.mjs`. Precedence: explicit runtime > the `OKSTRA_RUNTIME_HOST` environment variable > Claude Code skill handoff > external when tmux is available > fail fast otherwise. The safe fallback never silently selects a runtime different from the user's intent, and the presence of the `agy` binary alone never selects the Antigravity host.
 
-- Inside Claude Code, `/okstra-run` is the front door. Bare `okstra run` cannot invoke host-native Claude workers.
-- On a Codex host, the installed `okstra-run` skill is the front door. Bare `okstra run` cannot invoke host-native Codex workers.
-- On an Antigravity host, the installed `okstra-run` skill is the front door. Bare `okstra run` cannot invoke host-native Antigravity workers.
+- Inside a supported host, the installed `okstra-run` skill is the front door and reuses the session you are already in.
+- From a terminal, `okstra run <lead>` starts that lead itself: `okstra run` (Claude Code), `okstra run codex`, `okstra run antigravity`. The leading word is an alias for `--lead-runtime`.
+- `okstra run external` does not start a lead — it orchestrates an all-CLI run through `okstra team`.
+- Starting a lead whose CLI sandboxes itself prints what is given up and waits for a `y`; `--yes` answers it. Today only Codex asks, because a sandboxed lead can reach neither cmux nor the worker CLIs' own configuration.
 - In a generic terminal with tmux, `okstra run` orchestrates `render-bundle --lead-runtime external` -> `okstra team dispatch` -> `okstra team await`.
 
 `doctor` and `render-bundle` also default to `auto`, but a plain terminal without a host signal must specify a host. `okstra install` and `ensure-installed` are exceptions. Installation places the shared runtime and skill targets based on agent homes rather than the runtime host, so it records the `auto` request and unresolved state in the manifest and continues even without a host signal. Skill copy targets depend on the presence of agent homes and the default Agent target policy, not runtime resolution. `~/.agents/skills/` is always created, and Claude skills/agents are installed when `~/.claude` exists. The host-aware `okstra-run` skill passes the current harness runtime explicitly; Claude-only maintenance skills continue to pass `--runtime claude-code` where that host is part of their contract.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "okstra",
-  "version": "0.161.0",
+  "version": "0.162.1",
   "description": "Host-aware multi-provider cross-verification orchestrator runtime and agent skills.",
   "license": "MIT",
   "author": "devonshin",

package/runtime/BUILD.json

@@ -1,5 +1,5 @@
 {
-  "package": "0.161.0",
-  "builtAt": "2026-08-08T16:14:31.788Z",
+  "package": "0.162.1",
+  "builtAt": "2026-08-08T18:29:02.245Z",
   "repoRoot": "/home/runner/work/okstra/okstra"
 }

package/runtime/bin/lib/okstra/interactive.sh

@@ -59,14 +59,14 @@ resolve_task_root_for_shortcut() {
   local task_id="$4"
 
   local resolved=""
-  resolved="$(python3 - "$WORKSPACE_ROOT/scripts" "$project_root" "$project_id" "$task_group" "$task_id" <<'PY'
+  resolved="$(python3 - "$OKSTRA_PYTHONPATH" "$project_root" "$project_id" "$task_group" "$task_id" <<'PY'
 import json, os, sys
 from pathlib import Path
 
 # task root 의 slug 경로 구성은 okstra_ctl.paths.task_dir(SSOT) 에 위임한다.
 # 과거 이 heredoc 은 slugify 와 `.okstra/tasks/<slug>/<slug>` 구조를 자체
 # 재구현해 규칙 변경 시 silent drift 위험이 있었다. project-resolver.sh 와
-# 동일하게 $WORKSPACE_ROOT/scripts 를 sys.path 에 올려 패키지를 import 한다.
+# 동일하게 $OKSTRA_PYTHONPATH 를 sys.path 에 올려 패키지를 import 한다.
 sys.path.insert(0, sys.argv[1])
 from okstra_ctl.paths import task_dir
 
@@ -176,7 +176,7 @@ autofill_from_manifest() {
     return 0
   fi
 
-  PYTHONPATH="$WORKSPACE_ROOT/scripts:${PYTHONPATH-}" python3 - "$manifest_project_root" "$manifest_task_root" <<'PY' || true
+  PYTHONPATH="$OKSTRA_PYTHONPATH:${PYTHONPATH-}" python3 - "$manifest_project_root" "$manifest_task_root" <<'PY' || true
 import sys
 from pathlib import Path
 
@@ -298,7 +298,7 @@ find_latest_final_report() {
   }
 
   local found=""
-  found="$(PYTHONPATH="$WORKSPACE_ROOT/scripts:${PYTHONPATH-}" python3 - \
+  found="$(PYTHONPATH="$OKSTRA_PYTHONPATH:${PYTHONPATH-}" python3 - \
              "$task_root" "$task_type_filter" <<'PY'
 import sys
 from okstra_ctl.paths import RunRef
@@ -397,7 +397,7 @@ PY
   local resume_extra_args=()
   while IFS= read -r -d '' _arg; do
     resume_extra_args+=("$_arg")
-  done < <(PYTHONPATH="$WORKSPACE_ROOT/scripts:${PYTHONPATH-}" python3 - \
+  done < <(PYTHONPATH="$OKSTRA_PYTHONPATH:${PYTHONPATH-}" python3 - \
              "$PROJECT_ROOT" "$TASK_GROUP" "$TASK_ID" "$resolved_type" <<'PY'
 import sys
 from okstra_ctl.run_context import latest_run_inputs

package/runtime/bin/lib/okstra/project-resolver.sh

@@ -9,7 +9,7 @@
 # strict/safe 두 종류를 분리한다.
 resolve_project_root_strict() {
   local explicit="${1-}"
-  python3 - "$WORKSPACE_ROOT/scripts" "$explicit" <<'PY'
+  python3 - "$OKSTRA_PYTHONPATH" "$explicit" <<'PY'
 import os, sys
 sys.path.insert(0, sys.argv[1])
 from okstra_project import resolve_project_root, ResolverError
@@ -26,7 +26,7 @@ PY
 # 실패해도 0 으로 종료하고 stdout 은 빈 문자열(autofill 등 best-effort 경로용).
 resolve_project_root_safe() {
   local explicit="${1-}"
-  python3 - "$WORKSPACE_ROOT/scripts" "$explicit" <<'PY'
+  python3 - "$OKSTRA_PYTHONPATH" "$explicit" <<'PY'
 import os, sys
 sys.path.insert(0, sys.argv[1])
 from okstra_project import resolve_project_root, ResolverError
@@ -43,7 +43,7 @@ PY
 upsert_project_json() {
   local project_root="$1"
   local project_id="$2"
-  python3 - "$WORKSPACE_ROOT/scripts" "$project_root" "$project_id" <<'PY'
+  python3 - "$OKSTRA_PYTHONPATH" "$project_root" "$project_id" <<'PY'
 import sys
 sys.path.insert(0, sys.argv[1])
 from pathlib import Path

package/runtime/bin/okstra.sh

@@ -37,8 +37,25 @@ source "$SCRIPT_DIR/lib/okstra/interactive.sh"
 # shellcheck disable=SC1090
 source "$SCRIPT_DIR/lib/okstra/project-resolver.sh"
 
+# The python packages live at `scripts/` in the repo and at `lib/python/` once
+# installed, and this script runs from both. Assuming the repo layout made the
+# installed launcher die on its first import; that went unnoticed because
+# in-host runs reach python through the Node CLI instead of through here.
+OKSTRA_PYTHONPATH=""
+for candidate in "scripts" "python" "lib/python"; do
+  if [[ -d "$WORKSPACE_ROOT/$candidate/okstra_project" ]]; then
+    OKSTRA_PYTHONPATH="$WORKSPACE_ROOT/$candidate"
+    break
+  fi
+done
+if [[ -z "$OKSTRA_PYTHONPATH" ]]; then
+  printf 'okstra: python package not found under %s — run '"'"'okstra install'"'"'\n' \
+    "$WORKSPACE_ROOT" >&2
+  exit 1
+fi
+
 okstra_py() {
-  PYTHONPATH="$WORKSPACE_ROOT/scripts:${PYTHONPATH-}" python3 "$@"
+  PYTHONPATH="$OKSTRA_PYTHONPATH:${PYTHONPATH-}" python3 "$@"
 }
 
 parse_cli_arguments "$@"
@@ -153,24 +170,60 @@ fi
 # Display summary lines to user (everything except the machine-readable line).
 printf '%s\n' "$PREPARE_OUTPUT" | grep -v '^__OKSTRA_LAUNCH__ '
 
-if ! command -v claude >/dev/null 2>&1; then
-  printf 'claude command not found\n' >&2
-  exit 1
-fi
-
-# Parse launch JSON and exec claude.
+# Parse launch metadata. Everything provider-specific — which executable, which
+# flags, whether a sandbox must be waived — is decided by the model catalog and
+# arrives already assembled, so this wrapper stays a thin adapter.
 LAUNCH_JSON="$(printf '%s\n' "$PREPARE_OUTPUT" | sed -n 's/^__OKSTRA_LAUNCH__ //p' | tail -n1)"
 if [[ -z "$LAUNCH_JSON" ]]; then
   printf 'okstra: prepare_task_bundle did not emit launch metadata\n' >&2
   exit 1
 fi
 
-# Read fields via python (jq not assumed available).
-read -r CLAUDE_SESSION_ID LEAD_MODEL_EXECUTION_VALUE PROJECT_ROOT_FROM_PY PROMPT_FILE < <(
+read -r LEAD_EXECUTABLE PROJECT_ROOT_FROM_PY < <(
   okstra_py - "$LAUNCH_JSON" <<'PY'
 import json, sys
 d = json.loads(sys.argv[1])
-print(d["claudeSessionId"], d["leadModelExecutionValue"], d["projectRoot"], d["promptFile"])
+print(d["leadExecutable"], d["projectRoot"])
+PY
+)
+
+if ! command -v "$LEAD_EXECUTABLE" >/dev/null 2>&1; then
+  printf '%s command not found\n' "$LEAD_EXECUTABLE" >&2
+  exit 1
+fi
+
+# Starting some leads means lowering a protection that CLI applies to itself.
+# okstra never waives it silently: the note says what is given up, and nothing
+# starts without an explicit yes.
+SANDBOX_NOTE="$(
+  okstra_py - "$LAUNCH_JSON" <<'PY'
+import json, sys
+print(json.loads(sys.argv[1])["sandboxWaiverNote"])
+PY
+)"
+if [[ -n "$SANDBOX_NOTE" ]]; then
+  printf '\n%s\n' "$SANDBOX_NOTE" >&2
+  if [[ "$ASSUME_YES" == "true" ]]; then
+    printf 'Proceeding without the sandbox (--yes).\n\n' >&2
+  else
+    printf 'Start %s without its sandbox? [y/N] ' "$LEAD_EXECUTABLE" >&2
+    read -r SANDBOX_ANSWER < /dev/tty || SANDBOX_ANSWER=""
+    if [[ "$SANDBOX_ANSWER" != "y" && "$SANDBOX_ANSWER" != "Y" ]]; then
+      printf 'okstra: cancelled. The task bundle is prepared; rerun to resume it.\n' >&2
+      exit 1
+    fi
+  fi
+fi
+
+# NUL-separated so a prompt carrying newlines or quotes survives the handoff.
+LAUNCH_ARGV=()
+while IFS= read -r -d '' LAUNCH_ARG; do
+  LAUNCH_ARGV+=("$LAUNCH_ARG")
+done < <(
+  okstra_py - "$LAUNCH_JSON" <<'PY'
+import json, sys
+for arg in json.loads(sys.argv[1])["launchArgv"]:
+    sys.stdout.write(arg + "\0")
 PY
 )
 
@@ -178,8 +231,5 @@ PY
 # provisions <PROJECT_ROOT>/.claude/settings.local.json as a symlink to
 # ~/.okstra/templates/settings.local.json, which Claude Code auto-loads
 # whenever it runs inside that project — no CLI flag required.
-PROMPT="$(cat "$PROMPT_FILE")"
 cd "$PROJECT_ROOT_FROM_PY"
-CLAUDE_COMMAND=(claude --model "$LEAD_MODEL_EXECUTION_VALUE" --session-id "$CLAUDE_SESSION_ID")
-CLAUDE_COMMAND+=("$PROMPT")
-exec "${CLAUDE_COMMAND[@]}"
+exec "${LAUNCH_ARGV[@]}"

package/runtime/prompts/launch.template.md

@@ -100,6 +100,10 @@ Emit one `PROGRESS: <phase-id> <verb-phrase>` line as plain user-facing text at
 
 The **default is full re-verification**. Only narrow this re-run to the impacted stages when the deterministic `okstra incremental-scope` CLI returns `mode == "incremental"`; on any doubt, stay full. This procedure fires ONLY when this run's task-type is `implementation-planning` AND a prior final report exists for this task-key (its data.json at `runs/implementation-planning/reports/final-report-implementation-planning-<prev-seq>.data.json`, where `<prev-seq>` is the most recent prior implementation-planning run's seq). For every other task-type, ignore this block and re-verify normally. This branches on the CLI's `mode` output only — it does NOT re-implement the safety logic in the prompt.
 
+0. **Honour the scope the user already pinned (not a judgement — an instruction).** The wizard asks for a re-verification scope whenever this re-run is narrowable, and the answer arrives as two tokens: mode `{{REVERIFY_SCOPE_MODE}}`, stages `{{REVERIFY_SCOPE_STAGES}}`. Apply it before you form your own view:
+   - `auto` — the user left the decision to this procedure. Run steps 1–6 exactly as written; nothing is pinned.
+   - `full` — the user asked for full re-verification. Still call the CLI once (the record is the audit trail), passing `--full-reason "user requested full re-verification"` and every other CSV empty. Do not argue the user out of it with a narrower `--impacted`: the answer already weighed the cost.
+   - `stages` — the user named the stages that must be re-verified. Put **every** number in `{{REVERIFY_SCOPE_STAGES}}` into `--impacted`, unioned with any stage you resolve yourself. Never drop one because your own back-trace did not reach it — the user is telling you about a blast radius the prior report failed to record, which is exactly what the back-trace cannot see. The CLI still applies the dependency closure and the cutoff on top, so a wide enough pin correctly ends in `mode == "full"`.
 1. **List the answered clarifications (a fact, not a judgement).** Collect the `C-NNN` ids you reconciled as answered in §1, and the IDs of any PREP items changed by the carried response. Pass the ids through `--answered-clarifications`; the CLI resolves which Stage Map stages each one touches by reading the prior run's own links — the `P-*` plan item that carried that `clarificationId`, and the requirement-coverage row blocked on `C-NNN` in either its `status` or its `approvalDisposition` (a `documented-deviation` row records the block in the latter). Do NOT map answers to stage numbers yourself.
    - An id that traces to no stage in the prior report makes the CLI return `mode == "full"` for the whole re-run. That is the intended outcome: an answer whose blast radius the prior report never recorded must not narrow anything.
    - **Structural change is your call, and you declare it.** When an answer overturns the selected Option, restructures the stages, or changes the recommended approach, pass `--full-reason "<what changes and how>"`. It forces `mode == "full"` regardless of every other input — the back-trace resolves stages, it cannot judge whether the plan's shape survived. Do NOT express this by leaving the CSVs empty: that produces the same `no impacted stages resolved` reason as a re-run that simply failed to map anything, and the two become indistinguishable in the record. `--impacted` remains available for stage numbers you resolved yourself.

package/runtime/prompts/profiles/implementation-planning.md

@@ -63,7 +63,7 @@
   - Phase 5.5 finding convergence runs in **adversarial mode** for this phase (`convergence.adversarial=true`). Verifiers actively try to refute each worker finding (requirement gap / risk / option) by re-inspecting its cited evidence; the burden of proof sits on the claim. See `prompts/lead/convergence.md` §"Adversarial Verification Mode".
   - §5.5.9 plan-body verification runs with an **adversarial posture** (`prompts/lead/plan-body-verification.md` §"Adversarial plan-body posture"): verifiers open and confirm every cited path / command and put the burden of proof on the plan. The gate threshold is majority-based for kinds `b`/`c`/`e`, but a single `DISAGREE` blocks on its own for the concrete, safety-critical kind `a` (path/symbol mismatch) — and `f` on `P-Req-*` items. `P-Var-*` items are excepted from the kind-`a` exception: a variation-point defect takes a majority. Rollback ordering (`d`) is advisory and never blocks the gate — a rollback is executed by a human, not by okstra's workers or verifiers. A majority also needs ≥2 participating votes, so a lone dissent whose peer returned a non-result does not block on a majority-gated kind (see that contract's §"Adversarial plan-body posture").
   - **Incremental re-verification scope (clarification re-runs):** when the lead's `okstra incremental-scope` decision is `mode == "incremental"` (procedure in `prompts/launch.template.md` §"Clarification Response Carried In"), workers re-analyze ONLY the stages listed in `reverify_stages` (the downstream closure of the impacted stages). Workers MUST NOT re-open, re-score, or re-judge any stage in `carry_stages` — those stages' prior plan-item verdicts are carried forward verbatim, and a worker never overwrites a carried verdict with its own judgement. When the decision is `mode == "full"` (the default), every stage is re-analyzed as usual.
-  - **Single incremental-scope decision:** the lead calls `okstra incremental-scope` exactly once for the re-run, passing the answered `C-NNN` ids through `--answered-clarifications`, changed design-preparation IDs through `--prep-items`, and any lead-resolved stage numbers through `--impacted`; the CLI unions all three before applying the existing dependency closure and cutoff. The clarification ids are resolved to stages by the CLI from the prior report's own `planItems[].clarificationId` and `blocked C-NNN` coverage links — the lead does not map answers to stage numbers. An answer that changes the selected option, Stage Map, or recommended approach is not a local impact: pass every CSV empty so the same call returns `mode == "full"`. A clarification id that traces to no stage, unknown PREP IDs, or invalid `stageRefs` also return an explicit full decision instead of being guessed.
+  - **Single incremental-scope decision:** the lead calls `okstra incremental-scope` exactly once for the re-run, passing the answered `C-NNN` ids through `--answered-clarifications`, changed design-preparation IDs through `--prep-items`, and any lead-resolved stage numbers through `--impacted`; the CLI unions all three before applying the existing dependency closure and cutoff. The clarification ids are resolved to stages by the CLI from the prior report's own `planItems[].clarificationId` and `blocked C-NNN` coverage links — the lead does not map answers to stage numbers. An answer that changes the selected option, Stage Map, or recommended approach is not a local impact: pass every CSV empty so the same call returns `mode == "full"`. A clarification id that traces to no stage, unknown PREP IDs, or invalid `stageRefs` also return an explicit full decision instead of being guessed. When the user pinned a scope at the wizard (`REVERIFY_SCOPE_MODE` / `REVERIFY_SCOPE_STAGES` in `prompts/launch.template.md` §"Clarification Response Carried In" step 0), that pin is an input to this same single call — `full` supplies the `--full-reason`, and pinned stage numbers join `--impacted` — never a second call or a bypass of the CLI's closure and cutoff.
   - **Stage-aware carry:** for an incremental decision, pass its `carry_stages` and `reverify_stages` CSVs unchanged to `okstra incremental-carry`. The helper carries the prior whole stage rows and their owned PREP / `P-Prep-*` artifacts; overlap, cross-scope ownership, scope leaks, or canonical conflicts return `CarryError`. On that error, discard the partial merge and run full re-verification.
 {{INCLUDE:_coverage-critic.md}}
 - Non-goals:

package/runtime/prompts/wizard/prompts.ko.json

@@ -398,6 +398,31 @@
         "latest_report": "clarification: {value} (재사용)"
       }
     },
+    "reverify_scope_pick": {
+      "label": "재검증 범위를 어떻게 할까요? (답변한 항목이 모두 직전 리포트의 stage 에 연결돼 있어 범위를 좁힐 수 있는 상태입니다 — 최종 확정은 run 시점 base-ref 비교)",
+      "echo_template": "reverify-scope: {value}",
+      "options": {
+        "auto": "관련 stage 만 (추천) — 답변이 닿는 stage 와 그 하위만 다시 검증하고 나머지는 직전 판정을 그대로 이월",
+        "full": "전체 재검증 — stage 전부를 처음부터 다시 교차검증 (시간은 더 들지만 계획 형태가 바뀌었을 때 안전)",
+        "__free_input__": "직접 입력 — 다시 볼 stage 번호를 지정"
+      },
+      "echo_suffixes": {
+        "auto": "reverify-scope: auto (좁힐 수 있으면 좁힘)",
+        "full": "reverify-scope: full (전체 재검증)"
+      }
+    },
+    "reverify_scope_stages": {
+      "label": "다시 볼 stage 번호를 쉼표로 입력하세요 (예: 2,3 — 직전 리포트 Stage Map 에 있는 번호만 유효. 지정한 stage 의 하위 stage 까지 함께 재검증됩니다. 빈 줄이면 자동 판정)",
+      "echo_template": "reverify-scope: stage {value}",
+      "echo_suffixes": {
+        "auto": "reverify-scope: auto (좁힐 수 있으면 좁힘)"
+      },
+      "errors": {
+        "not_a_number": "stage 번호는 정수여야 합니다: {token}",
+        "unknown_stage": "직전 리포트의 Stage Map 에 없는 stage 입니다: {stages} (Stage Map 의 번호: {known})",
+        "no_stage_map": "직전 리포트에서 Stage Map 을 읽을 수 없어 stage 번호를 검증할 수 없습니다: {reason}"
+      }
+    },
     "pr_template_pick": {
       "label": "PR 본문 템플릿 경로를 직접 지정할까요?",
       "echo_template": "pr-template(pick): {value}",
@@ -567,6 +592,8 @@
     "reverify_scope_incremental": "  reverify-scope: incremental 가능 — 답변된 항목이 모두 직전 리포트의 stage 에 연결됨 (최종 확정은 run 시점 base-ref 비교)",
     "reverify_scope_unlinked": "  reverify-scope: full 예상 — {ids} 이(가) 직전 리포트의 어느 stage 에도 연결되지 않아 범위를 좁힐 수 없음",
     "reverify_scope_full": "  reverify-scope: full 예상 — {reason}",
+    "reverify_scope_user_full": "  reverify-scope: full (사용자 지정 — 전체 재검증)",
+    "reverify_scope_user_stages": "  reverify-scope: stage {stages} 재검증 지정 (사용자 지정 — 하위 stage 포함, 나머지는 직전 판정 이월)",
     "stage_whole_task": "전체 task",
     "handoff_scope_whole_task": "전체 task (whole-task 검증 기반)",
     "handoff_scope_stage_group": "stage-group ({stages})"

package/runtime/python/okstra_ctl/cmux.py

@@ -10,6 +10,7 @@ import json
 import os
 import shlex
 import shutil
+import socket
 import subprocess
 from dataclasses import dataclass
 from pathlib import Path
@@ -44,6 +45,25 @@ LEAD_TARGET_COLUMNS = 80
 # Sidebar entries are keyed by source so tools do not overwrite each other's.
 SIDEBAR_SOURCE = "okstra"
 
+# Why a run that prepare recorded as cmux can no longer see cmux. Kept apart
+# because they call for opposite responses: a sanitized environment or a denied
+# socket means a sandbox stands in the way and the fallback is doomed with it,
+# while a quit app leaves the worker CLIs perfectly able to run.
+LOST_NOTHING = ""
+LOST_ENVIRONMENT = "environment"
+LOST_DENIED = "denied"
+LOST_GONE = "gone"
+
+# Verdicts from `socket_reachability`. `denied` is the one that matters: it
+# means a sandbox stands between this process and cmux, and the same sandbox
+# hides the worker CLIs' own config, so falling back is already doomed.
+SOCKET_OK = "ok"
+SOCKET_DENIED = "denied"
+SOCKET_MISSING = "missing"
+SOCKET_UNREACHABLE = "unreachable"
+
+SOCKET_PROBE_TIMEOUT_SECONDS = 2
+
 
 def cmux_cli_path() -> str:
     """Absolute path to the cmux CLI, or "" when cmux is not installed.
@@ -301,6 +321,50 @@ def capture_surface(surface_uuid: str, *, last_lines: int = 200) -> str:
     return result.stdout if result.returncode == 0 else ""
 
 
+def socket_reachability() -> str:
+    """Why this process can or cannot reach cmux, decided at syscall level.
+
+    Separating a sandbox from a closed app without matching on cmux's error
+    text: a denied connect raises PermissionError, an absent socket raises
+    FileNotFoundError. The distinction decides whether degrading is worth
+    attempting at all.
+    """
+    path = os.environ.get("CMUX_SOCKET_PATH", "").strip()
+    if not path:
+        return SOCKET_MISSING
+    probe = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
+    try:
+        probe.settimeout(SOCKET_PROBE_TIMEOUT_SECONDS)
+        probe.connect(path)
+        return SOCKET_OK
+    except PermissionError:
+        return SOCKET_DENIED
+    except FileNotFoundError:
+        return SOCKET_MISSING
+    except OSError:
+        return SOCKET_UNREACHABLE
+    finally:
+        probe.close()
+
+
+def unreachable_reason() -> str:
+    """Why cmux cannot be reached from here, or "" when it can.
+
+    `environment` is the case a socket probe alone cannot see: a sandbox that
+    sanitizes the environment leaves no CMUX_* variables at all, so cmux looks
+    identical to a machine that never had it — except this run's manifest says
+    prepare reached it minutes ago.
+    """
+    if not _lead_workspace_env():
+        return LOST_ENVIRONMENT
+    reachability = socket_reachability()
+    if reachability == SOCKET_DENIED:
+        return LOST_DENIED
+    if reachability != SOCKET_OK:
+        return LOST_GONE
+    return LOST_NOTHING if resolve_lead_workspace() else LOST_GONE
+
+
 def sidebar_log(workspace: str, message: str, *, level: str = "info") -> None:
     """Append one line to the workspace sidebar's log."""
     _sidebar_call(

package/runtime/python/okstra_ctl/codex_dispatch.py

@@ -8,7 +8,6 @@ from __future__ import annotations
 
 import argparse
 import json
-import os
 import subprocess
 import sys
 from dataclasses import dataclass
@@ -762,18 +761,7 @@ def _run_cli_wrapper_worker(
     plan: DispatchPlan,
     worker: WorkerJob,
 ) -> subprocess.CompletedProcess[str]:
-    env = {
-        **os.environ,
-        "OKSTRA_WORKER_ID": worker.worker_id,
-        "OKSTRA_WORKER_RESULT_PATH": str(worker.result_path),
-        "OKSTRA_WORKER_AUDIT_PATH": str(worker.worker_result_path),
-        "OKSTRA_RUN_MANIFEST_PATH": str(plan.manifest_path),
-    }
-    if worker.worker_id == REPORT_WRITER_WORKER_ID:
-        env["OKSTRA_REPORT_WRITER_MARKDOWN_PATH"] = str(
-            _final_report_markdown_path(worker.result_path)
-        )
-    return subprocess.run(worker.command, cwd=plan.project_root, env=env, text=True)
+    return subprocess.run(worker.command, cwd=plan.project_root, text=True)
 
 
 def _post_process_report_writer_result(

package/runtime/python/okstra_ctl/dispatch_core.py

@@ -2,7 +2,6 @@
 from __future__ import annotations
 
 import json
-import os
 import subprocess
 import time
 from dataclasses import dataclass
@@ -445,6 +444,7 @@ def _start_job(plan: DispatchPlan, job: WorkerJob) -> WorkerHandle:
 def _start_cmux_or_degrade(plan: DispatchPlan, job: WorkerJob) -> WorkerHandle:
     workspace = cmux.resolve_lead_workspace()
     if not workspace:
+        _refuse_when_cmux_is_walled_off()
         return _run_cli_wrapper(plan, job, BACKEND_CMUX_PANE)
     try:
         surface_id = cmux.spawn_worker_surface(
@@ -477,17 +477,35 @@ def _start_tmux_or_degrade(plan: DispatchPlan, job: WorkerJob) -> WorkerHandle:
     return WorkerHandle(job, pane_id, None, status_path_for_prompt(job.prompt_path), "")
 
 
+def _refuse_when_cmux_is_walled_off() -> None:
+    """Stop rather than degrade when a sandbox stands between okstra and cmux.
+
+    prepare records `cmux-pane` only after reaching cmux, so losing it by
+    dispatch time means something came between. When the socket is present but
+    connecting is denied, that something is a sandbox around the lead — and the
+    same sandbox hides the worker CLIs' own config, so the fallback this would
+    otherwise take is already dead. Degrading here spends every worker's retry
+    budget on the same wall and leaves the user with three failures and no
+    explanation, which is exactly what it looks like when nothing happens.
+    """
+    reason = cmux.unreachable_reason()
+    if reason not in (cmux.LOST_ENVIRONMENT, cmux.LOST_DENIED):
+        return
+    observed = (
+        "this process has no cmux environment left — a sandbox sanitized it"
+        if reason == cmux.LOST_ENVIRONMENT
+        else "cmux is running but this process may not connect to its socket"
+    )
+    raise DispatchError(
+        f"this run was prepared for cmux panes, but {observed}. The same "
+        "sandbox blocks worker CLIs from their own config, so falling back to "
+        "blocking workers would fail too. Relaunch the lead outside a sandbox "
+        "(codex: `codex -s danger-full-access`)."
+    )
+
+
 def _run_cli_wrapper(plan: DispatchPlan, job: WorkerJob, degraded_from: str) -> WorkerHandle:
-    env = {
-        **os.environ,
-        "OKSTRA_WORKER_ID": job.worker_id,
-        "OKSTRA_WORKER_RESULT_PATH": str(job.result_path),
-        "OKSTRA_WORKER_AUDIT_PATH": str(job.worker_result_path),
-        "OKSTRA_RUN_MANIFEST_PATH": str(plan.manifest_path),
-    }
-    if job.worker_id == REPORT_WRITER_WORKER_ID:
-        env["OKSTRA_REPORT_WRITER_MARKDOWN_PATH"] = str(_final_report_markdown_path(job.result_path))
-    completed = subprocess.run(job.command, cwd=plan.project_root, env=env, text=True)
+    completed = subprocess.run(job.command, cwd=plan.project_root, text=True)
     return WorkerHandle(job, "", completed, status_path_for_prompt(job.prompt_path), degraded_from)
 
 

package/runtime/python/okstra_ctl/incremental_scope.py

@@ -42,6 +42,43 @@ class IncrementalDecision:
     reason: str
 
 
+@dataclass(frozen=True)
+class UserReverifyScope:
+    """What the user answered at the wizard's re-verification-scope step.
+
+    The lead still runs `okstra incremental-scope`; this only says which of the
+    CLI's inputs the user pinned. `auto` pins nothing.
+    """
+    mode: str  # "auto" | "full" | "stages"
+    stages: list[int]
+
+
+class ReverifyScopeError(ValueError):
+    """The `--reverify-scope` value is not one of the three accepted forms."""
+
+
+def parse_user_reverify_scope(raw: str) -> UserReverifyScope:
+    """`--reverify-scope` → the user's pinned scope.
+
+    Accepts exactly `""` / `auto`, `full`, or a comma-separated stage list.
+    Anything else raises rather than degrading to `auto`: a typo silently read
+    as "let the lead decide" would drop a full-re-verification request the user
+    made on purpose, and the run would look like it honoured it.
+    """
+    value = (raw or "").strip()
+    if not value or value == "auto":
+        return UserReverifyScope("auto", [])
+    if value == "full":
+        return UserReverifyScope("full", [])
+    tokens = [token.strip() for token in value.split(",") if token.strip()]
+    if not tokens or not all(token.isdigit() for token in tokens):
+        raise ReverifyScopeError(
+            f"--reverify-scope must be 'auto', 'full', or a stage-number list "
+            f"(e.g. '2,3'); got {raw!r}"
+        )
+    return UserReverifyScope("stages", sorted({int(token) for token in tokens}))
+
+
 def _parse_depends_on(cell: str) -> list[int]:
     text = (cell or "").strip()
     if not text or text == "(none)":

package/runtime/python/okstra_ctl/models.py

@@ -94,6 +94,26 @@ ANALYSIS_ROLES = frozenset({"analyser", "critic"})
 IMPLEMENTATION_ROLES = frozenset({"executor", "verifier"})
 
 
+@dataclass(frozen=True)
+class LeadLaunchSpec:
+    """How to start this provider's CLI as an interactive lead session.
+
+    The worker wrappers cannot serve here: they run one non-interactive turn and
+    exit, while a lead owns the session the user talks to. Empty `prompt_flag`
+    means the CLI takes the prompt positionally; empty `session_id_flag` means it
+    has no resumable session id and resumes from artifacts instead.
+    """
+
+    executable: str
+    model_flag: str
+    prompt_flag: str = ""
+    session_id_flag: str = ""
+    # Flags that lift the CLI's own sandbox, and what the user is agreeing to by
+    # accepting them. Empty when the CLI does not sandbox itself by default.
+    sandbox_waiver: tuple[str, ...] = ()
+    sandbox_waiver_note: str = ""
+
+
 @dataclass(frozen=True)
 class ProviderSpec:
     provider: str
@@ -102,6 +122,7 @@ class ProviderSpec:
     default_models: Mapping[str, str]
     wrapper: str
     supported_roles: frozenset[str]
+    lead_launch: Optional[LeadLaunchSpec] = None
 
 
 PROVIDERS = {
@@ -121,6 +142,11 @@ PROVIDERS = {
         supported_roles=frozenset(
             {"lead", "analyser", "critic", "executor", "verifier", "report-writer"}
         ),
+        lead_launch=LeadLaunchSpec(
+            executable="claude",
+            model_flag="--model",
+            session_id_flag="--session-id",
+        ),
     ),
     "antigravity": ProviderSpec(
         provider="antigravity",
@@ -133,6 +159,13 @@ PROVIDERS = {
         supported_roles=frozenset(
             {"lead", "analyser", "critic", "executor", "verifier"}
         ),
+        lead_launch=LeadLaunchSpec(
+            executable="agy",
+            model_flag="--model",
+            # Without this the prompt runs once and the session ends; okstra
+            # needs the lead to stay and drive the remaining phases.
+            prompt_flag="--prompt-interactive",
+        ),
     ),
     "codex": ProviderSpec(
         provider="codex",
@@ -145,6 +178,20 @@ PROVIDERS = {
         supported_roles=frozenset(
             {"lead", "analyser", "critic", "executor", "verifier", "report-writer"}
         ),
+        lead_launch=LeadLaunchSpec(
+            executable="codex",
+            model_flag="-m",
+            # A codex session sandboxes itself, and everything it spawns inherits
+            # that — okstra's dispatch and every worker CLI with it. Measured:
+            # the cmux socket returns EPERM and each worker dies unable to write
+            # its own config. A sandboxed lead cannot run okstra at all.
+            sandbox_waiver=("-s", "danger-full-access"),
+            sandbox_waiver_note=(
+                "codex will start without its filesystem and network sandbox, "
+                "which okstra needs so the lead can reach cmux and start worker "
+                "CLIs."
+            ),
+        ),
     ),
     "grok": ProviderSpec(
         provider="grok",
@@ -190,6 +237,46 @@ class UnknownProviderError(ValueError):
     """Raised when a requested provider is absent from the registry."""
 
 
+def lead_launch_spec(provider: str) -> LeadLaunchSpec:
+    """The launch spec for a provider that can lead, or an error naming why not."""
+    spec = provider_spec(provider)
+    if spec.lead_launch is None:
+        raise UnknownProviderError(
+            f"provider {provider!r} cannot act as a lead: no launch spec"
+        )
+    return spec.lead_launch
+
+
+def lead_launch_argv(
+    provider: str,
+    *,
+    model: str,
+    prompt: str,
+    session_id: str = "",
+    waive_sandbox: bool = True,
+) -> list[str]:
+    """The argv that starts this provider's CLI as the lead for one run.
+
+    The sandbox waiver is applied by default because a sandboxed lead cannot run
+    okstra at all — it reaches neither cmux nor the worker CLIs' own config. The
+    caller still owns telling the user and collecting their answer; passing
+    False produces the un-waived argv so a declined confirmation can show what
+    would otherwise have run.
+    """
+    launch = lead_launch_spec(provider)
+    argv = [launch.executable]
+    if waive_sandbox:
+        argv.extend(launch.sandbox_waiver)
+    if model:
+        argv.extend([launch.model_flag, model])
+    if session_id and launch.session_id_flag:
+        argv.extend([launch.session_id_flag, session_id])
+    if launch.prompt_flag:
+        argv.append(launch.prompt_flag)
+    argv.append(prompt)
+    return argv
+
+
 def provider_spec(provider: str) -> ProviderSpec:
     """Return one registered provider or fail before assignment/dispatch."""
     normalized = (provider or "").strip().lower()

package/runtime/python/okstra_ctl/run.py

@@ -46,6 +46,7 @@ from .clarification_items import (
     scan_approval_gate,
 )
 from .error_report import prior_run_error_digest
+from .incremental_scope import ReverifyScopeError, parse_user_reverify_scope
 from .qa_commands import format_errors as _format_qa_errors, validate_qa_commands
 from .material import (
     build_analysis_material,
@@ -65,6 +66,8 @@ from .model_discovery import normalize_execution_for_dispatch
 from .models import (
     ModelAssignment,
     default_model,
+    lead_launch_argv,
+    lead_launch_spec,
     provider_default_model,
     provider_ids,
     provider_spec,
@@ -373,6 +376,10 @@ class PrepareInputs:
     # 별개 채널이다.
     stages: str = ""
     clarification_response_path: str = ""  # absolute or empty
+    # implementation-planning 전용: 사용자가 고른 이번 재실행의 재검증 범위.
+    # "" / "auto" = 리드의 `okstra incremental-scope` 판정에 맡김, "full" =
+    # 전체 재검증 강제, "<stage csv>" = 그 stage 들을 impacted 로 지정.
+    reverify_scope: str = ""
     # release-handoff 전용: PR 본문 템플릿 1회성 override. 빈 문자열이면
     # project.json → global config → 스킬 디폴트 순으로 해석된다.
     pr_template_path: str = ""
@@ -1016,9 +1023,35 @@ def _validate_prepare_inputs(project_root: Path, inp: PrepareInputs) -> list:
         raise PrepareError(
             f"clarification response file not found: {inp.clarification_response_path}"
         )
+    _validate_reverify_scope(inp)
     return ctx_stage_map
 
 
+def _validate_reverify_scope(inp: PrepareInputs) -> None:
+    """A pinned re-verification scope is only actionable on a planning re-run.
+
+    Every other phase renders the tokens too (the template always reads them),
+    but nothing consumes them there — so a value outside the one phase that
+    acts on it is a caller mistake, not a preference to honour silently.
+    """
+    if not (inp.reverify_scope or "").strip():
+        return
+    if inp.task_type != "implementation-planning":
+        raise PrepareError(
+            "--reverify-scope is only meaningful with --task-type "
+            f"implementation-planning; got {inp.task_type}"
+        )
+    if not inp.clarification_response_path:
+        raise PrepareError(
+            "--reverify-scope needs --clarification-response: there is no prior "
+            "report to narrow re-verification against"
+        )
+    try:
+        parse_user_reverify_scope(inp.reverify_scope)
+    except ReverifyScopeError as exc:
+        raise PrepareError(str(exc)) from exc
+
+
 def _prepare_implementation_approved_plan(inp: PrepareInputs) -> list:
     """Apply approved-plan inputs only after canonical brief preflight succeeds."""
     if inp.approve_plan_ack or inp.implementation_option:
@@ -2276,6 +2309,21 @@ def _related_tasks_ctx(ctx: dict, inp: PrepareInputs) -> dict[str, str]:
     }
 
 
+def _reverify_scope_ctx(raw: str) -> dict[str, str]:
+    """Render tokens for the re-verification scope the user pinned.
+
+    Always emitted: the lead prompt reads both tokens unconditionally, and an
+    absent one is a render failure rather than a silent `auto`.
+    """
+    scope = parse_user_reverify_scope(raw)
+    return {
+        "REVERIFY_SCOPE_MODE": scope.mode,
+        "REVERIFY_SCOPE_STAGES": (
+            ",".join(str(num) for num in scope.stages) or "(none)"
+        ),
+    }
+
+
 def _model_ctx(models: "_ModelBindings") -> dict[str, str]:
     """Render tokens for every model binding this run resolved."""
     return {
@@ -2577,6 +2625,7 @@ def prepare_task_bundle(inp: PrepareInputs) -> PrepareOutputs:
         "CLAUDE_SESSION_ID": claude_session_id,
         "CLARIFICATION_RESPONSE_PATH": inp.clarification_response_path,
         "CLARIFICATION_RESPONSE_RELATIVE_PATH": clarification_relative,
+        **_reverify_scope_ctx(inp.reverify_scope),
         "BRIEF_FILE_PATH": str(inp.brief_path),
         "BRIEF_RELATIVE_PATH": brief_relative,
         **_model_ctx(models),
@@ -2761,6 +2810,17 @@ def main(argv: list[str]) -> int:
         ),
     )
     p.add_argument("--clarification-response", default="", dest="clarification_response_path")
+    p.add_argument(
+        "--reverify-scope",
+        default="",
+        dest="reverify_scope",
+        help=(
+            "implementation-planning 재실행 전용. 사용자가 고른 재검증 범위. "
+            "'' / 'auto' = 리드의 incremental-scope 판정에 맡김(기본), "
+            "'full' = 전체 재검증 강제, '<stage csv>' (예: '2,3') = 그 stage 를 "
+            "impacted 로 지정."
+        ),
+    )
     p.add_argument(
         "--pr-template-path",
         default="",
@@ -2870,6 +2930,7 @@ def main(argv: list[str]) -> int:
         stage=args.stage,
         stages=args.stages,
         clarification_response_path=clarification_abs,
+        reverify_scope=args.reverify_scope,
         pr_template_path=args.pr_template_path,
         render_only=args.render_only,
         approve_plan_ack=args.approve_plan_ack,
@@ -2903,19 +2964,38 @@ def main(argv: list[str]) -> int:
     else:
         print(f"okstra current run dir: {ctx['RUN_DIR']}")
         print(f"final report path: {ctx['FINAL_REPORT_PATH']}")
+        lead_runtime_name = ctx.get("LEAD_RUNTIME", "claude-code")
+        lead_provider = lead_runtime_info(lead_runtime_name).agent
+        launch = lead_launch_spec(lead_provider)
         print(f"lead model: {ctx['LEAD_MODEL']}")
         print(f"claude session id: {ctx['CLAUDE_SESSION_ID']}")
         print(f"resume command file: {ctx['CLAUDE_RESUME_COMMAND_PATH']}")
-        print("launch mode: interactive Claude handoff")
-        print(f"claude working directory: {ctx['PROJECT_ROOT']}")
+        print(f"launch mode: interactive {launch.executable} handoff")
+        print(f"lead working directory: {ctx['PROJECT_ROOT']}")
         print()
-        # In non-render-only mode emit a small JSON the bash wrapper can parse
-        # to build the `claude` exec command. Wrapper exec's; we don't.
+        # In non-render-only mode emit the JSON a front end needs to exec the
+        # lead. The argv is assembled here rather than in the caller so provider
+        # launch knowledge stays in the catalog and every front end — the bash
+        # wrapper and the Node CLI — starts the lead identically.
+        prompt_file = Path(ctx["INSTRUCTION_SET_PATH"]) / "lead-execution-prompt.md"
         machine = {
-            "claudeSessionId": ctx["CLAUDE_SESSION_ID"],
+            "leadRuntime": lead_runtime_name,
+            "leadProvider": lead_provider,
+            "leadExecutable": launch.executable,
+            "leadSessionId": ctx["CLAUDE_SESSION_ID"],
             "leadModelExecutionValue": ctx["LEAD_MODEL_EXECUTION_VALUE"],
             "projectRoot": ctx["PROJECT_ROOT"],
-            "promptFile": str(Path(ctx["INSTRUCTION_SET_PATH"]) / "lead-execution-prompt.md"),
+            "promptFile": str(prompt_file),
+            # Non-empty only when starting this lead lowers a protection the
+            # user should agree to first. The front end asks; okstra does not
+            # waive it silently.
+            "sandboxWaiverNote": launch.sandbox_waiver_note,
+            "launchArgv": lead_launch_argv(
+                lead_provider,
+                model=ctx["LEAD_MODEL_EXECUTION_VALUE"],
+                session_id=ctx["CLAUDE_SESSION_ID"],
+                prompt=prompt_file.read_text(encoding="utf-8"),
+            ),
         }
         print(f"__OKSTRA_LAUNCH__ {json.dumps(machine)}")
     return 0

package/runtime/python/okstra_ctl/wizard.py

@@ -56,7 +56,10 @@ from okstra_ctl.clarification_items import (
     sidecar_answers,
     user_response_sidecars,
 )
-from okstra_ctl.incremental_scope import preview_link_availability_for_report
+from okstra_ctl.incremental_scope import (
+    parse_stage_graph,
+    preview_link_availability_for_report,
+)
 from okstra_ctl.design_prep import (
     DesignPrepError,
     load_design_prep_items,
@@ -342,6 +345,8 @@ S_RELATED_TASKS_PICK = "related_tasks_pick"
 S_RELATED_TASKS = "related_tasks"
 S_CLARIFICATION_PICK = "clarification_pick"
 S_CLARIFICATION = "clarification"
+S_REVERIFY_SCOPE_PICK = "reverify_scope_pick"
+S_REVERIFY_SCOPE_STAGES = "reverify_scope_stages"
 S_PR_TEMPLATE_PICK = "pr_template_pick"
 S_PR_TEMPLATE = "pr_template"
 S_PR_TEMPLATE_SCOPE = "pr_template_scope"
@@ -473,6 +478,10 @@ class WizardState:
     clarification_response_path: str = ""
     clarification_pending_text: bool = False
     last_final_report_cached: str = ""
+    # "" | "auto" | "full" | "<stage csv>" — 사용자가 고른 이번 재실행의 재검증
+    # 범위. implementation-planning 재실행에서 좁힐 여지가 있을 때만 채워진다.
+    reverify_scope: str = ""
+    reverify_scope_pending_text: bool = False
     pr_template_path: str = ""
     pr_template_pending_text: bool = False
     pr_template_scope: str = ""  # "once" | "project" | "global"
@@ -3002,6 +3011,128 @@ def _submit_clarification_pick(state: WizardState, value: str) -> Optional[str]:
     return _submit_optional_cached_pick(state, value, _CLARIFICATION_PICK_SPEC)
 
 
+def _carried_planning_report(state: WizardState) -> Optional[Path]:
+    """이번 재실행이 이어받는 직전 implementation-planning 리포트 (없으면 None)."""
+    if state.task_type != "implementation-planning":
+        return None
+    if not state.clarification_response_path or not state.project_root:
+        return None
+    report = _resolve_path(
+        state.clarification_response_path, Path(state.project_root)
+    )
+    return report if report.is_file() else None
+
+
+def _reverify_scope_preview(state: WizardState) -> Optional[dict]:
+    """답변된 id 가 직전 리포트의 stage 로 되짚어지는지 — 범위 판정의 앞 절반."""
+    report = _carried_planning_report(state)
+    if report is None:
+        return None
+    return preview_link_availability_for_report(
+        report, set(sidecar_answers(report))
+    )
+
+
+def _reverify_scope_pick_required(state: WizardState) -> bool:
+    """좁힐 여지가 있는 재실행에서만 범위를 묻는다.
+
+    링크가 끊겨 full 이 이미 확정된 재실행에서 물으면 어떤 답도 판정을 바꾸지
+    못한다 — 고를 수 없는 선택지를 내미는 화면이 하나 느는 것뿐이다. 그 경우
+    확인 블록의 `reverify-scope: full 예상` 줄이 이유까지 같이 알려준다.
+    """
+    preview = _reverify_scope_preview(state)
+    return preview is not None and not preview["wouldForceFull"]
+
+
+def _reverify_scope_step_pending(state: WizardState) -> bool:
+    """범위 질문이 아직 안 끝났는가 — confirm 진입을 막는 게이트."""
+    if state.reverify_scope_pending_text:
+        return True
+    return _reverify_scope_pick_required(state) and not state.reverify_scope
+
+
+def _prior_stage_numbers(state: WizardState) -> set[int]:
+    """직전 리포트 Stage Map 의 stage 번호. 읽을 수 없으면 WizardError."""
+    t = _p(state.workspace_root, "reverify_scope_stages")
+    report = _carried_planning_report(state)
+    if report is None:
+        raise WizardError(
+            t["errors"]["no_stage_map"].format(reason="carried report not found")
+        )
+    data_path = final_report_data_path(report)
+    try:
+        data = json.loads(data_path.read_text(encoding="utf-8"))
+        stages = {num for num, _ in parse_stage_graph(data)}
+    except (OSError, ValueError, KeyError, TypeError) as exc:
+        raise WizardError(
+            t["errors"]["no_stage_map"].format(reason=str(exc))
+        ) from exc
+    if not stages:
+        raise WizardError(
+            t["errors"]["no_stage_map"].format(reason="stage map is empty")
+        )
+    return stages
+
+
+def _build_reverify_scope_pick(state: WizardState) -> Prompt:
+    t = _p(state.workspace_root, "reverify_scope_pick")
+    opts = t["options"]
+    return Prompt(
+        step=S_REVERIFY_SCOPE_PICK, kind="pick", label=t["label"],
+        options=[
+            _opt("auto", opts["auto"]),
+            _opt("full", opts["full"]),
+            _opt(PICK_TYPE_CUSTOM, opts[PICK_TYPE_CUSTOM]),
+        ],
+        echo_template=t["echo_template"])
+
+
+def _submit_reverify_scope_pick(state: WizardState, value: str) -> Optional[str]:
+    t = _p(state.workspace_root, "reverify_scope_pick")
+    picked = value.strip().lower()
+    if picked == PICK_TYPE_CUSTOM:
+        state.reverify_scope = ""
+        state.reverify_scope_pending_text = True
+        return "reverify-scope: 직접 입력"
+    if picked not in ("auto", "full"):
+        raise WizardError(
+            f"expected 'auto' / 'full' / {PICK_TYPE_CUSTOM!r}, got: {value!r}"
+        )
+    state.reverify_scope = picked
+    state.reverify_scope_pending_text = False
+    return t["echo_suffixes"][picked]
+
+
+def _build_reverify_scope_stages(state: WizardState) -> Prompt:
+    t = _p(state.workspace_root, "reverify_scope_stages")
+    return Prompt(
+        step=S_REVERIFY_SCOPE_STAGES, kind="text", label=t["label"],
+        echo_template=t["echo_template"])
+
+
+def _submit_reverify_scope_stages(state: WizardState, value: str) -> Optional[str]:
+    t = _p(state.workspace_root, "reverify_scope_stages")
+    tokens = [token.strip() for token in value.split(",") if token.strip()]
+    if not tokens:
+        state.reverify_scope = "auto"
+        state.reverify_scope_pending_text = False
+        return t["echo_suffixes"]["auto"]
+    for token in tokens:
+        if not token.isdigit():
+            raise WizardError(t["errors"]["not_a_number"].format(token=token))
+    known = _prior_stage_numbers(state)
+    picked = sorted({int(token) for token in tokens})
+    unknown = [num for num in picked if num not in known]
+    if unknown:
+        raise WizardError(t["errors"]["unknown_stage"].format(
+            stages=", ".join(str(num) for num in unknown),
+            known=", ".join(str(num) for num in sorted(known)),
+        ))
+    state.reverify_scope = ",".join(str(num) for num in picked)
+    state.reverify_scope_pending_text = False
+    return t["echo_template"].format(value=state.reverify_scope)
+
+
 def _suggest_project_pr_template(state: WizardState) -> str:
     """project.json 의 prTemplatePath 필드를 읽어 경로 문자열로 반환.
 
@@ -4232,14 +4363,32 @@ STEPS: list[Step] = [
                             and S_PR_TEMPLATE_SCOPE not in s.answered),
          build=_build_pr_template_scope, submit=_submit_pr_template_scope,
          owns=("pr_template_scope",)),
+    # 재검증 범위는 clarification-response 가 정해진 뒤에야 판정할 수 있고,
+    # 확인 블록은 full 재검증 비용을 물기 전 마지막 되돌림 지점이다. 그래서
+    # 이 질문은 confirm 바로 앞에 선다.
+    Step(S_REVERIFY_SCOPE_PICK,
+         applies=lambda s: (_ready_for_confirm(s)
+                            and not s.reverify_scope_pending_text
+                            and not s.reverify_scope
+                            and _reverify_scope_pick_required(s)),
+         build=_build_reverify_scope_pick, submit=_submit_reverify_scope_pick,
+         owns=("reverify_scope", "reverify_scope_pending_text")),
+    Step(S_REVERIFY_SCOPE_STAGES,
+         applies=lambda s: (s.reverify_scope_pending_text
+                            and S_REVERIFY_SCOPE_STAGES not in s.answered),
+         build=_build_reverify_scope_stages,
+         submit=_submit_reverify_scope_stages,
+         owns=("reverify_scope", "reverify_scope_pending_text")),
     Step(S_FIX_CYCLE_CONFIRM,
          applies=lambda s: (_ready_for_confirm(s)
+                            and not _reverify_scope_step_pending(s)
                             and _fix_cycle_confirm_required(s)
                             and not s.fix_cycle),
          build=_build_fix_cycle_confirm, submit=_submit_fix_cycle_confirm,
          owns=("fix_cycle",)),
     Step(S_CONFIRM,
          applies=lambda s: (_ready_for_confirm(s)
+                            and not _reverify_scope_step_pending(s)
                             and (not _fix_cycle_confirm_required(s)
                                  or bool(s.fix_cycle))
                             and s.confirmed is None),
@@ -4357,6 +4506,7 @@ _FIELD_DEFAULTS: dict[str, Any] = {
     "directive_pending_text": False,
     "related_tasks_raw": "", "related_tasks_pending_text": False,
     "clarification_response_path": "", "clarification_pending_text": False,
+    "reverify_scope": "", "reverify_scope_pending_text": False,
     "pr_template_path": "", "pr_template_pending_text": False,
     "pr_template_scope": "",
     "fix_cycle": "",
@@ -4650,31 +4800,34 @@ def render_args(state: WizardState) -> dict[str, str]:
         "report-writer-model": state.report_writer_model,
         "related-tasks": state.related_tasks_raw,
         "clarification-response": state.clarification_response_path,
+        "reverify-scope": (
+            state.reverify_scope
+            if state.task_type == "implementation-planning" else ""
+        ),
         "pr-template-path": pr_template,
         "fix-cycle": state.fix_cycle,
     }
 
 
 def _reverify_scope_line(state: WizardState) -> Optional[str]:
-    """이번 clarification 재실행이 좁혀질지 — 확인 단계에서 미리 보여주는 줄.
-
-    이 판정의 절반(답변된 id 가 stage 로 되짚어지는지)은 base SHA 없이 결정되고
-    직전 리포트만 있으면 이미 정해져 있다. 그런데 지금까지는 `okstra recap
-    assemble` 을 따로 돌려야만 보였고, run 이 시작된 뒤에 full 로 밝혀지면 두
-    시간을 물린 뒤였다. 확인 단계는 그 전에 되돌릴 수 있는 마지막 지점이다.
+    """이번 clarification 재실행이 좁혀질지 — 확인 단계에서 보여주는 줄.
+
+    사용자가 범위를 직접 골랐으면 그 선택을 찍는다. 고르지 않았으면(또는 좁힐
+    수 없어 질문 자체가 안 뜬 경우) 예측을 찍는다. 예측의 절반(답변된 id 가
+    stage 로 되짚어지는지)은 base SHA 없이 직전 리포트만으로 이미 정해져 있는데,
+    지금까지는 `okstra recap assemble` 을 따로 돌려야만 보였고 run 이 시작된 뒤
+    full 로 밝혀지면 두 시간을 물린 뒤였다. 확인 단계는 그 전에 되돌릴 수 있는
+    마지막 지점이다.
     """
-    if state.task_type != "implementation-planning":
-        return None
-    if not state.clarification_response_path or not state.project_root:
+    preview = _reverify_scope_preview(state)
+    if preview is None:
         return None
-    report = _resolve_path(
-        state.clarification_response_path, Path(state.project_root)
-    )
-    if not report.is_file():
-        return None
-    preview = preview_link_availability_for_report(
-        report, set(sidecar_answers(report))
-    )
+    if state.reverify_scope == "full":
+        return _msg(state.workspace_root, "confirmation",
+                    "reverify_scope_user_full")
+    if state.reverify_scope and state.reverify_scope != "auto":
+        return _msg(state.workspace_root, "confirmation",
+                    "reverify_scope_user_stages", stages=state.reverify_scope)
     if not preview["wouldForceFull"]:
         return _msg(state.workspace_root, "confirmation",
                     "reverify_scope_incremental")

package/runtime/skills/okstra-run/SKILL.md

@@ -142,6 +142,7 @@ That is the entire interactive flow. The wizard handles:
 - `release-handoff`-only sub-flow: after the approved plan auto-resolves, a `handoff_stage_pick` multi-select — choose an eligible stage bundle (stage-group) or the whole task (when an accepted whole-task verification report exists); the result goes out as render-args' `stages` key (csv, empty when whole-task),
 - `Use defaults / Customize` branch with profile-aware worker/model questions,
 - **resume-clarification (in-session equivalent)** — there is no separate mode or flag matching the shell's `okstra.sh --resume-clarification`; two steps of the standard flow carry out its substance. (1) `reuse_previous` (yes/no to reuse the previous run's settings — in `requirements-discovery` / `error-analysis` / `implementation-planning`, only when prior run-inputs exist): YES prefills workers·model·directive·related-tasks at once. (2) `clarification_pick`: if the **task-type's own** previous `final-report` exists it is auto-recommended as the carry-in input (falling back to the newest by mtime across all phases when absent), and the same run's `user-responses/` sidecar (answers the user filled in) is attached alongside. The chosen path is passed to prepare as `--clarification-response` — the user makes the sidecar via the report's `Export user response`, places it in `runs/<task-type>/user-responses/`, and re-runs the same phase,
+- **re-verification scope (`reverify_scope_pick`, `implementation-planning` clarification re-runs only)** — asked right before `confirm`, and **only when the re-run is narrowable** (every answered `C-NNN` traces back to a stage in the prior report). 3 options: `auto` (recommended — leave it to the lead's `okstra incremental-scope` decision) / `full` (re-verify every stage) / Enter directly (a stage-number CSV, validated against the prior report's Stage Map). The answer goes out as `--reverify-scope` and reaches the lead prompt as the `REVERIFY_SCOPE_MODE` / `REVERIFY_SCOPE_STAGES` tokens; it shapes that CLI's inputs rather than replacing the decision. When the re-run is not narrowable the step does not appear — full is already fixed, and the confirmation block's `reverify-scope` line says which answered id broke the link,
 - `release-handoff` PR template override + persist scope,
 - final `Proceed / Edit` confirmation; on `Edit` the wizard asks which step to rewind to and clears every later answer.
 

package/src/commands/execute/run.mjs

@@ -1,3 +1,7 @@
+import { spawnSync } from "node:child_process";
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+
 import { runEnsureInstalled } from "../lifecycle/install.mjs";
 import { runPythonModule } from "../../lib/python-helper.mjs";
 import { resolvePaths } from "../../lib/paths.mjs";
@@ -6,13 +10,31 @@ import { resolveRuntime } from "../../lib/runtime-resolver.mjs";
 const USAGE = `okstra run — host-aware okstra execution front door
 
 Usage:
-  okstra run --project-root <dir> --project-id <id> --task-group <tg> \\
-    --task-id <tid> --task-type <type> [--lead-runtime auto|claude-code|codex|antigravity|external]
-
-Host-native Claude Code, Codex, and Antigravity execution use the okstra-run
-skill front door. Bare 'okstra run' orchestrates only external/tmux all-CLI execution.
+  okstra run [claude|codex|antigravity|external] --project-root <dir> \\
+    --project-id <id> --task-group <tg> --task-id <tid> --task-type <type> \\
+    [--lead-runtime auto|claude-code|codex|antigravity|external] [--yes]
+
+The leading word selects the lead and is an alias for --lead-runtime, so
+'okstra run codex' starts a Codex lead. Naming a lead starts that CLI with the
+prepared prompt; 'external' instead orchestrates an all-CLI run through okstra
+team. Starting a lead whose CLI sandboxes itself asks for confirmation first,
+which --yes answers.
 `;
 
+// Leads okstra can start itself. `external` is not one: it names a harness
+// okstra does not own, so those runs are orchestrated rather than launched.
+const LAUNCHABLE_RUNTIMES = new Set(["claude-code", "codex", "antigravity"]);
+
+// The leading word users actually type. `claude` is the provider's name while
+// the runtime is `claude-code`; the rest coincide.
+const RUNTIME_ALIASES = new Map([
+  ["claude", "claude-code"],
+  ["claude-code", "claude-code"],
+  ["codex", "codex"],
+  ["antigravity", "antigravity"],
+  ["external", "external"],
+]);
+
 function flagValue(args, flag) {
   const equals = args.find((arg) => arg.startsWith(`${flag}=`));
   if (equals) return equals.slice(flag.length + 1);
@@ -20,14 +42,21 @@ function flagValue(args, flag) {
   return index >= 0 ? args[index + 1] : "";
 }
 
+export function positionalRuntime(args) {
+  const first = args[0];
+  if (!first || first.startsWith("-")) return "";
+  return RUNTIME_ALIASES.get(first) || "";
+}
+
 export function requestedRuntimeFromArgs(args) {
-  return flagValue(args, "--lead-runtime") || "auto";
+  return flagValue(args, "--lead-runtime") || positionalRuntime(args) || "auto";
 }
 
-export function withoutLeadRuntimeFlags(args) {
+export function withoutRuntimeSelection(args) {
+  const rest = positionalRuntime(args) ? args.slice(1) : args;
   const out = [];
-  for (let i = 0; i < args.length; i += 1) {
-    const arg = args[i];
+  for (let i = 0; i < rest.length; i += 1) {
+    const arg = rest[i];
     if (arg === "--lead-runtime") {
       i += 1;
       continue;
@@ -53,24 +82,17 @@ function renderArgs(args, resolution) {
     "--lead-runtime", resolution.resolvedRuntime,
     "--lead-runtime-request", resolution.requestedRuntime,
     "--runtime-resolution-json", JSON.stringify(resolution),
-    ...withoutLeadRuntimeFlags(args),
+    ...withoutRuntimeSelection(args),
   ];
 }
 
 export function buildRunPlan({ args, paths, resolution, runManifestPath = "" }) {
   void paths;
   const projectRoot = projectRootFromArgs(args);
-  if (resolution.resolvedRuntime === "claude-code") {
-    return {
-      ok: false,
-      reason: "Bare okstra run cannot invoke host-native Claude workers. Use the okstra-run skill in Claude Code or pass --lead-runtime external.",
-      commands: [],
-    };
-  }
-
   if (resolution.resolvedRuntime === "external") {
     return {
       ok: true,
+      kind: "team",
       reason: resolution.reason,
       commands: [
         { name: "render-bundle", args: renderArgs(args, resolution), capture: true },
@@ -80,19 +102,21 @@ export function buildRunPlan({ args, paths, resolution, runManifestPath = "" })
     };
   }
 
-  if (resolution.resolvedRuntime === "codex") {
-    return {
-      ok: false,
-      reason: "Bare okstra run cannot invoke host-native Codex workers. Use the okstra-run skill in Codex or pass --lead-runtime external for an all-CLI run.",
-      commands: [],
-    };
-  }
-
-  if (resolution.resolvedRuntime === "antigravity") {
+  if (LAUNCHABLE_RUNTIMES.has(resolution.resolvedRuntime)) {
     return {
-      ok: false,
-      reason: "Bare okstra run cannot invoke host-native Antigravity workers. Use the okstra-run skill in Antigravity or pass --lead-runtime external for an all-CLI run.",
-      commands: [],
+      ok: true,
+      kind: "launch-lead",
+      reason: resolution.reason,
+      // Handed to okstra.sh, which owns input collection and the launch. Only
+      // the runtime is decided here; everything else is passed through so the
+      // launcher can prompt for whatever is still missing.
+      commands: [
+        {
+          name: "launcher",
+          args: ["--lead-runtime", resolution.resolvedRuntime, ...withoutRuntimeSelection(args)],
+          capture: false,
+        },
+      ],
     };
   }
 
@@ -114,6 +138,27 @@ async function runRenderCommand(command, paths) {
   return result;
 }
 
+async function launchLead(command, paths) {
+  // okstra.sh already collects missing task inputs, prepares the bundle, asks
+  // about a sandbox waiver, and execs the lead. Reimplementing any of that here
+  // would give the two front doors separate answers to the same questions —
+  // most visibly, this one had no way to ask for a task id and simply forwarded
+  // the gap to python's argument parser.
+  const launcher = join(paths.bin, "okstra.sh");
+  if (!existsSync(launcher)) {
+    process.stderr.write(
+      `error: launcher not found at ${launcher} — run 'okstra install'\n`,
+    );
+    return 1;
+  }
+  const started = spawnSync(launcher, command.args, { stdio: "inherit" });
+  if (started.error) {
+    process.stderr.write(`error: could not start the launcher: ${started.error.message}\n`);
+    return 1;
+  }
+  return started.status ?? 1;
+}
+
 async function runTeam(args) {
   const { run: runTeamCommand } = await import("./team.mjs");
   return await runTeamCommand(args);
@@ -147,6 +192,10 @@ export async function run(args) {
   const ensureCode = await ensureRuntime(requestedRuntime);
   if (ensureCode !== 0) return ensureCode;
 
+  if (firstPlan.kind === "launch-lead") {
+    return await launchLead(firstPlan.commands[0], paths);
+  }
+
   const render = firstPlan.commands[0];
   const prepared = await runRenderCommand(render, paths);
   if (prepared.code !== 0) return prepared.code ?? 1;