okstra 0.61.0 → 0.63.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "okstra",
-  "version": "0.61.0",
+  "version": "0.63.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.61.0",
-  "builtAt": "2026-06-09T07:19:02.278Z",
+  "package": "0.63.0",
+  "builtAt": "2026-06-09T09:05:23.698Z",
   "repoRoot": "/home/runner/work/okstra/okstra"
 }

package/runtime/agents/workers/claude-worker.md

@@ -90,8 +90,12 @@ You are an in-process Claude subagent — Lead's `Agent()` call blocks until you
 
 After your `Write` to the assigned worker-results file (path provided by Lead as `**Result Path:**` — the canonical anchor header defined in `okstra-team-contract` "Worker Prompt Composition" — or derived under `runs/<task-type>/worker-results/claude-worker-<task-type>-<seq>.md`) succeeds:
 
-1. Return your final assistant message **immediately**, in this format:
-   `Worker results written to <abs path>. Sections 1–5 complete. Findings: <n>.`
+1. Return your final assistant message **immediately**. Begin every return with your model identity, copied verbatim from the `**Model:** Claude worker, <modelExecutionValue>` line in your dispatch prompt (per Worker Preamble → "Return message to the lead"), then the status line — for an analysis dispatch:
+   ```
+   **Model:** Claude worker, <modelExecutionValue>
+   Worker results written to <abs path>. Sections 1–5 complete. Findings: <n>.
+   ```
+   The `**Model:**` line precedes whatever you return — analysis status above, or a convergence reverify verdict summary.
 2. Do NOT perform additional `Read`, `Grep`, `Glob`, MCP, or self-review tool calls after the file is written.
 3. Do NOT rewrite the worker-results file with `Write` more than once. If a correction is genuinely required, perform a single `Edit` and then return immediately.
 4. The only exception is recording a `tool-failure` in the errors sidecar when a post-Write failure is itself the failure being reported — return immediately after that single sidecar append.

package/runtime/agents/workers/codex-worker.md

@@ -106,7 +106,11 @@ The wrapper exists because Claude Code's Bash permission matcher rejects simple-
       2. Record a `cli-failure` event directly to the run-level error log via the exact `okstra-error-log.py append-observed` template in §"Error reporting" — substitute `--exit-code 0`, `--duration-ms <observed-ms>`, `--message "okstra-codex-exec.sh exited 0 but no result file at <abs-path>"`, and `--stderr-excerpt-file <temp-tail-path>`.
       3. Return `CODEX_RESULT_MISSING: codex exited 0 but result file absent at <abs-path>` instead of the raw stdout. The lead is responsible for deciding redispatch per `okstra-team-contract` "Lead Redispatch Policy on Result-Missing".
 
-   d. **Normal return.** Otherwise (`exit_code == 0` AND result file exists), concatenate the wrapper's accumulated stdout from `BashOutput` and return it as-is without modification.
+   d. **Normal return.** Otherwise (`exit_code == 0` AND result file exists), return the wrapper's accumulated stdout from `BashOutput`, prefixed by exactly one model-identity line copied verbatim from the `**Model:** Codex worker, <execution-value>` line in the lead prompt (per Worker Preamble → "Return message to the lead"):
+      ```
+      **Model:** Codex worker, <assigned-model-execution-value>
+      ```
+      Emit that line first, then the stdout unmodified. The model line is the ONLY addition permitted — do not otherwise summarize or alter the CLI output. This applies to convergence reverify dispatches too.
 
 9. When `Task Type` is `improvement-discovery`, the lead's Phase 1.5 reflect-back log at `<RUN_DIR>/state/phase-1.5-grilling.md` is the authoritative scope and lens definition. Read its `Resolved scope` and `Resolved lenses` blocks and do NOT re-interpret the brief's raw `scan-scope` / `priority-lenses` fields. Findings that violate the resolved lens whitelist or scope are rejected by `validators/validate-improvement-report.py`.
 
@@ -228,7 +232,7 @@ pre-flight terminal status, not a runtime CLI error.
 
 - Ignore stderr warnings from MCP integration.
 - Return error messages as-is on failure.
-- Do not summarize or modify Codex results.
+- Do not summarize or modify Codex results beyond prepending the single `**Model:**` line on a normal return (step 8d).
 - Sections 1–5 of the worker output are the common core shared with the Claude and Gemini workers — the dispatched prompt asks identical questions for all three roles, and the Codex CLI must answer all of them, not only implementation-feasibility findings. Your specialization (implementation realism, code-path implications, edge cases, technical trade-offs) belongs only in optional Section 6 as additive depth. A Codex result whose Findings section is populated solely with implementation-feasibility items is in breach of contract; see `skills/okstra-team-contract/SKILL.md` "Worker Output Contract".
 
 ## Stage evidence emission (BLOCKING, implementation task only)

package/runtime/agents/workers/gemini-worker.md

@@ -106,7 +106,11 @@ The wrapper exists because Claude Code's Bash permission matcher rejects simple-
       2. Record a `cli-failure` event directly to the run-level error log via the exact `okstra-error-log.py append-observed` template in §"Error reporting" — substitute `--exit-code 0`, `--duration-ms <observed-ms>`, `--message "okstra-gemini-exec.sh exited 0 but no result file at <abs-path>"`, and `--stderr-excerpt-file <temp-tail-path>`.
       3. Return `GEMINI_RESULT_MISSING: gemini exited 0 but result file absent at <abs-path>` instead of the raw stdout. The lead is responsible for deciding redispatch per `okstra-team-contract` "Lead Redispatch Policy on Result-Missing".
 
-   d. **Normal return.** Otherwise (`exit_code == 0` AND result file exists), concatenate the wrapper's accumulated stdout from `BashOutput` and return it as-is without modification.
+   d. **Normal return.** Otherwise (`exit_code == 0` AND result file exists), return the wrapper's accumulated stdout from `BashOutput`, prefixed by exactly one model-identity line copied verbatim from the `**Model:** Gemini worker, <execution-value>` line in the lead prompt (per Worker Preamble → "Return message to the lead"):
+      ```
+      **Model:** Gemini worker, <assigned-model-execution-value>
+      ```
+      Emit that line first, then the stdout unmodified. The model line is the ONLY addition permitted — do not otherwise summarize or alter the CLI output. This applies to convergence reverify dispatches too.
 
 9. When `Task Type` is `improvement-discovery`, the lead's Phase 1.5 reflect-back log at `<RUN_DIR>/state/phase-1.5-grilling.md` is the authoritative scope and lens definition. Read its `Resolved scope` and `Resolved lenses` blocks and do NOT re-interpret the brief's raw `scan-scope` / `priority-lenses` fields. Findings that violate the resolved lens whitelist or scope are rejected by `validators/validate-improvement-report.py`.
 
@@ -228,7 +232,7 @@ pre-flight terminal status, not a runtime CLI error.
 
 - Always specify the assigned `-m` value for the current run.
 - Return error messages as-is on failure.
-- Do not summarize or modify Gemini results.
+- Do not summarize or modify Gemini results beyond prepending the single `**Model:**` line on a normal return (step 8d).
 - Sections 1–5 of the worker output are the common core shared with the Claude and Codex workers — the dispatched prompt asks identical questions for all three roles, and the Gemini CLI must answer all of them, not only requirement-interpretation findings. Your specialization (requirement interpretation, consistency, safety, documentation quality, alternative viewpoints) belongs only in optional Section 6 as additive depth. A Gemini result whose Findings section is populated solely with requirement-interpretation items is in breach of contract; see `skills/okstra-team-contract/SKILL.md` "Worker Output Contract".
 
 ## Stage evidence emission (BLOCKING, implementation task only)

package/runtime/agents/workers/report-writer-worker.md

@@ -103,7 +103,12 @@ Rules (the schema enforces most of these — they are listed here so you know *w
 - For `implementation-planning`, populate `implementationPlanning.requirementCoverage` with one row per concrete requirement from the brief / packet, using IDs `R-001`, `R-002`, ... in source order. `coveredBy` MUST name the specific Option Candidate plus Stage/Step that satisfies the requirement. Use `status: "covered"` only when the report's plan actually covers it; otherwise use `gap` or `blocked C-NNN` and ensure the corresponding `Clarification Items` row blocks approval. Do not collapse this into `ticketCoverage`; ticket coverage is not requirement coverage.
 - When the `Task Type` is `improvement-discovery`, populate `## 5.9 Improvement Candidates` with the 10-column schema enforced by `validators/validate-improvement-report.py`. Source the row IDs (`I-NNN`), lens whitelist, and Source workers patterns from `scripts/okstra_ctl/improvement_lenses.py` — do NOT introduce new lens names or worker prefixes. `improvement-discovery` is NOT in the data.json schema enum, so author its markdown directly (not via `okstra-render-final-report.py`). Immediately after writing the markdown, run (`Bash`): `python3 scripts/okstra-inject-report-index.py <markdown path> --report-language <en|ko>`. That adds the top-of-report Index plus `I-NNN` / `C-NNN` scroll anchors; the run validator fails the report when the Index anchor is absent.
 
-Write the data.json with your `Write` tool against the absolute `Result Path`. Then invoke the renderer (`Bash`): `python3 scripts/okstra-render-final-report.py <data.json path>`. Confirm both files exist and respond with a short status line: `data.json written to <abs path>; markdown rendered to <abs path>. Sections populated: <count>.`
+Write the data.json with your `Write` tool against the absolute `Result Path`. Then invoke the renderer (`Bash`): `python3 scripts/okstra-render-final-report.py <data.json path>`. Confirm both files exist and respond with a short status line prefixed by your model identity, copied verbatim from the `**Model:** Report writer worker, <modelExecutionValue>` line in your dispatch prompt (per Worker Preamble → "Return message to the lead"):
+
+```
+**Model:** Report writer worker, <modelExecutionValue>
+data.json written to <abs path>; markdown rendered to <abs path>. Sections populated: <count>.
+```
 
 <!-- Worker Result File contract lives above, right after the Authority
      section. The legacy "after Authoring Contract" placement was kept

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

@@ -393,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
 
@@ -415,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

@@ -235,12 +235,17 @@ implementation-option: {{ frontmatter.implementationOption | yaml_scalar }}
 {% for stage in implementationPlanning.stages %}
 ## 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 }}
+- **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 }}
+{% endif %}
+
 ### Carry-In
 
 {{ stage.carryIn }}

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

@@ -68,7 +68,7 @@
     "columnRelatedIds": "Related item IDs"
   },
   "finalVerdict": {
-    "intro": "Final conclusion and recommended direction. `Direction` values: `continue-investigation / begin-implementation / approve / reject / hold`. When `task-type` is `final-verification`, `Verdict Token` is one of `accepted / conditional-accept / blocked` and serves as the `release-handoff` entry gate. For all other task-types: `not-applicable`."
+    "intro": "This run's final conclusion and next action. **`Direction`** is the recommended next action — one of `continue-investigation`, `begin-implementation`, `approve`, `reject`, or `hold` — and is present for every task-type. **`Verdict Token`** is meaningful only for the `final-verification` task-type, where it is one of `accepted`, `conditional-accept`, or `blocked` and serves as the `release-handoff` entry gate. For every other task-type, `Verdict Token` is always `not-applicable`."
   },
   "evidence": {
     "sourceItemsColumnNote": "The `Source items` column is described in §6.1."

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

@@ -68,7 +68,7 @@
     "columnRelatedIds": "관련 항목 IDs"
   },
   "finalVerdict": {
-    "intro": "최종 결론과 권장 방향입니다. `Direction` 값: `continue-investigation / begin-implementation / approve / reject / hold`. `task-type` 이 `final-verification` 일 때 `Verdict Token` 은 `accepted / conditional-accept / blocked` 중 하나이며 `release-handoff` 진입 게이트로 쓰입니다. 그 외 task-type 에서는 `not-applicable`."
+    "intro": "이 run 의 최종 결론과 다음 행동입니다. **`Direction`** 은 권장 다음 행동으로 `continue-investigation`(조사 계속) · `begin-implementation`(구현 시작) · `approve`(승인) · `reject`(반려) · `hold`(보류) 중 하나이며, 모든 task-type 에 존재합니다. **`Verdict Token`** 은 `final-verification` task-type 에서만 의미를 가집니다 — `accepted` · `conditional-accept` · `blocked` 중 하나로 `release-handoff` 진입 게이트로 쓰입니다. 그 외 task-type 에서 `Verdict Token` 은 항상 `not-applicable`(해당 없음) 입니다."
   },
   "evidence": {
     "sourceItemsColumnNote": "`Source items` 열 설명은 §6.1 과 동일합니다."

package/runtime/templates/worker-prompt-preamble.md

@@ -114,6 +114,16 @@ For task types `requirements-discovery`, `error-analysis`, `implementation-plann
 
 See `skills/okstra-team-contract/SKILL.md` "Worker Output Contract" for the full frontmatter schema and section ordering rules. This preamble is consistent with that contract; the team-contract document is authoritative if the two ever diverge.
 
+## Return message to the lead (all workers)
+
+The short message you return inline to the lead — the text shown to the user as your agent box — MUST begin with one line identifying the model you ran under, copied verbatim from the `**Model:** <Role>, <modelExecutionValue>` line in your dispatch prompt:
+
+```
+**Model:** <Role>, <modelExecutionValue>
+```
+
+Emit that line first, then your normal status / summary text on the following lines. This keeps the acting model visible in every worker box — across every provider (Claude / Codex / Gemini / report-writer) and every dispatch type (initial analysis, convergence reverify, report authoring). Copy the value exactly; never guess, abbreviate, or substitute a provider default. If your prompt carries no `**Model:**` line, say so in the return message rather than inventing one. Each worker spec applies this rule at its own concrete return point — see `agents/workers/claude-worker.md` "Stop Condition", `agents/workers/_cli-wrapper-template.md` step 8d, and `agents/workers/report-writer-worker.md` "Authoring Contract".
+
 ## Writing style (all prose output — analysis workers + report-writer)
 
 When you write in Korean (`Report Language: ko` / `meta.reportLanguage = "ko"`), write so a Korean developer understands it on first read. Translate the **meaning**, never the dictionary word.

package/runtime/validators/validate-implementation-plan-stages.py

@@ -162,11 +162,16 @@ def _check_each_stage_section(text: str, stages: List[StageMeta]) -> List[Valida
     return errs
 
 
-SLICE_VALUE = re.compile(r"^\s*Slice value\s*:\s*(.+?)\s*$", re.M)
-ACCEPTANCE = re.compile(r"^\s*Acceptance\s*:\s*(.+?)\s*$", re.M)
-TDD_EXEMPTION = re.compile(r"^\s*TDD exemption\s*:\s*\S", re.M)
-CONFORMANCE_TESTS = re.compile(r"^\s*Conformance tests\s*:\s*\S", re.M)
-CONFORMANCE_EXEMPTION = re.compile(r"^\s*Conformance exemption\s*:\s*\S", re.M)
+# Each label line may be plain (`Slice value: …`) or rendered as a bold-label
+# bullet (`- **Slice value:** …`). The optional `(?:[-*]\s+)?` bullet marker and
+# the two optional `\*\*` groups accept both forms; the bold wraps the colon, so
+# the closing `**` sits AFTER the colon.
+_LABEL_PREFIX = r"^\s*(?:[-*]\s+)?(?:\*\*)?"
+SLICE_VALUE = re.compile(_LABEL_PREFIX + r"Slice value\s*:\s*(?:\*\*)?\s*(.+?)\s*$", re.M)
+ACCEPTANCE = re.compile(_LABEL_PREFIX + r"Acceptance\s*:\s*(?:\*\*)?\s*(.+?)\s*$", re.M)
+TDD_EXEMPTION = re.compile(_LABEL_PREFIX + r"TDD exemption\s*:\s*(?:\*\*)?\s*\S", re.M)
+CONFORMANCE_TESTS = re.compile(_LABEL_PREFIX + r"Conformance tests\s*:\s*(?:\*\*)?\s*\S", re.M)
+CONFORMANCE_EXEMPTION = re.compile(_LABEL_PREFIX + r"Conformance exemption\s*:\s*(?:\*\*)?\s*\S", re.M)
 
 
 def _check_slice_tdd(text: str, stages: List[StageMeta]) -> List[ValidationError]: