okstra 0.71.0 → 0.71.1

package/package.json

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

package/runtime/BUILD.json

@@ -1,5 +1,5 @@
 {
-  "package": "0.71.0",
-  "builtAt": "2026-06-10T18:46:31.471Z",
+  "package": "0.71.1",
+  "builtAt": "2026-06-11T03:33:31.499Z",
   "repoRoot": "/home/runner/work/okstra/okstra"
 }

package/runtime/prompts/profiles/_implementation-deliverable.md

@@ -50,6 +50,6 @@ are collected and convergence finished. Phase 1-5 do not need it.
 
 - Parse the executor's `### Stage Carry Evidence` JSON block. If absent or unparsable, end with status `contract-violated` and route to a follow-up `error-analysis`.
 - For this run's single stage: write its JSON verbatim to `runs/<impl-task-key>/carry/stage-<N>.json`. Refuse to overwrite an existing file (one stage = one sidecar; re-runs are out of scope for this version).
-- For this run's single stage: append a `status:"done"` row to `runs/<plan-task-key>/consumers.jsonl` with `completed_at`, `carry_path`, `report_path` (this run's final-report path relative to the run root), and the SHA of HEAD. Use the okstra runtime's `consumers_mutex` helper (NOT a raw filesystem write) to honour the lock. `report_path` lets `final-verification` cite each stage's originating report when assembling its Source Implementation Report list.
+- For this run's single stage: append a `status:"done"` row to `runs/<plan-task-key>/consumers.jsonl` with `completed_at`, `carry_path`, `report_path` (this run's final-report path relative to the run root), and the SHA of HEAD. Append it with `okstra_ctl.consumers.append_consumer` (NOT a raw filesystem write) — it honours the consumers lock AND releases this stage's worktree-registry occupancy, so later runs stop seeing a finished stage as a concurrent run. `report_path` lets `final-verification` cite each stage's originating report when assembling its Source Implementation Report list.
 - The verifier round, Phase 5.5 convergence, and this Phase 6 report run **once per run** over this stage's diff — NOT per step.
 - Quote this stage's new contents (the sidecar JSON in full and the new consumers row by itself) in the final report's `Stage sidecar evidence` deliverable section.

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

@@ -160,7 +160,7 @@
       }
     },
     "base_ref_pick": {
-      "label": "이 task worktree 의 base branch?",
+      "label": "이 task 의 base branch?",
       "echo_template": "base-ref: {value}",
       "options": {
         "_RECOMMENDED_SUFFIX": " (recommended)",
@@ -170,10 +170,13 @@
     "branch_confirm": {
       "label": "{summary}",
       "labels": {
-        "new": "새 브랜치 `{branch}` 를 base-ref `{base_ref}` 에서 새 worktree(`{path}`)에 생성합니다 — 진행할까요?",
-        "reuse": "현재 worktree(`{path}`, 브랜치 `{branch}`)를 재사용합니다 — 진행할까요?",
+        "new": "새 브랜치 `{branch}` 를 base-ref `{base_ref}` 에서 분기해 `{task_key}` 디렉터리(`{path}`)에 체크아웃합니다 — 진행할까요?",
+        "reuse": "기존 `{task_key}` 디렉터리(`{path}`, 브랜치 `{branch}`)에서 이어서 진행합니다 — 진행할까요?",
         "in_worktree": "현재 worktree(`{path}`)에서 그대로 진행합니다(이미 non-main worktree) — 진행할까요?",
-        "not_git": "git 저장소가 아니므로 `{path}` 에서 직접 진행합니다 — 진행할까요?"
+        "not_git": "git 저장소가 아니므로 `{path}` 에서 직접 진행합니다 — 진행할까요?",
+        "impl_stage_new": "implementation 은 stage 격리로 동작합니다 — stage {stage} worktree 를 `{path}` 에 브랜치 `{branch}` 로 새로 만들고, base 커밋은 의존 stage 의 done 커밋 기준으로 run 준비 시점에 해소됩니다 — 진행할까요?",
+        "impl_stage_reuse": "기존 stage {stage} worktree(`{path}`, 브랜치 `{branch}`)에서 이어서 진행합니다 — 진행할까요?",
+        "impl_stage_auto": "implementation 은 stage 격리로 동작합니다 — stage 번호는 run 준비 시점에 자동 선택되고, `{task_key}` 디렉터리(`{path}`) 아래 `stage-<N>/` worktree 가 새로 만들어지거나 재사용됩니다 — 진행할까요?"
       },
       "options": { "proceed": "진행", "edit": "base-ref 다시 고르기", "abort": "중단" },
       "echo_template": "branch-confirm: {value}"
@@ -407,6 +410,8 @@
   "confirmation": {
     "header": "선택 확인:",
     "workers_implementation_default": "  workers       : (프로필 기본 — executor + verifier 2 + report-writer)",
+    "base_ref_stage_isolated": "  base-ref      : (stage 격리 — 의존 stage 기준으로 run 준비 시점에 자동 해소)",
+    "base_ref_reuse_task_dir": "  base-ref      : (기존 `{task_key}` 디렉터리 재사용 — 최초 base 유지)",
     "stage_whole_task": "전체 task",
     "handoff_scope_whole_task": "전체 task (whole-task 검증 기반)",
     "handoff_scope_stage_group": "stage-group ({stages})"

package/runtime/python/okstra_ctl/consumers.py

@@ -50,22 +50,52 @@ def append_consumer(plan_run_root: Path, *, impl_task_key: str, stage: int,
     if status not in ("started", "done"):
         raise ValueError(f"status must be 'started' or 'done', got: {status!r}")
     with consumers_mutex(plan_run_root):
-        existing = read_consumers(plan_run_root)
-        for row in existing:
-            if (row.get("impl_task_key") == impl_task_key
-                    and row.get("stage") == stage
-                    and row.get("status") == status):
-                if not force_reappend:
-                    return  # idempotent
-                if row.get("head_commit") == fields.get("head_commit"):
-                    return  # 동일 보정의 중복 재-append 방지
-        record: Dict[str, Any] = {
-            "impl_task_key": impl_task_key,
-            "stage": stage,
-            "status": status,
-            **fields,
-        }
-        _append_row(plan_run_root, record)
+        if not _equivalent_row_exists(plan_run_root, impl_task_key, stage,
+                                      status, force_reappend,
+                                      fields.get("head_commit")):
+            record: Dict[str, Any] = {
+                "impl_task_key": impl_task_key,
+                "stage": stage,
+                "status": status,
+                **fields,
+            }
+            _append_row(plan_run_root, record)
+    # done 은 점유 해제 이벤트이기도 하다 — 중복 append(no-op)에서도 풀어야
+    # release 없이 done 만 기록된 과거 run 의 잔존 점유가 다음 호출에서 치유된다.
+    if status == "done":
+        _release_stage_reservation(impl_task_key, stage)
+
+
+def _equivalent_row_exists(plan_run_root: Path, impl_task_key: str, stage: int,
+                           status: str, force_reappend: bool,
+                           head_commit: Any) -> bool:
+    for row in read_consumers(plan_run_root):
+        if (row.get("impl_task_key") == impl_task_key
+                and row.get("stage") == stage
+                and row.get("status") == status):
+            if not force_reappend:
+                return True
+            if row.get("head_commit") == head_commit:
+                return True  # 동일 보정의 중복 재-append 방지
+    return False
+
+
+def _release_stage_reservation(impl_task_key: str, stage: Any) -> None:
+    """done 이 기록된 stage 의 worktree-registry 점유(stage-key)를 해제한다.
+
+    release 는 점유 표시만 푼다 — worktree 디렉토리·브랜치는 보존된다.
+    registry 좌표는 TASK_KEY(`project:group:task`) 각 segment 의
+    safe-segment 와 같다(stage 예약이 그렇게 만들어진다). 형식이 다르면
+    점유 주체가 아니므로 건너뛴다."""
+    parts = impl_task_key.split(":")
+    if len(parts) != 3 or not isinstance(stage, int):
+        return
+    from .ids import _safe_fs_segment
+    from . import worktree_registry
+    worktree_registry.release(
+        _safe_fs_segment(parts[0]), _safe_fs_segment(parts[1]),
+        _safe_fs_segment(parts[2]), stage_number=stage,
+    )
 
 
 def _append_row(plan_run_root: Path, record: Dict[str, Any]) -> None:

package/runtime/python/okstra_ctl/run.py

@@ -1516,7 +1516,10 @@ def _select_and_provision_implementation_stage(
         started_stages=started_stages, reserved_stages=reserved_stages,
     )
     selected = batch[0]
-    concurrent_stages = sorted(reserved_stages - {selected})
+    # done stage 는 동시 run 이 아니다 — done 기록 시 점유는 해제되지만
+    # (consumers._release_stage_reservation), crash·구버전 기록의 잔존
+    # 예약이 남을 수 있어 읽기에서도 차감한다.
+    concurrent_stages = sorted(reserved_stages - done_stages - {selected})
 
     # spec §2.1 degradation: 주변 흐름이 non-git / nested-worktree 로 skipped 면
     # stage 격리도 동일하게 degrade — worktree 없이 project HEAD 만 기록.

package/runtime/python/okstra_ctl/wizard.py

@@ -52,8 +52,10 @@ from okstra_ctl.workers import (
 from okstra_ctl.workflow import PHASE_SEQUENCE
 from okstra_ctl import worktree_registry
 from okstra_ctl.worktree import (
+    compute_worktree_path,
     is_git_work_tree,
     main_worktree_path,
+    preview_stage_worktree_decision,
     preview_worktree_decision,
 )
 from okstra_ctl.paths import task_runs_dir
@@ -2423,6 +2425,8 @@ def _submit_pr_template_scope(state: WizardState, value: str) -> Optional[str]:
 
 
 def _build_branch_confirm(state: WizardState) -> Prompt:
+    if state.task_type == "implementation":
+        return _build_branch_confirm_impl_stage(state)
     decision = preview_worktree_decision(
         project_root=Path(state.project_root),
         project_id=state.project_id,
@@ -2443,6 +2447,7 @@ def _build_branch_confirm(state: WizardState) -> Prompt:
         branch=decision.branch or "(none)",
         base_ref=decision.base_ref or "(HEAD)",
         path=decision.path,
+        task_key=f"{state.task_group}/{state.task_id}",
     )
     # Pass the computed label as `summary` so _p's placeholder interpolation works.
     t = _p(state.workspace_root, "branch_confirm", summary=label)
@@ -2455,6 +2460,43 @@ def _build_branch_confirm(state: WizardState) -> Prompt:
                   options=options, echo_template=t["echo_template"])
 
 
+def _build_branch_confirm_impl_stage(state: WizardState) -> Prompt:
+    """implementation 은 stage 격리로 동작하므로 task-key 디렉터리가 아니라
+    이번 run 이 실제로 사용할 stage worktree 관점으로 미리보기를 보여준다."""
+    raw = _load_wizard_root(state.workspace_root)["steps"]["branch_confirm"]
+    task_key = f"{state.task_group}/{state.task_id}"
+    stage = (state.selected_stage or "auto").strip()
+    if stage == "auto":
+        parent_dir = compute_worktree_path(
+            project_id=state.project_id, task_group_segment=state.task_group,
+            task_id_segment=state.task_id,
+        )
+        label = raw["labels"]["impl_stage_auto"].format(
+            task_key=task_key, path=str(parent_dir),
+        )
+        decision_status = "new"
+    else:
+        decision = preview_stage_worktree_decision(
+            project_id=state.project_id, task_group_segment=state.task_group,
+            task_id_segment=state.task_id, work_category="",
+            stage_number=int(stage),
+        )
+        key = "impl_stage_reuse" if decision.status == "reused" else "impl_stage_new"
+        label = raw["labels"][key].format(
+            stage=stage, path=decision.path, branch=decision.branch,
+            task_key=task_key,
+        )
+        decision_status = decision.status
+    t = _p(state.workspace_root, "branch_confirm", summary=label)
+    opts = t["options"]
+    options = [_opt("proceed", opts["proceed"])]
+    if decision_status == "new" and _base_ref_required(state):
+        options.append(_opt("edit", opts["edit"]))
+    options.append(_opt("abort", opts["abort"]))
+    return Prompt(step=S_BRANCH_CONFIRM, kind="pick", label=label,
+                  options=options, echo_template=t["echo_template"])
+
+
 def _submit_branch_confirm(state: WizardState, value: str) -> Optional[str]:
     if value == "edit":
         _reset_from(state, S_BASE_REF_PICK)
@@ -3096,8 +3138,13 @@ def confirmation_block(state: WizardState) -> str:
     lines.append(f"  brief         : {state.brief_path or '(none)'}")
     if state.task_type == "final-verification":
         lines.append("  base-ref      : (selected stage worktree)")
+    elif state.task_type == "implementation" and state.reuse_worktree:
+        lines.append(_msg(state.workspace_root, "confirmation",
+                          "base_ref_stage_isolated"))
     elif state.reuse_worktree:
-        lines.append("  base-ref      : (reusing existing worktree)")
+        lines.append(_msg(state.workspace_root, "confirmation",
+                          "base_ref_reuse_task_dir",
+                          task_key=f"{state.task_group}/{state.task_id}"))
     else:
         lines.append(f"  base-ref      : {state.base_ref}")
     if state.task_type == "implementation":

package/runtime/python/okstra_ctl/worktree.py

@@ -195,6 +195,41 @@ def preview_worktree_decision(
     )
 
 
+def preview_stage_worktree_decision(
+    *,
+    project_id: str,
+    task_group_segment: str,
+    task_id_segment: str,
+    work_category: str,
+    stage_number: int,
+) -> "WorktreeDecision":
+    """Side-effect-free: what provision_stage_worktree WOULD do (reuse vs new).
+
+    Mirrors provision_stage_worktree's registry-reuse branch exactly. A "new"
+    decision carries no base_ref — the stage base commit is resolved later by
+    the prepare flow from the stage's dependency anchors.
+    """
+    safe_project = _safe_segment(project_id)
+    safe_group = _safe_segment(task_group_segment)
+    safe_task = _safe_segment(task_id_segment)
+    existing = worktree_registry.lookup(
+        safe_project, safe_group, safe_task, stage_number=stage_number)
+    if existing is not None and existing.status == "active":
+        return WorktreeDecision(
+            status="reused", path=existing.worktree_path,
+            branch=existing.branch, base_ref=existing.base_ref,
+        )
+    return WorktreeDecision(
+        status="new",
+        path=str(compute_worktree_path(
+            project_id=safe_project, task_group_segment=safe_group,
+            task_id_segment=safe_task, stage_number=stage_number)),
+        branch=compute_branch_name(
+            work_category=work_category, task_id_segment=safe_task,
+            stage_number=stage_number),
+    )
+
+
 def _safe_segment(value: str) -> str:
     """Sanitise a single path/branch segment.
 

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

@@ -47,7 +47,7 @@ The wizard tells you *which UI to use* via `kind` (and the optional `multi` flag
 - `kind: "done"` → input collection finished; move to Step 5.
 - `kind: "aborted"` → the user picked 중단; the wizard is terminally cancelled. Tell the user on one short line that the run setup was aborted, delete the state file (`rm` with the literal path), and stop this skill — do NOT call `render-args` or `render-bundle` (the wizard rejects `render-args` on an aborted state).
 
-The `branch_confirm` step (shown just before `confirm`) is a normal `pick` step and is rendered the same way — no special handling needed. Its options always include `중단` (abort); `base-ref 다시 고르기` (edit) appears only when a new worktree would be created.
+The `branch_confirm` step (shown just before `confirm`) is a normal `pick` step and is rendered the same way — no special handling needed. Its options always include `중단` (abort); `base-ref 다시 고르기` (edit) appears only when a new branch would be created from the user-chosen base-ref. For `implementation` runs the wizard previews the **stage worktree** this run will actually use (not the task-key directory); render its label verbatim.
 
 Never invent additional questions. Never reorder. **Never drop, hide, or merge a `pick` / `pick_group` option** — render every `options[]` entry as its own selectable `AskUserQuestion` choice, including entries that carry a `(default)` / `(recommended)` suffix. Do NOT collapse a multi-option pick into a "recommended + 직접 입력 / Other" shortlist: the wizard's `options[]` array IS the complete, authoritative choice set. Example: the `executor` step always emits `claude` / `codex` / `gemini` — show all three, never just `claude`. The run-prompt recommendation rule (1–2 추천 + 직접 입력) applies ONLY to prompts this skill authors itself (e.g. the conformance-waiver picker), never to wizard-provided `options[]`. Never use `AskUserQuestion` for `text` prompts — the wizard explicitly chose `text` to avoid the picker-Other re-render lag.