okstra 0.67.0 → 0.68.0

package/runtime/python/okstra_ctl/run.py

@@ -462,12 +462,41 @@ def _commit_is_ancestor(project_root, ancestor: str, descendant: str) -> bool:
     return r.returncode == 0
 
 
+def _check_multi_dep_merged(project_root, plan_run_root, latest,
+                            pred_commits: dict, candidate_base: str,
+                            stage_n: int) -> None:
+    """모든 선행 done commit 이 candidate 에 (내용 기준으로라도) 머지됐는지
+    검증. patch-equivalent 면 보정 row 를 자동 기록(다음 run 은 ancestor 로
+    바로 통과). 아니면 회복 안내를 담아 PrepareError."""
+    from .git_reconcile import content_merged, _record_reconciled
+    for d, head in pred_commits.items():
+        if _commit_is_ancestor(project_root, head, candidate_base):
+            continue
+        match = content_merged(project_root, head, candidate_base)
+        if match.status in ("ancestor", "patch-equivalent"):
+            if plan_run_root is not None:
+                _record_reconciled(
+                    plan_run_root,
+                    impl_task_key=(latest.get(d) or {}).get("impl_task_key", ""),
+                    stage=d, new_commit=match.matched_commit,
+                    replaced=head, reason="auto-patch-id")
+            continue
+        raise PrepareError(
+            f"multi-dependency stage {stage_n}: predecessor stage {d} "
+            f"({head[:8]}) is not merged into the task worktree "
+            f"({candidate_base[:8]}). Merge stage branches "
+            f"(e.g. the `-s{d}` branches) into the task worktree "
+            "(or into main, then refresh the worktree) and retry."
+        )
+
+
 def _resolve_stage_base_commit(
     stage: dict,
     consumer_done_rows: list,
     anchor_base_commit: str,
     candidate_base: str = "",
     project_root=None,
+    plan_run_root=None,
 ) -> str:
     """Pick the git base commit a stage's isolated worktree branches from.
 
@@ -479,18 +508,15 @@ def _resolve_stage_base_commit(
       candidate 를 반환(사용자가 선행을 머지함). 아니면 PrepareError.
 
     Raises PrepareError on missing predecessor / anchor / unmerged predecessor."""
+    from .consumers import latest_done_by_stage
+    latest = latest_done_by_stage(consumer_done_rows)
     deps = stage.get("depends_on") or []
     if len(deps) >= 2:
         n = stage["stage_number"]
         # 1) 모든 선행의 done head_commit 수집
         pred_commits = {}
         for d in deps:
-            head = next(
-                (r.get("head_commit") for r in consumer_done_rows
-                 if r.get("stage") == d and r.get("status") == "done"
-                 and r.get("head_commit")),
-                None,
-            )
+            head = (latest.get(d) or {}).get("head_commit")
             if not head:
                 raise PrepareError(
                     f"predecessor stage {d} has no done row with head_commit "
@@ -503,16 +529,10 @@ def _resolve_stage_base_commit(
                 f"candidate base missing for multi-dependency stage {n}; "
                 "task-key worktree HEAD could not be resolved"
             )
-        # 3) 모든 선행 done 이 candidate 의 ancestor 인지 (=사용자가 머지함)
-        for d, head in pred_commits.items():
-            if not _commit_is_ancestor(project_root, head, candidate_base):
-                raise PrepareError(
-                    f"multi-dependency stage {n}: predecessor stage {d} "
-                    f"({head[:8]}) is not merged into the task worktree "
-                    f"({candidate_base[:8]}). Merge stage branches "
-                    f"(e.g. the `-s{d}` branches) into the task worktree "
-                    "(or into main, then refresh the worktree) and retry."
-                )
+        # 3) 모든 선행 done 이 candidate 에 (ancestor 또는 patch-equivalent 로)
+        #    머지됐는지 — patch-equivalent 면 보정 row 를 자동 기록한다.
+        _check_multi_dep_merged(project_root, plan_run_root, latest,
+                                pred_commits, candidate_base, n)
         return candidate_base
     if not deps:
         if not anchor_base_commit:
@@ -524,11 +544,9 @@ def _resolve_stage_base_commit(
         return anchor_base_commit
     # 단일 의존
     pred = deps[0]
-    for row in consumer_done_rows:
-        if row.get("stage") == pred and row.get("status") == "done":
-            head = row.get("head_commit") or ""
-            if head:
-                return head
+    head = (latest.get(pred) or {}).get("head_commit") or ""
+    if head:
+        return head
     raise PrepareError(
         f"predecessor stage {pred} has no done row with head_commit in "
         "consumers.jsonl; cannot derive base for stage "
@@ -553,7 +571,8 @@ def _resolve_whole_task_target(
 ) -> "_FVTarget":
     """전체-task 검증 target. 모든 Stage Map stage 가 done + HEAD 에 머지 +
     worktree clean 이어야 한다. 위반 시 PrepareError."""
-    done_by_stage = {r["stage"]: r for r in done_rows}
+    from .consumers import latest_done_by_stage
+    done_by_stage = latest_done_by_stage(done_rows)
     for s in stage_map:
         n = s["stage_number"]
         if n not in done_by_stage:
@@ -587,8 +606,9 @@ def _resolve_single_stage_target(
 ) -> "_FVTarget":
     """단독-stage 검증 target. stage N 만 done + stage worktree 존재 + clean.
     다른 stage 의 done/머지 여부와 무관. 위반 시 PrepareError."""
+    from .consumers import latest_done_by_stage
     n = int(requested_stage)
-    done_by_stage = {r["stage"]: r for r in done_rows}
+    done_by_stage = latest_done_by_stage(done_rows)
     if n not in done_by_stage:
         raise PrepareError(
             f"final-verification(single-stage): stage {n} not done — "
@@ -1290,6 +1310,7 @@ class StageSelection:
     worktree_status: str
     worktree_note: str
     started_head_commit: str
+    concurrent_stages: list = field(default_factory=list)
 
 
 def _select_and_provision_implementation_stage(
@@ -1315,6 +1336,7 @@ def _select_and_provision_implementation_stage(
     # carry sidecars are the SSOT for stage completion; recover any `done` rows
     # the lead failed to append before the dependency gate reads them.
     backfill_done_from_carry(plan_run_root)
+    _auto_reconcile_best_effort(inp, plan_run_root)
     consumed = read_consumers(plan_run_root)
     done_stages = {r["stage"] for r in consumed if r.get("status") == "done"}
     started_stages = {r["stage"] for r in consumed if r.get("status") == "started"}
@@ -1327,6 +1349,7 @@ def _select_and_provision_implementation_stage(
         started_stages=started_stages, reserved_stages=reserved_stages,
     )
     selected = batch[0]
+    concurrent_stages = sorted(reserved_stages - {selected})
 
     # spec §2.1 degradation: 주변 흐름이 non-git / nested-worktree 로 skipped 면
     # stage 격리도 동일하게 degrade — worktree 없이 project HEAD 만 기록.
@@ -1340,6 +1363,7 @@ def _select_and_provision_implementation_stage(
             worktree_status=executor_worktree_status,
             worktree_note="",
             started_head_commit=head,
+            concurrent_stages=concurrent_stages,
         )
 
     # anchor base commit 1회 고정 (task-key worktree HEAD 기준)
@@ -1360,6 +1384,7 @@ def _select_and_provision_implementation_stage(
     stage_base = _resolve_stage_base_commit(
         selected_stage, consumer_done_rows, anchor_base_commit=anchor,
         candidate_base=head_sha, project_root=Path(inp.project_root),
+        plan_run_root=plan_run_root,
     )
     try:
         prov = _worktree.provision_stage_worktree(
@@ -1372,7 +1397,12 @@ def _select_and_provision_implementation_stage(
             base_commit=stage_base,
         )
     except RuntimeError as exc:
-        raise PrepareError(f"stage worktree provisioning failed: {exc}") from exc
+        from .git_reconcile import guidance
+        hint = guidance(plan_run_root=plan_run_root, project_id=inp.project_id,
+                        task_group=inp.task_group, task_id=inp.task_id,
+                        work_category=inp.work_category)
+        raise PrepareError(
+            f"stage worktree provisioning failed: {exc}\n{hint}") from exc
 
     return StageSelection(
         stage=selected,
@@ -1382,6 +1412,7 @@ def _select_and_provision_implementation_stage(
         worktree_status=prov.status,
         worktree_note=prov.note,
         started_head_commit=prov.base_ref,
+        concurrent_stages=concurrent_stages,
     )
 
 
@@ -1400,6 +1431,7 @@ def _apply_implementation_stage(
     ctx["effective_stages"] = [sel.stage]
     csv = str(sel.stage)
     ctx["EFFECTIVE_STAGES"] = csv
+    ctx["CONCURRENT_RUN_STAGES"] = ",".join(str(s) for s in sel.concurrent_stages)
     ctx["STAGE_BATCH_DIRECTIVE"] = (
         f"- **Stage for this implementation run:** `{csv}`. "
         "Execute exactly this Stage Map stage — this is the authoritative scope. "
@@ -1436,6 +1468,20 @@ def _git_out(cwd, *args) -> str:
     return r.stdout.strip() if r.returncode == 0 else ""
 
 
+def _auto_reconcile_best_effort(inp: "PrepareInputs", plan_run_root: Path) -> None:
+    try:
+        from .git_reconcile import auto_reconcile
+        for it in auto_reconcile(
+                project_root=Path(inp.project_root), plan_run_root=plan_run_root,
+                project_id=inp.project_id, task_group=inp.task_group,
+                task_id=inp.task_id, work_category=inp.work_category):
+            print(f"git-reconcile: stage {it.stage} done commit "
+                  f"{it.recorded[:8]} -> {it.suggested_commit[:8]} "
+                  "(patch-equivalent)", file=sys.stdout)
+    except Exception as exc:  # 화해는 부가 기능 — 실패 시 기존 gate 가 판정
+        print(f"git-reconcile skipped: {exc}", file=sys.stderr)
+
+
 def _is_ancestor(cwd, commit, head) -> bool:
     if not commit or not head:
         return False
@@ -1464,6 +1510,7 @@ def _reserve_final_verification_target(
     # carry sidecars are the SSOT for stage completion — recover missing `done`
     # rows before the whole-task gate checks every stage.
     backfill_done_from_carry(plan_run_root)
+    _auto_reconcile_best_effort(inp, plan_run_root)
     done_rows = [r for r in read_consumers(plan_run_root)
                  if r.get("status") == "done"]
 
@@ -1485,8 +1532,9 @@ def _reserve_final_verification_target(
         anchor = _reg.get_implementation_base(
             inp.project_id, inp.task_group, inp.task_id) or ""
         head = _git_out(wt_path, "rev-parse", "HEAD")
-        merged = {r["stage"]: _is_ancestor(wt_path, r.get("head_commit", ""), head)
-                  for r in done_rows}
+        from .consumers import latest_done_by_stage
+        merged = {s: _is_ancestor(wt_path, r.get("head_commit", ""), head)
+                  for s, r in latest_done_by_stage(done_rows).items()}
         target = _resolve_whole_task_target(
             stage_map=ctx_stage_map, done_rows=done_rows, anchor_base=anchor,
             task_worktree_path=wt_path, task_head=head,
@@ -1959,10 +2007,19 @@ def prepare_task_bundle(inp: PrepareInputs) -> PrepareOutputs:
     if not inp.render_only:
         _provision_settings_symlink(inp)
 
+    concurrent_run: dict = {}
+    if impl_stage_selection is not None and impl_stage_selection.concurrent_stages:
+        concurrent_run = {
+            "detected": True,
+            "active_stages": impl_stage_selection.concurrent_stages,
+        }
     return PrepareOutputs(
         ctx=ctx,
         prompt_text=prompt_text,
-        extras={"profile_content": profile_content},
+        extras={
+            "profile_content": profile_content,
+            "concurrent_run": concurrent_run,
+        },
     )
 
 
@@ -2132,6 +2189,10 @@ def main(argv: list[str]) -> int:
     print(f"okstra instruction-set: {ctx['INSTRUCTION_SET_PATH']}")
     print(f"okstra reference expectations: {ctx['REFERENCE_EXPECTATIONS_FILE']}")
     print(f"okstra final report template: {ctx['FINAL_REPORT_TEMPLATE_PATH']}")
+    cr = out.extras.get("concurrent_run", {})
+    if cr.get("detected"):
+        stages_csv = ",".join(str(s) for s in cr["active_stages"])
+        print(f"okstra concurrent-run stages: {stages_csv}")
     if inputs.render_only:
         print()
         print(out.prompt_text, end="")

package/runtime/python/okstra_ctl/wizard.py

@@ -261,6 +261,7 @@ S_BRANCH_CONFIRM = "branch_confirm"
 S_CONFIRM = "confirm"
 S_EDIT_TARGET = "edit_target"
 S_DONE = "done"
+S_ABORTED = "aborted"
 
 # ---- 멀티탭 배치 프롬프트 그룹 (방출 계층 전용) ----
 # 그룹 id 는 S_* 가 아니므로 prompts JSON SOT / step-id 동기화 검사 대상이 아니다.
@@ -362,6 +363,8 @@ class WizardState:
     branch_confirmed: Optional[bool] = None
     confirmed: Optional[bool] = None
     edit_target: str = ""
+    # terminal: user picked 중단 — no further prompt ever applies
+    aborted: bool = False
 
     # bookkeeping
     answered: list[str] = field(default_factory=list)
@@ -384,7 +387,7 @@ class Option:
 @dataclass
 class Prompt:
     step: str
-    kind: str  # "pick" | "text" | "done"
+    kind: str  # "pick" | "text" | "pick_group" | "done" | "aborted"
     label: str = ""
     options: list[Option] = field(default_factory=list)
     help: str = ""
@@ -2201,6 +2204,7 @@ def _build_branch_confirm(state: WizardState) -> Prompt:
     options = [_opt("proceed", opts["proceed"])]
     if decision.status == "new":
         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"])
 
@@ -2210,8 +2214,13 @@ def _submit_branch_confirm(state: WizardState, value: str) -> Optional[str]:
         _reset_from(state, S_BASE_REF_PICK)
         state.branch_confirmed = None
         return "branch-confirm: edit"
+    if value == "abort":
+        state.aborted = True
+        return "branch-confirm: abort"
     if value != "proceed":
-        raise WizardError(f"expected 'proceed' or 'edit', got: {value!r}")
+        raise WizardError(
+            f"expected 'proceed' / 'edit' / 'abort', got: {value!r}"
+        )
     state.branch_confirmed = True
     return "branch-confirm: proceed"
 
@@ -2685,6 +2694,8 @@ def _build_group_prompt(state: WizardState, group_id: str) -> Prompt:
 
 
 def next_prompt(state: WizardState) -> Prompt:
+    if state.aborted:
+        return Prompt(step=S_ABORTED, kind="aborted")
     if state.confirmed:
         return Prompt(step=S_DONE, kind="done")
     for step in STEPS:
@@ -2731,7 +2742,7 @@ def submit(state: WizardState, value: str) -> dict[str, Any]:
     validation failure (caller may re-prompt).
     """
     prompt = next_prompt(state)
-    if prompt.kind == "done":
+    if prompt.kind in ("done", "aborted"):
         return {"echo": "", "next": prompt.to_json()}
     if prompt.kind == "pick_group":
         return _submit_group(state, prompt, value)
@@ -2745,6 +2756,10 @@ def submit(state: WizardState, value: str) -> dict[str, Any]:
 
 def render_args(state: WizardState) -> dict[str, str]:
     """Convert finalized state into ``okstra render-bundle`` argument map."""
+    if state.aborted:
+        raise WizardError(
+            "wizard was aborted by the user — render-args is unavailable"
+        )
     workers = state.workers_override.strip()
     if state.task_type == "implementation":
         workers = ""  # profile-default roster is mandatory for impl
@@ -2928,7 +2943,13 @@ def _cli(argv: list[str]) -> int:
 
     if args.cmd == "render-args":
         state = load_state_file(state_path)
-        print(json.dumps({"ok": True, "args": render_args(state)},
+        try:
+            rendered = render_args(state)
+        except WizardError as exc:
+            print(json.dumps({"ok": False, "error": str(exc)},
+                             ensure_ascii=False, indent=2))
+            return 0
+        print(json.dumps({"ok": True, "args": rendered},
                          ensure_ascii=False, indent=2))
         return 0
 

package/runtime/python/okstra_ctl/worktree.py

@@ -492,11 +492,14 @@ def compute_worktree_path(
     task_group_segment: str,
     task_id_segment: str,
     stage_number: Optional[int] = None,
+    group_id: Optional[str] = None,
 ) -> Path:
     """Pure path computation. One worktree dir per task-key, or per
     `<task-key>/stage-<N>` when stage_number is given (implementation
     stage isolation). Uses `OKSTRA_HOME` when set (test hook), else
     `~/.okstra`."""
+    if stage_number is not None and group_id is not None:
+        raise ValueError("stage_number and group_id are mutually exclusive")
     okstra_home = os.environ.get("OKSTRA_HOME", "").strip()
     base = Path(okstra_home) if okstra_home else (Path.home() / ".okstra")
     path = (
@@ -507,6 +510,8 @@ def compute_worktree_path(
     )
     if stage_number is not None:
         path = path / f"stage-{stage_number}"
+    if group_id is not None:
+        path = path / f"group-{group_id}"
     return path
 
 
@@ -515,12 +520,17 @@ def compute_branch_name(
     work_category: str,
     task_id_segment: str,
     stage_number: Optional[int] = None,
+    group_id: Optional[str] = None,
 ) -> str:
     """One branch per task-key, or `<prefix>-<task-id>-s<N>` for an
     implementation stage worktree."""
+    if stage_number is not None and group_id is not None:
+        raise ValueError("stage_number and group_id are mutually exclusive")
     name = f"{_work_category_prefix(work_category)}-{_safe_segment(task_id_segment)}"
     if stage_number is not None:
         name = f"{name}-s{stage_number}"
+    if group_id is not None:
+        name = f"{name}-{group_id}"
     return name
 
 

package/runtime/python/okstra_ctl/worktree_registry.py

@@ -46,13 +46,17 @@ def _okstra_worktrees_dir() -> Path:
 def task_key(
     project_id: str, task_group: str, task_id: str,
     stage_number: Optional[int] = None,
+    group_id: Optional[str] = None,
 ) -> str:
-    """Canonical task-key. With stage_number, returns the stage-scoped
-    key `<proj>/<group>/<task>#stage-<N>` used to reserve a per-stage
-    worktree independently of the task-key entry."""
+    """Canonical task-key. stage_number → `#stage-<N>` (per-stage worktree),
+    group_id → `#group-<id>` (stage-group collector worktree). 둘은 상호배타."""
+    if stage_number is not None and group_id is not None:
+        raise ValueError("stage_number and group_id are mutually exclusive")
     base = f"{project_id}/{task_group}/{task_id}"
     if stage_number is not None:
         return f"{base}#stage-{stage_number}"
+    if group_id is not None:
+        return f"{base}#group-{group_id}"
     return base
 
 
@@ -70,6 +74,7 @@ class WorktreeEntry:
     status: str = "active"  # "active" | "released"
     stage: Optional[int] = None
     implementation_base_commit: str = ""
+    stages: Optional[list] = None
 
 
 @contextlib.contextmanager
@@ -119,8 +124,9 @@ def _save(data: dict) -> None:
 def lookup(
     project_id: str, task_group: str, task_id: str,
     stage_number: Optional[int] = None,
+    group_id: Optional[str] = None,
 ) -> Optional[WorktreeEntry]:
-    key = task_key(project_id, task_group, task_id, stage_number)
+    key = task_key(project_id, task_group, task_id, stage_number, group_id)
     with _registry_lock():
         data = _load()
         row = data["tasks"].get(key)
@@ -139,18 +145,20 @@ def reserve(
     base_ref: str,
     phase: str = "",
     stage_number: Optional[int] = None,
+    group_id: Optional[str] = None,
+    stages: Optional[list] = None,
 ) -> WorktreeEntry:
     """Atomically insert a new entry. Raises RuntimeError if the
     task-key already exists or the branch is already owned by a
     different task-key. Callers should `lookup()` first when re-entry
     is expected.
     """
-    key = task_key(project_id, task_group, task_id, stage_number)
+    key = task_key(project_id, task_group, task_id, stage_number, group_id)
     now = time.strftime("%Y-%m-%dT%H:%M:%S%z") or time.strftime("%Y-%m-%dT%H:%M:%S")
     with _registry_lock():
         data = _load()
-        if key in data["tasks"]:
-            existing = data["tasks"][key]
+        existing = data["tasks"].get(key)
+        if existing and existing.get("status") != "released":
             raise RuntimeError(
                 f"task-key already has a worktree registered: {key} → "
                 f"{existing['worktree_path']} (branch {existing['branch']}). "
@@ -174,6 +182,7 @@ def reserve(
             "last_phase": phase,
             "status": "active",
             "stage": stage_number,
+            "stages": stages,
         }
         data["tasks"][key] = row
         data["branches"][branch] = key
@@ -218,6 +227,24 @@ def set_implementation_base(
         return commit
 
 
+def reset_implementation_base(
+    project_id: str, task_group: str, task_id: str, commit: str,
+) -> str:
+    """anchor 를 의식적으로 재고정한다. 유일한 호출자는 git-reconcile 의
+    `--reset-anchor` — prepare 경로는 절대 anchor 를 움직이지 않는다."""
+    key = task_key(project_id, task_group, task_id)
+    with _registry_lock():
+        data = _load()
+        row = data["tasks"].get(key)
+        if row is None:
+            raise RuntimeError(
+                f"no task-key entry to reset implementation base: {key}"
+            )
+        row["implementation_base_commit"] = commit
+        _save(data)
+        return commit
+
+
 def get_implementation_base(
     project_id: str, task_group: str, task_id: str,
 ) -> Optional[str]:
@@ -262,13 +289,17 @@ def list_active_stage_numbers(
         return out
 
 
-def release(project_id: str, task_group: str, task_id: str) -> Optional[WorktreeEntry]:
+def release(
+    project_id: str, task_group: str, task_id: str,
+    stage_number: Optional[int] = None,
+    group_id: Optional[str] = None,
+) -> Optional[WorktreeEntry]:
     """Mark the entry as `released` (worktree dir intact — preservation
     is the project's policy). The branch index is freed so future
     reservations of the same branch name are not blocked.
     Returns the prior entry, or None when not found.
     """
-    key = task_key(project_id, task_group, task_id)
+    key = task_key(project_id, task_group, task_id, stage_number, group_id)
     with _registry_lock():
         data = _load()
         row = data["tasks"].get(key)

package/runtime/skills/okstra-context-loader/SKILL.md

@@ -155,6 +155,6 @@ Information to be obtained after executing this skill:
 - Reference list of config files/deployment manifests and task-level expected values
 - Current run status and presence of existing worker results
 - Current run prompt history contract for attempted workers
-- Candidate `teamName` for Phase 3 hand-off: `okstra-<task-key>` (with task-key slugified per Step 1's slug rule)
+- Candidate `teamName` for Phase 3 hand-off: `okstra-<task-key>` (with task-key slugified per Step 1's slug rule); implementation stage runs append `-s<N>` — the launch prompt's Team Creation Gate block carries the final name verbatim
 - Current Claude `lead.sessionId` (the in-flight Claude Code session) — required by `okstra-team-contract` when registering the lead in `team-state.json`
 - Resume command path: from `task-manifest.json` → `latestResumeCommandPath` (fallback: latest `runs/<task-type>/sessions/claude-resume-*.sh` by mtime). Never reconstruct the filename — the `<seq>` counter is category-local and may diverge from `manifests/`.

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

@@ -264,7 +264,7 @@ Agent(
   prompt: "<re-verification prompt with findings batch>",
   name: "<role-slug>-reverify-r<N>",
   subagent_type: "<same as initial execution>",
-  team_name: "okstra-<task-key>",
+  team_name: "<teamName recorded in team-state>",
   model: "<same as initial execution>",
   mode: "auto"
 )

package/runtime/skills/okstra-report-writer/SKILL.md

@@ -34,7 +34,7 @@ Agent(
   prompt: "<report-writer prompt: see this skill + Required reading clause + Available MCP Servers section>",
   name: "report-writer",
   subagent_type: "report-writer-worker",
-  team_name: "okstra-<task-key>",   # omit if team is not alive — see Resume-safe dispatch
+  team_name: "<teamName recorded in team-state>",   # omit if team is not alive — see Resume-safe dispatch
   model: "<family token of Report writer worker's modelExecutionValue>",   # opus/sonnet/haiku — NOT hardcoded; see below
   mode: "auto"
 )
@@ -68,7 +68,7 @@ The prompt MUST include, in this order at the top:
 
 A resumed lead session can ALWAYS dispatch a fresh Report writer worker. The Agent tool does not require a previously created Team to be alive:
 
-- If `TeamCreate` for `okstra-<task-key>` still succeeds (or the team is still listed), include `team_name` in the dispatch.
+- If `TeamCreate` for the team-state `teamName` still succeeds (or the team is still listed), include `team_name` in the dispatch.
 - If `TeamCreate` reports the name is taken or the team is gone, omit `team_name` from the dispatch — the worker still runs as a background subagent and its session is still recoverable by `agentName: "report-writer"` in `okstra-token-usage.py`.
 - Do NOT skip dispatch because of any team-related error. Record the team status in team-state and proceed without `team_name`.
 

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

@@ -45,8 +45,9 @@ The wizard tells you *which UI to use* via `kind` (and the optional `multi` flag
 - `kind: "pick_group"` → render a SINGLE `AskUserQuestion` whose questions array maps 1:1 to the wizard's `questions[]`. For each entry use `questions[].label`, `questions[].options[].label`, and `multiSelect: questions[].multi`. Collect the user's chosen `options[].value` per tab, build a JSON object keyed by each `questions[].step`, and submit it as a single literal `--answer '{"lead_model":"opus","claude_model":"default",...}'`. A tab the user leaves at its default still gets its `"default"`/`""` value in the JSON. Never split a `pick_group` into multiple `AskUserQuestion` calls — the wizard already capped it at 4 tabs and emits any remainder as the next prompt.
 - `kind: "text"` → write `label` as a plain text message and consume the user's NEXT message as the answer.
 - `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.
+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.
 
 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.
 
@@ -92,7 +93,7 @@ Output: the same `{ok, next}` JSON described above. The first `next` is always `
 
 ## Step 3: Run the prompt loop
 
-Repeat until `next.kind == "done"`:
+Repeat until `next.kind == "done"` (or `"aborted"` — terminal cancel, see "How the wizard talks to you"):
 
 1. **Render** the prompt according to `kind` (and `multi` for pick):
    - `pick` + `multi: false` → `AskUserQuestion` with `multiSelect: false`, `label`, and `options`. The user's chosen option's `value` is the answer string.
@@ -178,7 +179,7 @@ okstra render-bundle \
   --pr-template-path "<args.pr-template-path>"
 ```
 
-`render-bundle` auto-supplies `--workspace-root` and forces `--render-only`. Stdout prints `okstra task root:`, `okstra instruction-set:`, and the full rendered lead prompt. Parse the labelled lines for `TASK_ROOT` and `INSTRUCTION_SET_PATH`.
+`render-bundle` auto-supplies `--workspace-root` and forces `--render-only`. Stdout prints `okstra task root:`, `okstra instruction-set:`, and the full rendered lead prompt. Parse the labelled lines for `TASK_ROOT` and `INSTRUCTION_SET_PATH`. Also watch for an optional `okstra concurrent-run stages:` label line — present only when a concurrent run is detected (see "동시-run 감지 분기" below).
 
 The python function underneath is mutex-protected (`~/.okstra/.locks/<task-key>.lock`), writes `run-context-*.json` + `run-inputs-*.json` + all manifests + discovery files, and registers the run in `~/.okstra/recent.jsonl` with status `prepared`.
 
@@ -196,6 +197,45 @@ This is **never** a lead/worker self-exemption — only the user may waive. Offe
 
 When the user picks a waiver, append `--qa-waiver "<stageKey>:<reason>"` to the `render-bundle` invocation above. Omit the flag entirely otherwise (do **not** pass `--qa-waiver ""`). A malformed value or unknown `<stageKey>` aborts `render-bundle` with a `PrepareError`.
 
+### 동시-run 감지 분기 (concurrent-run)
+
+`render-bundle` stdout 에 `okstra concurrent-run stages: <stages>` 라벨 라인이
+있으면(같은 task-key 의 다른 implementation run 이 `<stages>` 를 점유 중), launch
+프롬프트는 이미 "Concurrent-run: no-team background" 게이트로 렌더돼 있다. 이 라인이
+없으면 동시-run 이 아니므로 이 분기를 건너뛴다. 라인이 있으면 dispatch 전에
+사용자에게 3-옵션 recommendation picker 를 제시한다 (run-prompt recommendation 규칙:
+1–2 추천 + 직접 입력; 이 picker 는 스킬이 author 하는 것이라 wizard `options[]`
+제약과 무관):
+
+1. (추천) 이대로 no-team background 로 진행 — 이미 렌더된 bundle 을 그대로 사용한다.
+   team 을 만들지 않아 `~/.claude/teams/` race 를 회피한다(Teams split-pane 관찰성만 포기).
+2. 대기 — 지금 dispatch 를 보류한다. stage worktree·run-context 는 보존되므로,
+   점유 중인 다른 run 종료 후 같은 stage 를 resume 으로 재개하면 그때는 정상 team
+   경로다. resume 명령(`okstra-inspect` history → resume)을 사용자에게 출력한다.
+3. 직접 입력.
+
+### Stale git SHA recovery (git-reconcile gate)
+
+`render-bundle` 이 `Recorded stage SHAs no longer match the git history` 를 포함한
+`PrepareError` 로 실패하면, okstra 밖에서 git 히스토리가 바뀐 것이다(rebase /
+squash / 리뷰 반영 amend / branch 삭제). 절대 registry/consumers 를 손으로
+고치지 말고 다음 순서로 회복한다:
+
+1. 에러 메시지에 인쇄된 `okstra git-reconcile … --check --json` 명령을 그대로 실행해
+   stale 리포트를 얻는다. (patch-id 로 내용 동일성이 증명되는 항목은 prepare
+   가 이미 자동 화해했으므로, 여기 남는 것은 confirm 항목뿐이다.)
+2. confirm 항목별로 사용자에게 3-옵션 picker 를 제시한다:
+   - **`stage-<N>` branch 의 현재 tip 으로 재기록 (추천)** — 리뷰 반영 등
+     의도된 수정이 그 branch 에 있을 때.
+   - **다른 ref 직접 입력** — 사용자가 commit/branch/tag 를 직접 지정.
+   - **중단** — 회복하지 않고 run 을 멈춘다.
+3. 선택된 ref 로 `okstra git-reconcile … --apply --stage <N> --use-ref <ref>`
+   를 실행한 뒤, 실패했던 `render-bundle` 을 동일 인자로 재시도한다.
+
+anchor(`implementation_base_commit`)가 unresolvable 로 보고되면 같은 명령의
+`--reset-anchor <ref>` 를 사용자 확인 후 실행한다. picker 없이 confirm 항목을
+보정하는 것은 금지 — 런타임도 `--use-ref` 없는 confirm 보정을 거부한다.
+
 ## Step 6: Take over as Claude lead
 
 Read `<INSTRUCTION_SET_PATH>/claude-execution-prompt.md` verbatim and enter `Claude lead` mode. The lead prompt now points to compact intake artifacts first (`active-run-context`, `analysis-profile.md`, and `analysis-packet.md`); full source files such as `analysis-material.md`, `reference-expectations.md`, and `final-report-template.md` are lazy/fallback inputs. Follow the rendered prompt order, do not preempt it.

package/runtime/skills/okstra-team-contract/SKILL.md

@@ -54,7 +54,7 @@ Only workers selected from `recommendedWorkers` in `task-manifest.json` and `res
 
 ## Operating Rules
 
-0. **TeamCreate ordering (BLOCKING).** Before issuing any `Agent` dispatch that includes `team_name`, Lead MUST have called `TeamCreate(team_name: "okstra-<task-key>", ...)` in this run and recorded the outcome in team-state as `teamCreate: { attempted: true, status: "ok"|"error", error?: <message> }`. If the Agent tool rejects a dispatch with `"team must be created first or call without team_name"` / `"team을 먼저 생성하거나 team_name 없이 호출해야 합니다"`, the correct response is to go back to Phase 3 and call `TeamCreate` — NOT to strip `team_name` and retry. The no-`team_name` Phase 5 fallback is only legal when `teamCreate.status == "error"` is already recorded; otherwise stripping `team_name` silently degrades the run to in-process background dispatch and loses the Teams split-pane behavior. See [okstra agent SKILL.md Phase 3](../../agents/SKILL.md) for the full team-creation sequence.
+0. **TeamCreate ordering (BLOCKING).** Before issuing any `Agent` dispatch that includes `team_name`, Lead MUST have called `TeamCreate` with the exact team name from the launch prompt's Team Creation Gate block (`okstra-<task-key>`; implementation stage runs append `-s<N>`) in this run and recorded the outcome in team-state as `teamCreate: { attempted: true, status: "ok"|"error", error?: <message> }` plus the name as `teamName`. On a "team already exists" failure, follow the stale-team recovery in [okstra agent SKILL.md Phase 3 step 2-1](../../agents/SKILL.md) — never shell-delete `~/.claude/teams/...` on your own initiative. If the Agent tool rejects a dispatch with `"team must be created first or call without team_name"` / `"team을 먼저 생성하거나 team_name 없이 호출해야 합니다"`, the correct response is to go back to Phase 3 and call `TeamCreate` — NOT to strip `team_name` and retry. The no-`team_name` Phase 5 fallback is legal when `teamCreate.status == "error"` is already recorded, OR when the launch prompt's concurrent-run gate recorded `status: "skipped", reason: "concurrent-run"`; otherwise stripping `team_name` silently degrades the run to in-process background dispatch and loses the Teams split-pane behavior. See [okstra agent SKILL.md Phase 3](../../agents/SKILL.md) for the full team-creation sequence.
 1. `Claude lead` is responsible for orchestration, convergence supervision, and final-report review/approval. It never overrides worker analysis results, and it never authors the final-report file when `Report writer worker` is in the roster.
 2. `Report writer worker` is NOT an analysis worker. It is excluded from Phase 4/5 (initial analysis) and Phase 5.5 (convergence re-verification). It is spawned only in Phase 6 and is the **author** of the final-report file at `runs/<task-type>/reports/final-report-<task-type>-<seq>.md`.
 3. When `Report writer worker` is in the roster, Lead MUST dispatch it in Phase 6. The only legal lead-authored fallback is when a dispatch was attempted and recorded a terminal status of `error` / `timeout` / `not-run` with a concrete logged reason. Speculative reasons such as "session resume constraint" or "team is no longer alive" are NOT valid — Lead can always dispatch a fresh subagent (omit `team_name` if the team is gone).
@@ -406,7 +406,7 @@ okstra token-usage /abs/path/to/run/state/team-state-<task-type>-<seq>.json --wr
 `okstra token-usage` is a thin Node-side wrapper around the python helper installed at `~/.okstra/bin/okstra-token-usage.py`. Calling the python script directly with `python3 "$HOME/..."` is forbidden — the `$HOME` expansion breaks the literal-token permission match and forces a confirmation prompt every call.
 
 The script reads:
-- `~/.claude/projects/<encoded-cwd>/<sessionId>.jsonl` for the lead and every Claude-side worker (Claude worker, Report writer worker, plus the Claude wrappers around Codex/Gemini workers). Sessions are discovered by `teamName: okstra-<task-id>`, lead is identified by `lead.sessionId`, and other workers are identified by `agentName` (e.g. `claude-worker`, `codex-worker`, `gemini-worker`, `report-writer`). **For this `agentName` match to work, Lead MUST set the Agent `name` arg to `<workerId>-worker` on every dispatch** (see [agents SKILL.md Phase 4 — "Agent `name` on dispatch"](../../agents/SKILL.md)); a worker dispatched without `name` carries no `agentName`, so the collector cannot attribute its session and records it `unavailable` (now surfaced as a `usageSummary.unattributedTeamSessions` entry rather than dropped silently).
+- `~/.claude/projects/<encoded-cwd>/<sessionId>.jsonl` for the lead and every Claude-side worker (Claude worker, Report writer worker, plus the Claude wrappers around Codex/Gemini workers). Sessions are discovered by the recorded team-state `teamName`, lead is identified by `lead.sessionId`, and other workers are identified by `agentName` (e.g. `claude-worker`, `codex-worker`, `gemini-worker`, `report-writer`). **For this `agentName` match to work, Lead MUST set the Agent `name` arg to `<workerId>-worker` on every dispatch** (see [agents SKILL.md Phase 4 — "Agent `name` on dispatch"](../../agents/SKILL.md)); a worker dispatched without `name` carries no `agentName`, so the collector cannot attribute its session and records it `unavailable` (now surfaced as a `usageSummary.unattributedTeamSessions` entry rather than dropped silently).
 - `~/.codex/sessions/Y/M/D/rollout-*.jsonl` for the underlying Codex CLI session (matched by `cwd` and timestamp window of the wrapper subagent). Last `event_msg.token_count.total_token_usage.total_tokens` is the session total.
 - `~/.gemini/tmp/<project>/chats/session-*.json` for the underlying Gemini CLI session. Sum of per-message `tokens.total`.