okstra 0.60.3 → 0.62.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "okstra",
-  "version": "0.60.3",
+  "version": "0.62.0",
   "description": "Multi-agent cross-verification orchestrator runtime + Claude Code skills.",
   "license": "MIT",
   "author": "devonshin",

package/runtime/BUILD.json

@@ -1,5 +1,5 @@
 {
-  "package": "0.60.3",
-  "builtAt": "2026-06-09T06:44:22.023Z",
+  "package": "0.62.0",
+  "builtAt": "2026-06-09T08:14:49.499Z",
   "repoRoot": "/home/runner/work/okstra/okstra"
 }

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

@@ -357,10 +357,16 @@ run_resume_clarification() {
   local report_path="${lookup_result%$'\t'*}"
   local resolved_type="${lookup_result##*$'\t'}"
 
+  # implementation-planning 도 §1 Clarification Items(plan-body 결정: 예 C-205
+  # tx-배관 step 누락)를 가지므로, 사용자가 결정란을 채운 뒤 같은 phase 를
+  # clarification-response 자동공급으로 재실행해 plan 을 재생성·gate 재판정할 수
+  # 있다. 자동검색(task_type_filter 없음)은 파일명 사전순 max 라 implementation-
+  # planning 이 requirements-discovery 에 밀리므로, 이 경로는 --task-type
+  # implementation-planning 을 명시했을 때만 해소된다.
   case "$resolved_type" in
-    requirements-discovery|error-analysis) ;;
+    requirements-discovery|error-analysis|implementation-planning) ;;
     *)
-      printf '%s (resolved task-type: %s)\n' '--resume-clarification only applies to requirements-discovery or error-analysis runs' "$resolved_type" >&2
+      printf '%s (resolved task-type: %s)\n' '--resume-clarification only applies to requirements-discovery, error-analysis, or implementation-planning runs' "$resolved_type" >&2
       exit 1
       ;;
   esac
@@ -387,11 +393,62 @@ PY
     exit 1
   fi
 
+  # 직전 run 의 워커/모델/directive/related-tasks 를 그대로 이어 실행한다 — resume 가
+  # 이 설정들을 안 넘기면 매 단계 재입력이 아니라 Python phase 기본값으로 조용히
+  # 되돌아가 버린다. run-inputs 의 위치/구조 지식은 okstra_ctl.run_context 가 SSOT.
+  local resume_extra_args=()
+  while IFS= read -r -d '' _arg; do
+    resume_extra_args+=("$_arg")
+  done < <(PYTHONPATH="$WORKSPACE_ROOT/scripts:${PYTHONPATH-}" python3 - \
+             "$PROJECT_ROOT" "$TASK_GROUP" "$TASK_ID" "$resolved_type" <<'PY'
+import sys
+from okstra_ctl.run_context import latest_run_inputs
+from okstra_ctl.ids import slugify_task_segment
+
+project_root, task_group, task_id, task_type = sys.argv[1:5]
+inputs = latest_run_inputs(
+    project_root, task_group, task_id,
+    phase_segment=slugify_task_segment(task_type))
+
+
+def emit(flag, value):
+    if value:
+        sys.stdout.write(flag + "\0" + value + "\0")
+
+
+def model(value):
+    # 직전 run 의 모델 display 값. "default"/빈 값은 phase 기본값을 뜻하므로 넘기지
+    # 않는다(명시 플래그로 고정하면 안 됨).
+    return value if isinstance(value, str) and value not in ("", "default") else ""
+
+
+workers = inputs.get("workers")
+if isinstance(workers, list):
+    workers = ",".join(w for w in workers if isinstance(w, str))
+elif not isinstance(workers, str):
+    workers = ""
+emit("--workers", workers)
+emit("--lead-model", model(inputs.get("leadModel")))
+emit("--claude-model", model(inputs.get("claudeModel")))
+emit("--codex-model", model(inputs.get("codexModel")))
+emit("--gemini-model", model(inputs.get("geminiModel")))
+emit("--report-writer-model", model(inputs.get("reportWriterModel")))
+directive = inputs.get("directive")
+emit("--directive", directive if isinstance(directive, str) else "")
+related = inputs.get("relatedTasks")
+emit("--related-tasks", related if isinstance(related, str) else "")
+PY
+)
+
   if [[ "${OKSTRA_RESUME_CLARIFICATION_DRY_RUN:-false}" == "true" ]]; then
     printf 'resume-clarification (dry-run):\n' >&2
     printf '  report: %s\n' "$report_path" >&2
-    printf '  re-exec: bash %s --task-type %s --project-id %s --task-group %s --task-id %s --task-brief %s --clarification-response %s\n' \
+    printf '  re-exec: bash %s --task-type %s --project-id %s --task-group %s --task-id %s --task-brief %s --clarification-response %s' \
       "$0" "$resolved_type" "$PROJECT_ID" "$TASK_GROUP" "$TASK_ID" "$resume_brief_rel" "$report_path" >&2
+    if (( ${#resume_extra_args[@]} > 0 )); then
+      printf ' %s' "${resume_extra_args[@]}" >&2
+    fi
+    printf '\n' >&2
     return 0
   fi
 
@@ -409,5 +466,6 @@ PY
     --task-group "$TASK_GROUP" \
     --task-id "$TASK_ID" \
     --task-brief "$resume_brief_rel" \
-    --clarification-response "$report_path"
+    --clarification-response "$report_path" \
+    ${resume_extra_args[@]+"${resume_extra_args[@]}"}
 }

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

@@ -251,6 +251,14 @@
         "provider": "{provider} critic"
       }
     },
+    "reuse_previous": {
+      "label": "이 task·phase 의 직전 run 설정이 남아 있습니다. 그대로 재사용할까요?\n· 예 — 직전 run 의 워커 구성·역할별 모델·directive·관련 task 를 그대로 가져오고, 가장 최근 final-report 를 clarification 입력으로 자동 선택해 바로 확인 단계로 넘어갑니다.\n· 아니오 — 모델/워커/directive 등을 단계별로 다시 입력합니다.",
+      "echo_template": "reuse-previous: {value}",
+      "options": {
+        "yes": "예 — 직전 설정 그대로 진행",
+        "no": "아니오 — 단계별로 다시 입력"
+      }
+    },
     "defaults_or_custom": {
       "label": "역할별로 어떤 모델을 쓸지 정하는 단계입니다 (참여 워커 구성을 바꾸는 게 아닙니다).\n· 기본값으로 진행 — lead·실행자/워커·report-writer 를 모두 추천 모델로 두고 바로 진행합니다.\n· 커스터마이즈 — 역할별 모델을 직접 고르고, 추가 directive·관련 task 도 지정합니다.",
       "echo_template": "customize: {value}",

package/runtime/python/okstra_ctl/run_context.py

@@ -23,7 +23,51 @@ from datetime import datetime, timezone
 from pathlib import Path
 from typing import Iterator, Optional
 
-from .paths import compute_run_paths
+from .paths import compute_run_paths, task_runs_dir
+
+
+def latest_run_inputs(
+    project_root: object,
+    task_group: str,
+    task_id: str,
+    *,
+    phase_segment: str = "",
+) -> dict:
+    """가장 최근 ``run-inputs-*.json`` 의 ``inputs`` dict 를 반환 (부재 시 {}).
+
+    ``phase_segment`` 가 주어지면 그 phase 의 ``runs/<seg>/manifests/`` 만 스캔한다
+    (resume 는 같은 phase 를 재실행하므로 그 phase 의 직전 입력이 기준). 비어 있으면
+    task 의 모든 phase 를 통틀어 가장 최근(mtime) 파일을 고른다.
+
+    페이로드 구조는 ``{"schemaVersion", "writtenAt", "inputs": {...}}`` 이며 실제
+    입력은 top-level 이 아니라 ``inputs`` 아래에 있다. run-inputs 의 위치/구조 지식은
+    이 함수 한 곳에만 둔다(wizard·okstra.sh resume 가 공유).
+    """
+    if not (project_root and task_group and task_id):
+        return {}
+    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")
+    else:
+        glob_iter = runs_base.glob("*/manifests/run-inputs-*.json")
+    candidates: list[tuple[float, Path]] = []
+    for inp in glob_iter:
+        try:
+            candidates.append((inp.stat().st_mtime, inp))
+        except OSError:
+            continue
+    if not candidates:
+        return {}
+    candidates.sort(key=lambda x: -x[0])
+    try:
+        data = json.loads(candidates[0][1].read_text(encoding="utf-8"))
+    except (OSError, json.JSONDecodeError):
+        return {}
+    inputs = data.get("inputs")
+    return inputs if isinstance(inputs, dict) else {}
 
 
 def _now_iso() -> str:

package/runtime/python/okstra_ctl/wizard.py

@@ -57,6 +57,7 @@ from okstra_ctl.worktree import (
     preview_worktree_decision,
 )
 from okstra_ctl.paths import task_runs_dir
+from okstra_ctl.run_context import latest_run_inputs
 from okstra_project.dirs import project_json_path
 from okstra_project.state import (
     StateError,
@@ -231,6 +232,7 @@ S_STAGE_PICK = "stage_pick"
 S_EXECUTOR = "executor"
 S_CRITIC_PICK = "critic_pick"
 S_CRITIC_TEXT = "critic_text"
+S_REUSE_PREVIOUS = "reuse_previous"
 S_DEFAULTS_OR_CUSTOM = "defaults_or_custom"
 S_WORKERS_OVERRIDE = "workers_override"
 S_LEAD_MODEL = "lead_model"
@@ -321,6 +323,9 @@ class WizardState:
     critic: str = ""
     critic_pending_text: bool = False
 
+    # resume: 직전 run-inputs 재사용 여부 (None=미응답, True=재사용, False=재입력)
+    reuse_previous: Optional[bool] = None
+
     # customize
     use_defaults: Optional[bool] = None
     workers_override: str = ""
@@ -1393,31 +1398,18 @@ def _suggest_latest_final_report(state: WizardState) -> str:
         return str(best)
 
 
+def _latest_run_inputs(
+    state: WizardState, *, phase_segment: str = ""
+) -> 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)
+
+
 def _suggest_last_directive(state: WizardState) -> str:
     """같은 task 의 가장 최근 run-inputs-*.json 에서 directive 값을 자동 추출."""
-    if not state.task_group or not state.task_id or not state.project_root:
-        return ""
-    runs_base = task_runs_dir(state.project_root, state.task_group, state.task_id)
-    if not runs_base.is_dir():
-        return ""
-    candidates: list[tuple[float, Path]] = []
-    for phase_dir in runs_base.iterdir():
-        if not phase_dir.is_dir():
-            continue
-        for run_dir in phase_dir.iterdir():
-            for inp in run_dir.glob("run-inputs-*.json"):
-                try:
-                    candidates.append((inp.stat().st_mtime, inp))
-                except OSError:
-                    continue
-    if not candidates:
-        return ""
-    candidates.sort(key=lambda x: -x[0])
-    try:
-        data = json.loads(candidates[0][1].read_text(encoding="utf-8"))
-    except (OSError, json.JSONDecodeError):
-        return ""
-    val = data.get("directive") or ""
+    val = _latest_run_inputs(state).get("directive") or ""
     return val if isinstance(val, str) else ""
 
 
@@ -1697,6 +1689,81 @@ def _submit_executor(state: WizardState, value: str) -> Optional[str]:
     return f"executor: {value}"
 
 
+# resume 재사용을 제안하는 phase. okstra.sh --resume-clarification 과 동일하게
+# §1 clarification 을 갖는 비-implementation phase 로 한정한다(implementation 은
+# approved-plan/stage 가 매 run 고유라 재사용 대상이 아니다).
+_RESUME_REUSE_PHASES = (
+    "requirements-discovery", "error-analysis", "implementation-planning")
+
+# YES 선택 시 prefill 로 충족되어 다시 묻지 않는 설정 단계들.
+_REUSE_FILLED_STEPS = (
+    S_DEFAULTS_OR_CUSTOM, S_WORKERS_OVERRIDE, S_LEAD_MODEL, S_EXECUTOR_MODEL,
+    S_CLAUDE_MODEL, S_CODEX_MODEL, S_GEMINI_MODEL, S_REPORT_WRITER_MODEL,
+    S_DIRECTIVE_PICK, S_DIRECTIVE, S_RELATED_TASKS_PICK, S_RELATED_TASKS,
+    S_CLARIFICATION_PICK, S_CLARIFICATION)
+
+
+def _has_prior_run_inputs(state: WizardState) -> bool:
+    seg = slugify_task_segment(state.task_type) if state.task_type else ""
+    return bool(_latest_run_inputs(state, phase_segment=seg))
+
+
+def _safe_model(provider: str, raw: object) -> str:
+    """run-inputs 의 모델 display 값을 wizard 필드로 환원. 알 수 없는 값은
+    빈 문자열(phase 기본값)로 안전하게 떨어뜨린다."""
+    if not isinstance(raw, str):
+        return ""
+    try:
+        return _validate_model(provider, raw)
+    except WizardError:
+        return ""
+
+
+def _build_reuse_previous(state: WizardState) -> Prompt:
+    t = _p(state.workspace_root, "reuse_previous")
+    return Prompt(
+        step=S_REUSE_PREVIOUS, kind="pick",
+        label=t["label"],
+        options=[_opt(k, v) for k, v in t["options"].items()],
+        echo_template=t["echo_template"],
+    )
+
+
+def _submit_reuse_previous(state: WizardState, value: str) -> Optional[str]:
+    if value not in ("yes", "no"):
+        raise WizardError(f"expected 'yes' or 'no', got: {value!r}")
+    if value == "no":
+        state.reuse_previous = False
+        return "reuse-previous: no (step-by-step re-entry)"
+    state.reuse_previous = True
+    seg = slugify_task_segment(state.task_type)
+    inputs = _latest_run_inputs(state, phase_segment=seg)
+    state.use_defaults = False
+    workers = inputs.get("workers")
+    state.workers_override = (
+        ",".join(w for w in workers if isinstance(w, str))
+        if isinstance(workers, list) else "")
+    state.lead_model = _safe_model("claude", inputs.get("leadModel"))
+    state.claude_model = _safe_model("claude", inputs.get("claudeModel"))
+    state.codex_model = _safe_model("codex", inputs.get("codexModel"))
+    state.gemini_model = _safe_model("gemini", inputs.get("geminiModel"))
+    state.report_writer_model = _safe_model(
+        "claude", inputs.get("reportWriterModel"))
+    directive = inputs.get("directive")
+    state.directive = directive if isinstance(directive, str) else ""
+    related = inputs.get("relatedTasks")
+    state.related_tasks_raw = related if isinstance(related, str) else ""
+    # clarification 은 직전 run 의 입력이 아니라 "직전 run 의 산출물(가장 최근
+    # final-report)" 을 재실행 입력으로 자동 선택한다 — resume-clarification 의 본질.
+    state.clarification_response_path = _suggest_latest_final_report(state)
+    for sid in _REUSE_FILLED_STEPS:
+        if sid not in state.answered:
+            state.answered.append(sid)
+    return (f"reuse-previous: yes "
+            f"(workers={state.workers_override or 'profile-default'}, "
+            f"lead-model={state.lead_model or 'default'})")
+
+
 def _build_defaults_or_custom(state: WizardState) -> Prompt:
     t = _p(state.workspace_root, "defaults_or_custom")
     return Prompt(
@@ -2158,6 +2225,18 @@ STEPS: list[Step] = [
          applies=lambda s: (s.critic_pending_text and S_CRITIC_TEXT not in s.answered),
          build=_build_critic_text, submit=_submit_critic_text,
          owns=("critic", "critic_pending_text")),
+    # resume: identity 가 모두 정해진 뒤(직전 run 과 같은 task/phase 가 확정),
+    # 모델/워커/directive/related/clarification 설정 단계로 들어가기 직전에
+    # "직전 run 설정 그대로 재사용?" 를 한 번 묻는다. YES 면 그 단계들을 prefill 로
+    # 충족시켜 곧장 confirm 으로 직행하고, NO 면 현행대로 단계별 입력을 받는다.
+    Step(S_REUSE_PREVIOUS,
+         applies=lambda s: (_identity_ready(s)
+                            and s.use_defaults is None
+                            and s.reuse_previous is None
+                            and s.task_type in _RESUME_REUSE_PHASES
+                            and _has_prior_run_inputs(s)),
+         build=_build_reuse_previous, submit=_submit_reuse_previous,
+         owns=("reuse_previous",)),
     Step(S_DEFAULTS_OR_CUSTOM,
          applies=lambda s: (_identity_ready(s)
                             and s.use_defaults is None),
@@ -2365,6 +2444,7 @@ _FIELD_DEFAULTS: dict[str, Any] = {
     "approved_plan_pending_text": False,
     "selected_stage": "auto",
     "executor": "", "critic": "", "critic_pending_text": False,
+    "reuse_previous": None,
     "use_defaults": None, "workers_override": "",
     "lead_model": "", "claude_model": "", "codex_model": "",
     "gemini_model": "", "report_writer_model": "", "directive": "",

package/runtime/templates/reports/final-report.template.md

@@ -35,8 +35,9 @@ implementation-option: {{ frontmatter.implementationOption | yaml_scalar }}
 {% if clarificationCarryIn and clarificationCarryIn.sourceFile %}
 ## 0. Clarification Response Carried In From Previous Run
 
+{{ t("sectionIntro.clarificationCarryIn") }}
+
 - Source file: `{{ clarificationCarryIn.sourceFile }}`
-- {{ t("sectionIntro.clarificationCarryIn") }}
 
 {% endif %}
 ## Summary of the Problem or Verification Target
@@ -78,12 +79,6 @@ implementation-option: {{ frontmatter.implementationOption | yaml_scalar }}
 {% for row in clarificationItems -%}
 | **{{ row.id }}**<br>Ticket: `{{ row.ticketId }}`<br>Kind: `{{ row.kind }}`<br>Blocks: `{{ row.blocks }}`<br>Status: {{ row.status }} | {{ row.statement }} | {{ row.expectedForm }} | {{ row.userInput or '' }} |
 {% endfor %}
-
-{{ t("clarification.columnGuide") }}
-
-- **`Kind`** ∈ `{material, decision, data-point}`.
-- **`Blocks`** ∈ `{approval, next-phase, none}`.
-- **`Status`** ∈ `{open, answered, resolved, obsolete}`.
 {%- endif %}
 
 ## 2. Evidence and Detailed Analysis
@@ -241,11 +236,19 @@ implementation-option: {{ frontmatter.implementationOption | yaml_scalar }}
 ## 5.5.{{ stage.stage }} Stage {{ stage.stage }}: {{ stage.title }}
 
 Slice value: {{ stage.sliceValue }}
+
 Acceptance: {{ stage.acceptance }}
-{% if stage.conformanceTests %}Conformance tests: stage-{{ stage.stage }} — {{ stage.conformanceTests }}
-{% else %}Conformance exemption: {{ stage.conformanceExemption }}
-{% endif %}{% if stage.tddExemption %}TDD exemption: {{ stage.tddExemption }}
+
+{% if stage.conformanceTests %}
+Conformance tests: stage-{{ stage.stage }} — {{ stage.conformanceTests }}
+{% else %}
+Conformance exemption: {{ stage.conformanceExemption }}
+{% endif %}
+{% if stage.tddExemption %}
+
+TDD exemption: {{ stage.tddExemption }}
 {% endif %}
+
 ### Carry-In
 
 {{ stage.carryIn }}

package/runtime/templates/reports/i18n/en.json

@@ -126,8 +126,7 @@
   },
   "clarification": {
     "fillAndRerun": "Fill in your answers then re-run the same phase:",
-    "separateTerminalLabel": "Separate terminal",
-    "columnGuide": "Record cell field values:"
+    "separateTerminalLabel": "Separate terminal"
   },
   "followUpTasks": {
     "headingAside": "Follow-up Tasks"

package/runtime/templates/reports/i18n/ko.json

@@ -126,8 +126,7 @@
   },
   "clarification": {
     "fillAndRerun": "답을 채우신 뒤 같은 phase 를 다시 실행:",
-    "separateTerminalLabel": "별도 터미널",
-    "columnGuide": "항목 칸 안의 값 설명:"
+    "separateTerminalLabel": "별도 터미널"
   },
   "followUpTasks": {
     "headingAside": "후속 작업"