okstra 0.225.0 → 0.226.0

package/runtime/python/okstra_ctl/run.py

@@ -55,7 +55,7 @@ from .phases.implementation_planning.entry import (
     _validate_reverify_scope,
 )
 from . import fix_cycles
-from .analysis_packet import build_analysis_packet
+from .analysis_packet import build_analysis_packet, cited_documents_block
 from .mcp_servers import NO_MCP_SERVERS_LINE, prepare_mcp
 from .coverage_census import (
     CensusError,
@@ -236,6 +236,7 @@ from .locks import worktree_provision_mutex
 from . import stage_targets as _stage_targets
 from .phases.catalog import PhaseAssetError, profile_markdown, resolve_include
 from .phases.final_verification.target import acquire_final_verification_target
+from .phases.final_verification.prior_blockers import prior_blockers_packet_block
 from .phases.final_verification.entry import (
     apply_verification_target,
     reject_prepare_flags,
@@ -534,6 +535,7 @@ def _set_data_json_approved_true_if_present(path: Path) -> bool:
 # 가 whole-task 통합 실패를 동일 타입으로 받는다. run.py 는 재노출만 한다.
 PrepareError = _stage_targets.PrepareError
 from .phases.implementation_option_selection.entry import (
+    selection_mode_packet_block,
     validate_brief_requirements,
 )
 
@@ -607,6 +609,9 @@ class PrepareInputs:
     clarification_response_path: str = ""  # absolute or empty
     # implementation-planning 신규 실행 전용: 검증된 방향 선택 최종 보고서.
     selected_direction_path: str = ""
+    # implementation-option-selection 전용: 리드가 미리 정한 방향과 그 근거.
+    # 값이 있으면 이 run 은 `preselected-validation`, 없으면 `candidate-comparison`.
+    preselected_direction: str = ""
     # implementation-planning 전용: 사용자가 고른 이번 재실행의 재검증 범위.
     # "" / "auto" = 리드의 `okstra incremental-scope` 판정에 맡김, "full" =
     # 전체 재검증 강제, "<stage csv>" = 그 stage 들을 impacted 로 지정.
@@ -1136,6 +1141,7 @@ def _canonical_argv(inp: PrepareInputs, ctx: dict) -> list[str]:
         ("--implementation-option", inp.implementation_option),
         ("--clarification-response", inp.clarification_response_path),
         ("--selected-direction", inp.selected_direction_path),
+        ("--preselected-direction", inp.preselected_direction),
         (
             "--lead-provider",
             inp.lead_provider or lead_fallbacks.get("LEAD_PROVIDER", ""),
@@ -1416,6 +1422,11 @@ def _validate_prepare_inputs(project_root: Path, inp: PrepareInputs) -> list:
         raise PrepareError(f"task brief not found: {inp.brief_path}")
     elif inp.task_type == "implementation-option-selection":
         validate_brief_requirements(inp.brief_path)
+    if inp.preselected_direction and inp.task_type != "implementation-option-selection":
+        raise PrepareError(
+            "--preselected-direction is only meaningful with --task-type "
+            f"implementation-option-selection; got {inp.task_type}"
+        )
     ctx_stage_map: list = []
     # implementation 과 final-verification 은 둘 다 승인된 plan 의 Stage Map 을
     # 입력으로 받는다(전자는 실행 scope, 후자는 검증 scope).
@@ -3068,6 +3079,22 @@ def _write_instruction_set_sources(
             if inp.clarification_response_path else ""
         ),
         verification_target_path=ctx.get("VERIFICATION_TARGET_RELATIVE_PATH", ""),
+        selection_mode_text=(
+            selection_mode_packet_block(
+                inp.preselected_direction,
+                Path(inp.clarification_response_path) if inp.clarification_response_path else None,
+                Path(ctx["PROJECT_ROOT"]),
+            )
+            if inp.task_type == "implementation-option-selection" else ""
+        ),
+        cited_documents_text=cited_documents_block(
+            (instruction_set / "task-brief.md").read_text(encoding="utf-8"),
+            Path(ctx["PROJECT_ROOT"]),
+        ),
+        prior_verification_text=(
+            prior_blockers_packet_block(Path(ctx["FINAL_REPORT_PATH"]))
+            if inp.task_type == "final-verification" else ""
+        ),
     )
     if inp.task_type == "technical-verification":
         packet += materialize_technical_input_packet(
@@ -3296,6 +3323,7 @@ def _persist_run_inputs(
             "approvedPlanPath": approved_plan_path,
             "clarificationResponsePath": inp.clarification_response_path,
             "selectedDirectionPath": inp.selected_direction_path,
+            "preselectedDirection": inp.preselected_direction,
             "analysisTarget": json.loads(ctx.get("ANALYSIS_TARGET_JSON", "{}")).get(
                 "requestedValue", ""
             ),
@@ -4060,6 +4088,11 @@ def _prepare_user_authorization(inp: PrepareInputs) -> dict:
     for key, value in expected.items():
         if record["scope"].get(key) != value:
             raise PrepareError(f"user authorization scope does not match --{key}; confirm the changed scope")
+    # A record confirmed before this key existed scoped a run without a preselected direction.
+    if record["scope"].get("preselected-direction", "") != inp.preselected_direction:
+        raise PrepareError(
+            "user authorization scope does not match --preselected-direction; confirm the changed scope"
+        )
     for key, path in (
         ("task-brief", "" if inp.task_type in ("release-handoff", "discussion") else inp.brief_path),
         ("approved-plan", inp.approved_plan_path),
@@ -4537,6 +4570,7 @@ Usage:
     [--related-tasks <list>] [--base-ref <ref>] \
     [--clarification-response <path>] [--work-category <cat>] \
     [--selected-direction <selection-final-report.md>] \
+    [--preselected-direction <direction and citation>] \
     [--stage <auto|N>] [--stages <csv>] [--pr-template-path <path>] \
     [--fix-cycle <yes|no>] [--discussion-start <link|text|task-key>]
 
@@ -4671,6 +4705,16 @@ def build_prepare_argument_parser():
     )
     p.add_argument("--clarification-response", default="", dest="clarification_response_path")
     p.add_argument("--selected-direction", default="", dest="selected_direction_path")
+    p.add_argument(
+        "--preselected-direction",
+        default="",
+        dest="preselected_direction",
+        help=(
+            "implementation-option-selection only: the one direction this run "
+            "validates, with its citation. Sets the run to preselected-validation; "
+            "omitted means candidate-comparison."
+        ),
+    )
     p.add_argument(
         "--reverify-scope",
         default="",
@@ -4907,6 +4951,7 @@ def main(argv: list[str]) -> int:
         stages=args.stages,
         clarification_response_path=clarification_abs,
         selected_direction_path=selected_direction_abs,
+        preselected_direction=args.preselected_direction.strip(),
         reverify_scope=args.reverify_scope,
         pr_template_path=args.pr_template_path,
         render_only=args.render_only,

package/runtime/python/okstra_ctl/run_context.py

@@ -36,12 +36,15 @@ def latest_run_inputs(
     task_id: str,
     *,
     phase_segment: str = "",
+    stage: Optional[int] = None,
 ) -> dict:
     """가장 최근 ``run-inputs-*.json`` 의 ``inputs`` dict 를 반환 (부재 시 {}).
 
-    ``phase_segment`` 가 주어지면 그 phase 의 ``runs/<seg>/manifests/`` 만 스캔한다
-    (resume 는 같은 phase 를 재실행하므로 그 phase 의 직전 입력이 기준). 비어 있으면
-    task 의 모든 phase 를 통틀어 가장 최근(mtime) 파일을 고른다.
+    ``phase_segment`` 가 주어지면 그 phase 의 ``runs/<seg>/manifests/`` 와
+    ``runs/<seg>/stage-*/manifests/`` 만 스캔한다 (resume 는 같은 phase 를 재실행하므로
+    그 phase 의 직전 입력이 기준). 비어 있으면 task 의 모든 phase 를 통틀어 가장
+    최근(mtime) 파일을 고른다. ``stage`` 는 ``phase_segment`` 와 함께 써서
+    ``runs/<seg>/stage-<N>/manifests/`` 하나로 좁힌다.
 
     페이로드 구조는 ``{"schemaVersion", "writtenAt", "inputs": {...}}`` 이며 실제
     입력은 top-level 이 아니라 ``inputs`` 아래에 있다. run-inputs 의 위치/구조 지식은
@@ -52,13 +55,15 @@ def latest_run_inputs(
     runs_base = task_runs_dir(Path(project_root), task_group, task_id)
     if not runs_base.is_dir():
         return {}
-    if phase_segment:
-        glob_iter = (runs_base / phase_segment / "manifests").glob(
-            "run-inputs-*.json")
+    if phase_segment and stage is not None:
+        patterns = [f"{phase_segment}/stage-{int(stage)}/manifests/run-inputs-*.json"]
     else:
-        glob_iter = runs_base.glob("*/manifests/run-inputs-*.json")
+        # implementation / final-verification run 은 stage-<N>/ 한 단계 아래에 있다.
+        scope = phase_segment or "*"
+        patterns = [f"{scope}/manifests/run-inputs-*.json",
+                    f"{scope}/stage-*/manifests/run-inputs-*.json"]
     candidates: list[tuple[float, Path]] = []
-    for inp in glob_iter:
+    for inp in (path for pattern in patterns for path in runs_base.glob(pattern)):
         try:
             candidates.append((inp.stat().st_mtime, inp))
         except OSError:

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

@@ -7,6 +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.phases.implementation_option_selection.entry import selection_mode
 from okstra_ctl.wizard_stage_intent import wizard_stage_confirmation_label, resolve_wizard_stage_intent
 from okstra_ctl.worktree import (
     compute_worktree_path,
@@ -325,6 +326,11 @@ def confirmation_block(state: WizardState) -> str:
             lines.append(reverify_line)
     if state.selected_direction_path:
         lines.append(f"  selected-direction: {state.selected_direction_path}")
+    if state.task_type == "implementation-option-selection":
+        mode = selection_mode(state.preselected_direction)
+        lines.append(f"  selection-mode: {mode}")
+        if state.preselected_direction:
+            lines.append(f"  preselected-direction: {state.preselected_direction}")
     if state.task_type == "release-handoff" and state.handoff_stages:
         scope = _msg(state.workspace_root, "confirmation",
                      "handoff_scope_stages", stages=state.handoff_stages)

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

@@ -220,6 +220,12 @@ S_CLARIFICATION_PICK = "clarification_pick"
 S_CLARIFICATION = "clarification"
 
 
+S_SELECTION_MODE_PICK = "selection_mode_pick"
+
+
+S_PRESELECTED_DIRECTION = "preselected_direction"
+
+
 S_REVERIFY_SCOPE_PICK = "reverify_scope_pick"
 
 

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

@@ -56,6 +56,7 @@ from .ids import (
     S_HANDOFF_STAGE_PICK,
     S_PROJECT_EVIDENCE,
     S_PROJECT_EVIDENCE_PICK,
+    S_PRESELECTED_DIRECTION,
     S_PR_TEMPLATE,
     S_PR_TEMPLATE_PICK,
     S_REASONING_EFFORT,
@@ -67,6 +68,7 @@ from .ids import (
     S_REVERIFY_SCOPE_PICK,
     S_REVERIFY_SCOPE_STAGES,
     S_SELECTED_DIRECTION_PICK,
+    S_SELECTION_MODE_PICK,
     S_STAGE_PICK,
     S_TASK_GROUP,
     S_TASK_GROUP_TEXT,
@@ -185,6 +187,8 @@ from .steps_options import (
     _build_pr_template_scope,
     _build_related_tasks,
     _build_related_tasks_pick,
+    _build_preselected_direction,
+    _build_selection_mode_pick,
     _submit_clarification,
     _submit_clarification_pick,
     _submit_directive,
@@ -194,6 +198,8 @@ from .steps_options import (
     _submit_pr_template_scope,
     _submit_related_tasks,
     _submit_related_tasks_pick,
+    _submit_preselected_direction,
+    _submit_selection_mode_pick,
 )
 from .steps_roles import _build_reuse_previous, _submit_reuse_previous
 from .confirmation import _build_confirm, _submit_confirm
@@ -556,6 +562,19 @@ STEPS: list[Step] = [
                             and S_CLARIFICATION not in s.answered),
          build=_build_clarification, submit=_submit_clarification,
          owns=("clarification_response_path", "clarification_pending_text")),
+    # clarification 뒤 — 이어받는 리포트의 다음 단계 지시를 라벨에 보여 준다.
+    Step(S_SELECTION_MODE_PICK,
+         applies=lambda s: (s.task_type == "implementation-option-selection"
+                            and _identity_ready(s)
+                            and not s.clarification_pending_text
+                            and S_SELECTION_MODE_PICK not in s.answered),
+         build=_build_selection_mode_pick, submit=_submit_selection_mode_pick,
+         owns=("preselected_direction", "preselected_direction_pending_text")),
+    Step(S_PRESELECTED_DIRECTION,
+         applies=lambda s: (s.preselected_direction_pending_text
+                            and S_PRESELECTED_DIRECTION not in s.answered),
+         build=_build_preselected_direction, submit=_submit_preselected_direction,
+         owns=("preselected_direction", "preselected_direction_pending_text")),
     # clarification 뒤에 온다. `_planning_rerun_selected` 는 clarification 답을 읽어
     # "이 런은 기존 계획서의 재실행" 인지 판정하는데, 이 단계가 clarification 앞에
     # 있던 동안 그 값은 언제나 비어 있었다 — 가드가 참이 될 수 없는 자리에 놓여
@@ -663,6 +682,8 @@ def _ready_for_confirm(s: WizardState) -> bool:
         S_RELATED_TASKS,
         S_CLARIFICATION_PICK,
         S_CLARIFICATION,
+        S_SELECTION_MODE_PICK,
+        S_PRESELECTED_DIRECTION,
         S_PR_TEMPLATE_PICK,
         S_PR_TEMPLATE,
         S_PR_TEMPLATE_SCOPE,

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

@@ -112,6 +112,10 @@ def render_args(state: WizardState) -> dict[str, Any]:
         "related-tasks": state.related_tasks_raw,
         "clarification-response": state.clarification_response_path,
         "selected-direction": state.selected_direction_path,
+        "preselected-direction": (
+            state.preselected_direction
+            if state.task_type == "implementation-option-selection" else ""
+        ),
         "reverify-scope": (
             state.reverify_scope
             if state.task_type == "implementation-planning" else ""

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

@@ -25,6 +25,7 @@ from okstra_ctl.final_report_paths import final_report_data_path
 from okstra_ctl.plan_run_root import list_implementation_planning_reports
 from okstra_ctl.stage_map import StageMapError, parse_stage_map_file
 from okstra_ctl.workflow import PHASE_SEQUENCE
+from okstra_ctl.wizard_stage_intent import WHOLE_TASK_STAGE
 from okstra_ctl import worktree_registry
 from okstra_ctl.worktree import is_git_work_tree, main_worktree_path
 from okstra_ctl.paths import RunRef, task_runs_dir
@@ -362,14 +363,32 @@ def _contained_final_report_data_path(report: Path, task_root: Path) -> Path:
     )
 
 
+def _stage_scoped_report_patterns(
+    segment: str, selected_stage: str
+) -> tuple[str, ...]:
+    """`segment` 아래에서 이 run 의 stage 범위에 속한 보고서 glob.
+
+    숫자 stage 는 `stage-<N>/` 만, 전체 작업(flat run 디렉터리)은 flat 만 본다 —
+    다른 범위의 답변은 이 run 의 clarification 이 아니다. stage 를 고르지 않는
+    run(release-handoff 등)은 둘 다 본다.
+    """
+    report = "reports/final-report-*.data.json"
+    if selected_stage.isdigit():
+        return (f"{segment}/stage-{selected_stage}/{report}",)
+    if selected_stage == WHOLE_TASK_STAGE:
+        return (f"{segment}/{report}",)
+    return (f"{segment}/{report}", f"{segment}/stage-*/{report}")
+
+
 def _newest_contained_final_report(
     runs_base: Path,
     task_root: Path,
-    glob_pattern: str,
+    glob_patterns: tuple[str, ...],
     project_root: Path,
 ) -> Path | None:
     candidates: list[Path] = []
-    for report in runs_base.glob(glob_pattern):
+    reports = (path for pattern in glob_patterns for path in runs_base.glob(pattern))
+    for report in reports:
         if not report.is_file():
             continue
         try:
@@ -513,7 +532,7 @@ def _technical_evidence_for_comparison(
     project_root = Path(state.project_root)
     report = _newest_contained_final_report(
         task_root / "runs", task_root,
-        "technical-verification/reports/final-report-*.data.json", project_root,
+        ("technical-verification/reports/final-report-*.data.json",), project_root,
     )
     if report is None:
         return source
@@ -531,10 +550,11 @@ def _suggest_latest_final_report(state: WizardState) -> str:
     """clarification carry-in 으로 추천할 직전 final-report 의 relpath.
 
     resume-clarification 은 "같은 phase 를 답변과 함께 재실행" 이므로 재실행
-    task-type **자신의** 보고서(``runs/<task-type>/reports/final-report-*.md``)를
-    우선한다. 그 phase 에 보고서가 없을 때만(예: 다음 phase 로 진행) 전체 phase 의
-    mtime 최신으로 폴백한다 — 과거엔 무조건 전체 mtime 최신이라 더 최근에 재렌더된
-    다른 phase 보고서를 잘못 집을 수 있었다. 못 찾으면 빈 문자열.
+    task-type **자신의** 보고서(``runs/<task-type>[/stage-<N>]/reports/``)를
+    우선한다(stage 범위는 ``_stage_scoped_report_patterns``). 그 phase 에 보고서가
+    없을 때만(예: 다음 phase 로 진행) 전체 phase 의 mtime 최신으로 폴백한다 —
+    과거엔 무조건 전체 mtime 최신이라 더 최근에 재렌더된 다른 phase 보고서를 잘못
+    집을 수 있었다. 못 찾으면 빈 문자열.
     """
     if not state.task_group or not state.task_id or not state.project_root:
         return ""
@@ -560,7 +580,7 @@ def _suggest_latest_final_report(state: WizardState) -> str:
         best = _newest_contained_final_report(
             runs_base,
             task_root,
-            f"{seg}/reports/final-report-*.data.json",
+            _stage_scoped_report_patterns(seg, state.selected_stage),
             Path(state.project_root),
         )
     # implementation-planning 의 `--clarification-response` 는 같은 phase 의
@@ -572,7 +592,9 @@ def _suggest_latest_final_report(state: WizardState) -> str:
         best = _newest_contained_final_report(
             runs_base,
             task_root,
-            "*/reports/final-report-*.data.json",
+            # 다른 phase 의 flat 보고서(계획서 등)는 stage 범위와 무관하게 후보다.
+            ("*/reports/final-report-*.data.json",
+             *_stage_scoped_report_patterns("*", state.selected_stage)),
             Path(state.project_root),
         )
     best = _technical_evidence_for_comparison(state, best, task_root)
@@ -592,12 +614,12 @@ def _suggest_latest_final_report(state: WizardState) -> str:
 
 
 def _latest_run_inputs(
-    state: WizardState, *, phase_segment: str = ""
+    state: WizardState, *, phase_segment: str = "", stage: Optional[int] = None
 ) -> dict:
     """직전 run 의 입력 스냅샷. 위치/구조 지식은 run_context.latest_run_inputs 가 SSOT."""
     return latest_run_inputs(
         state.project_root, state.task_group, state.task_id,
-        phase_segment=phase_segment)
+        phase_segment=phase_segment, stage=stage)
 
 
 def _clarification_pick_required(state: WizardState) -> bool:

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

@@ -120,6 +120,9 @@ class WizardState:
     clarification_pending_text: bool = False
     last_final_report_cached: str = ""
     selected_direction_path: str = ""
+    # implementation-option-selection: 리드가 미리 정한 방향과 근거. 비면 candidate-comparison.
+    preselected_direction: str = ""
+    preselected_direction_pending_text: bool = False
     # "" | "auto" | "full" | "<stage csv>" — 사용자가 고른 이번 재실행의 재검증
     # 범위. implementation-planning 재실행에서 좁힐 여지가 있을 때만 채워진다.
     reverify_scope: str = ""
@@ -625,6 +628,7 @@ _FIELD_DEFAULTS: dict[str, Any] = {
     "related_tasks_raw": "", "related_tasks_pending_text": False,
     "clarification_response_path": "", "clarification_pending_text": False,
     "selected_direction_path": "",
+    "preselected_direction": "", "preselected_direction_pending_text": False,
     "reverify_scope": "", "reverify_scope_pending_text": False,
     "pr_template_path": "", "pr_template_pending_text": False,
     "pr_template_scope": "",

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

@@ -8,10 +8,17 @@ from typing import Callable, Optional
 
 from okstra_ctl.clarification_items import user_response_sidecars
 from okstra_ctl.domain.worker_exec import REASONING_EFFORTS
+from okstra_ctl.ids import slugify_task_segment
 from okstra_ctl.manager_paths import MANAGER_CONTEXT_DIRECTIVE_PREFIX
 from okstra_ctl.json_boundary import JsonBoundaryError, load_owned_object, write_owned_object_atomic
 from okstra_ctl.report_language import is_language_tag
+from okstra_ctl.phases.implementation_option_selection.entry import (
+    CANDIDATE_COMPARISON,
+    PRESELECTED_VALIDATION,
+    upstream_next_steps,
+)
 from okstra_ctl.phases.implementation_planning.entry import is_existing_planning_report
+from okstra_ctl.prepare_error import PrepareError
 from okstra_ctl.pr_template import PrTemplateError, resolve_pr_template_path
 from okstra_project.dirs import project_json_path
 from okstra_project.state import StateError, list_project_tasks
@@ -23,6 +30,7 @@ from .ids import (
     S_CLARIFICATION_PICK,
     S_DIRECTIVE,
     S_DIRECTIVE_PICK,
+    S_PRESELECTED_DIRECTION,
     S_PR_TEMPLATE,
     S_PR_TEMPLATE_PICK,
     S_PR_TEMPLATE_SCOPE,
@@ -30,6 +38,7 @@ from .ids import (
     S_RELATED_TASKS,
     S_RELATED_TASKS_PICK,
     S_REPORT_LANGUAGE,
+    S_SELECTION_MODE_PICK,
     _LATEST_REPORT_TOKEN,
     _PROJECT_DEFAULT_TOKEN,
     _REUSE_LAST_TOKEN,
@@ -97,7 +106,13 @@ def _clarification_sidecar_note(state: WizardState, suggestion: str) -> str:
 
 def _suggest_last_directive(state: WizardState) -> str:
     """같은 task 의 가장 최근 run-inputs-*.json 에서 directive 값을 자동 추출."""
-    val = _latest_run_inputs(state).get("directive") or ""
+    inputs: dict = {}
+    if state.task_type and state.selected_stage.isdigit():
+        # stage run 의 directive 는 그 stage 범위로 쓰였다 — 형제 stage 것은 남의 것이다.
+        inputs = _latest_run_inputs(
+            state, phase_segment=slugify_task_segment(state.task_type),
+            stage=int(state.selected_stage))
+    val = (inputs or _latest_run_inputs(state)).get("directive") or ""
     return val if isinstance(val, str) else ""
 
 
@@ -129,9 +144,9 @@ class _OptionalCachedPickSpec:
     # 추천 옵션 라벨·echo 뒤에 덧붙일 동적 안내(예: 함께 첨부될 사이드카 개수).
     # (state, 추천 relpath) -> note. 미설정 picker 는 영향 없음.
     recommend_note: Optional[Callable[["WizardState", str], str]] = None
-    # Whether the wizard takes the suggestion without asking. A previous directive
-    # is an instruction written for another run, so reusing it stays a question.
-    auto_take_suggestion: bool = True
+    # Whether the screen is always shown. No recorded value tells the wizard that a
+    # run needs no directive, and a previous one was written for another run.
+    always_ask: bool = False
 
 
 def _build_optional_cached_pick(state: WizardState, spec: _OptionalCachedPickSpec) -> Prompt:
@@ -149,12 +164,12 @@ def _build_optional_cached_pick(state: WizardState, spec: _OptionalCachedPickSpe
     setattr(state, spec.cache_attr, suggestion)
     options.append(_opt(PICK_SKIP, t["options"][PICK_SKIP]))
     options.append(_opt(PICK_TYPE_CUSTOM, t["options"][PICK_TYPE_CUSTOM]))
-    if not suggestion:
+    if spec.always_ask:
+        auto_value = ""
+    elif not suggestion:
         auto_value = PICK_SKIP
-    elif spec.auto_take_suggestion:
-        auto_value = spec.recommend_token
     else:
-        auto_value = ""
+        auto_value = spec.recommend_token
     return Prompt(
         step=spec.step, kind="pick",
         label=t["label"], options=options,
@@ -218,7 +233,7 @@ _DIRECTIVE_PICK_SPEC = _OptionalCachedPickSpec(
     cache_attr="last_directive_cached", target_attr="directive",
     pending_attr="directive_pending_text",
     recommend_note=_directive_context_note,
-    auto_take_suggestion=False,
+    always_ask=True,
 )
 
 
@@ -393,6 +408,56 @@ def _submit_clarification(state: WizardState, value: str) -> Optional[str]:
     return f"clarification: {p}"
 
 
+def _build_selection_mode_pick(state: WizardState) -> Prompt:
+    """The mode is the lead's decision; the upstream report's routing is shown beside it."""
+    t = _p(state.workspace_root, "selection_mode_pick")
+    label = t["label"]
+    if state.clarification_response_path:
+        try:
+            steps = upstream_next_steps(Path(state.clarification_response_path))
+        except PrepareError as exc:
+            raise WizardError(str(exc)) from exc
+        if steps:
+            label += t["labels"]["upstream"].format(steps=" / ".join(steps))
+    return Prompt(
+        step=S_SELECTION_MODE_PICK, kind="pick", label=label,
+        options=[_opt(value, text) for value, text in t["options"].items()],
+        echo_template=t["echo_template"],
+    )
+
+
+def _submit_selection_mode_pick(state: WizardState, value: str) -> Optional[str]:
+    if value == CANDIDATE_COMPARISON:
+        state.preselected_direction = ""
+        state.preselected_direction_pending_text = False
+        return f"selection-mode: {CANDIDATE_COMPARISON}"
+    if value == PRESELECTED_VALIDATION:
+        state.preselected_direction_pending_text = True
+        return None
+    raise WizardError(
+        f"expected {CANDIDATE_COMPARISON!r} or {PRESELECTED_VALIDATION!r}, got: {value!r}"
+    )
+
+
+def _build_preselected_direction(state: WizardState) -> Prompt:
+    t = _p(state.workspace_root, "preselected_direction")
+    return Prompt(
+        step=S_PRESELECTED_DIRECTION, kind="text",
+        label=t["label"], echo_template=t["echo_template"],
+    )
+
+
+def _submit_preselected_direction(state: WizardState, value: str) -> Optional[str]:
+    direction = (value or "").strip()
+    if not direction:
+        raise WizardError(
+            f"{PRESELECTED_VALIDATION} needs the direction and the citation that fixed it"
+        )
+    state.preselected_direction = direction
+    state.preselected_direction_pending_text = False
+    return f"preselected-direction: {direction}"
+
+
 def _build_pr_template(state: WizardState) -> Prompt:
     t = _p(state.workspace_root, "pr_template")
     return Prompt(

package/runtime/python/okstra_ctl/worker_prompt_body.py

@@ -24,6 +24,7 @@ def analysis_prompt_body(
     plan: PromptPlan,
     approved_plan_path: str = "",
     selected_direction_path: str = "",
+    stage_extract_path: str = "",
 ) -> list[str]:
     """Render the provider-neutral body for an initial analysis audience."""
     label = analysis_worker_label(worker_id)
@@ -43,7 +44,12 @@ def analysis_prompt_body(
         "",
         "## Inputs",
         *analysis_input_lines(
-            manifest, active_context, plan, approved_plan_path, selected_direction_path
+            manifest,
+            active_context,
+            plan,
+            approved_plan_path,
+            selected_direction_path,
+            stage_extract_path,
         ),
         "",
         mcp_pointer_line(),
@@ -60,7 +66,21 @@ def analysis_input_lines(
     plan: PromptPlan,
     approved_plan_path: str = "",
     selected_direction_path: str = "",
+    stage_extract_path: str = "",
 ) -> list[str]:
+    if plan.audience == "implementation-executor":
+        # The packet already carries the brief extract, the reference
+        # expectations, the profile prelude and the directive; the task brief,
+        # analysis material, profile and reference files repeat them in full.
+        # Measured 2026-10-30 (dev-11562): those four files were 1,929 lines
+        # beside a 4,865-line packet. The clarification file stays: the
+        # packet keeps only its extract, and a lazy-delivery prompt has no
+        # inlined authority block.
+        return existing_input_lines((
+            ("Primary analysis packet", instruction_path(manifest, active_context, "analysisPacketPath")),
+            ("Approved plan stage extract", stage_extract_path),
+            ("Clarification response", instruction_path(manifest, active_context, "clarificationResponsePath")),
+        ))
     if plan.packet_only:
         packet_path = instruction_path(manifest, active_context, "analysisPacketPath")
         # 승인 계획은 `## Inputs` 에 실어야 한다. 워커의 읽기 범위는 이 절과

package/runtime/python/okstra_ctl/worker_prompt_headers.py

@@ -27,6 +27,8 @@ class WorkerPromptHeaderError(Exception):
 # skill catalogs, and similar non-okstra artifacts. Restating the scope inline
 # puts the rule in front of the worker before its first tool call, which is the
 # only point at which it can still win over those host instructions.
+# 패킷의 페이지 읽기 규칙도 같은 이유로 여기 있다 — 패킷 안 목차는 파일을 연 뒤에야
+# 보이는데, 통째 `cat` 은 그 전에 잘린다(실측 609KB 패킷, codex).
 READ_SCOPE_HEADER = (
     "**Read scope:** Read only the paths this prompt enumerates "
     "(`[Required reading]`, `## Inputs`, verification-target paths) plus "
@@ -39,7 +41,11 @@ READ_SCOPE_HEADER = (
     "NOT apply inside an okstra worker run: do not auto-read `graphify-out/`, "
     "`SKILL.md`, or other artifacts outside `<PROJECT_ROOT>/.okstra/`. If an "
     "un-enumerated file seems essential, record it under *Missing Information "
-    "or Assumptions* instead of reading it."
+    "or Assumptions* instead of reading it. Read the primary analysis packet "
+    "in pages of at most 200 lines (`sed -n '1,200p'`, then `'201,400p'`, …), "
+    "never with one whole-file `cat` or view: worker CLIs cut long output "
+    "without saying so, and the packet's `## Section Index` gives each "
+    "section's line range."
 )
 EVIDENCE_LEDGER_HEADER = "**Evidence ledger:** required-v1"
 
@@ -63,12 +69,13 @@ EVIDENCE_CITATION_HEADER = (
 # 구현 워커는 명령 행을 쓰지 못한다.
 EVIDENCE_COMMANDS_HEADER = (
     "**Evidence commands:** Append one `- Evidence command: "
-    "{\"command\":\"<exact command>\",\"cwd\":\"<project-root>\","
+    "{\"command\":\"<exact command>\",\"cwd\":\"<directory the command ran in>\","
     "\"exitCode\":0,\"outputSummary\":\"<one-line result>\"}` row to the audit "
     "sidecar for each command that produced or verified a conclusion. Do not "
     "record exploratory `rg`, `ls`, or file-opening commands. Write the command "
-    "as you ran it. A value that must not be written down is yours to omit or "
-    "pass as a `$VAR` reference."
+    "as you ran it. When it starts with `cd <dir> &&`, `cwd` is that `<dir>`, "
+    "not the shell's starting directory. A value that must not be written down "
+    "is yours to omit or pass as a `$VAR` reference."
 )
 
 # `agy`'s write tool validates the target against the Gemini artifact store

package/runtime/python/okstra_ctl/worker_prompt_policy.py

@@ -34,6 +34,9 @@ ERRORS_PATH_HEADERS = (
 # itself: the lead's launch prompt carries them, and no worker reads that.
 APPROVED_PLAN_HEADER = "**Approved plan:**"
 IMPLEMENTATION_STAGE_HEADER = "**Stage for this implementation run:**"
+# Executor-only and optional: a prompt published before it, or a run whose plan
+# is a Markdown report, has no extract and the executor reads the plan itself.
+APPROVED_PLAN_STAGE_EXTRACT_HEADER = "**Approved plan stage extract:**"
 # A stage's verifiers share one worktree and run as one batch. The Tier 3 script
 # (builds, fixed ports) and the self-mock mutation probe (edits sources in place)
 # must each run once, by the verifier named here.