okstra 0.121.0 → 0.122.0

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

@@ -9,7 +9,7 @@ at Phase 5, BEFORE constructing the verifier worker dispatch prompts.
 
 ## Verifier roles (resolved at run-prep time)
 
-- **Verifier dispatch labelling.** Agent `name` = `<provider>-verifier` (here, and identically in `final-verification`); for a `codex` / `antigravity` verifier, Lead additionally injects `**Pane role:** verifier` into the dispatched prompt body. Naming/mapping rules and the token-attribution guarantee are owned by `prompts/lead/okstra-lead-contract.md` Phase 4 "Agent `name` on dispatch".
+- **Verifier dispatch labelling.** The core functional role label is `<provider>-verifier` (here, and identically in `final-verification`). Provider, role, and model identity are owned by `prompts/lead/okstra-lead-contract.md` "Model assignments"; the selected runtime adapter owns provider-native dispatch-label mapping (including any `name` / `**Pane role:**` fields) and token-attribution wiring under its "Semantic operation mapping".
 - The verifier slots are `Claude verifier` and `Codex verifier`, plus `Antigravity verifier` **only when `antigravity` is in the resolved `--workers` roster**. Every verifier in the resolved roster is dispatched regardless of which provider holds the executor role; the executor's own provider is run *separately* as a verifier (a fresh CLI session with no shared context) so that no verdict is produced from the same session that wrote the diff. Verifiers MUST NOT call Edit, Write, or any Bash command that mutates files outside the run's artifact directories. If a verifier wants a fix, it records the recommendation in its worker result; it does not apply the fix itself.
 - Session isolation — not model-variant divergence — is the primary self-review safeguard: each verifier is a separate CLI invocation with its own context window, so reusing the same model variant for executor and same-provider verifier is acceptable. Different model variants (e.g. executor=opus / Claude verifier=sonnet) remain recommended when available.
 - Phase-specific model defaults override the shared defaults: `Claude verifier`=`opus`, `Codex verifier`=`gpt-5.6`, `Antigravity verifier`=`auto` (only when present in the roster). The `Executor`'s model is taken from the provider-specific worker model corresponding to `--executor`: claude→`--claude-model` (default `opus`), codex→`--codex-model` (default `gpt-5.6`), antigravity→`--antigravity-model` (default `auto`).

package/runtime/prompts/profiles/implementation-planning.md

@@ -62,7 +62,7 @@
   - Beyond substring matching, when the Plan Body Verification gate result is `passed` / `passed-with-dissent`, `validators/validate-run.py` runs the **structural** Stage Map validator (`validators/validate-implementation-plan-stages.py`) at the planning boundary — not deferred to the `implementation` entry gate. It enforces: the exact `## 5.5 Stage Map` heading, each `## 5.5.<i> Stage <i>:` section with its four required subsections, the per-stage effective step count (≤8), the `depends-on` DAG, and the per-stage vertical-slice contract (S10). S10 scans for the literal in-section strings `Slice value:`, `Acceptance:`, the three `Test case (success):` / `Test case (boundary):` / `Test case (failure):` lines (S10d), and the Stepwise `action`-cell prefixes `RED:` / `GREEN:` (or a `TDD exemption:` line, which waives both the test-case lines and the RED/GREEN check) — keep these tokens verbatim for the same reason as the heading keywords above.
 - Required deliverable shape (final report, in addition to the standard sections):
   - at least two implementation options. **Each option must include**:
-    - **File Structure**: an explicit list of files to create / modify / delete with each file's responsibility (one-line each). Use the form `Create: path — responsibility` / `Modify: path:line-range — change summary` / `Delete: path — reason`.
+    - **File Structure**: an explicit list of files to create / modify / delete with each file's responsibility (one-line each). Use the form `Create: path — responsibility` / `Modify: path:line-range — change summary` / `Delete: path — reason`. Write every `path` in full and `<PROJECT_ROOT>`-relative — never ellipsis-abbreviated (`…` / `...` / a trailing `/…`); an abbreviated path does not resolve and is rejected by plan-body verification as a kind-b path mismatch.
     - affected interfaces / public contracts and downstream consumers
     - estimated blast radius (units, configs, deployment manifests, data migrations)
   - trade-off matrix across options (rows = options, columns at minimum: complexity, risk, reversibility, test coverage cost, rollout cost)
@@ -81,7 +81,7 @@
       Validator S10d rejects a missing/empty line in any of the three categories (skipped only when a `TDD exemption:` line is present). The `RED:` step below must encode these cases, not a single assertion.
   - **Per-stage subsections** (`## 5.5.<i> Stage <i>: <title>` for each `i`), each containing the four required subsections:
     - `### Carry-In` — for `depends-on (none)`: task-brief only. Otherwise: each depended-on stage's static exit contract + runtime sidecar path `runs/<impl-key>/carry/stage-<i>.json` placeholder.
-    - `### Stepwise Execution Order` — bite-sized table with `step | action | files | command | expected`. **Effective row count ≤ 8** (excluding header / divider / blank). Each step is one cohesive, self-contained change (시간 하한 없음; 함께 바뀌는 여러 파일을 포함할 수 있다); for code steps include actual code or diff sketch. **TDD ordering is MUST, not a preference:** the **first** effective step's `action` cell MUST start with the literal `RED:` and describe the failing test(s) that capture this stage's `Acceptance` **and the three declared `Test case (success|boundary|failure)` lines** (`expected` = FAIL) — the RED step encodes the case set, not a single happy-path assertion; at least one later `action` cell MUST start with the literal `GREEN:` and describe the minimal implementation that makes it pass (`expected` = PASS); an optional refactor step starts with `REFACTOR:`. **Exemption:** doc-only / config-only / pure-rename stages with no observable runtime behaviour may omit RED/GREEN by declaring one line `TDD exemption: <reason>` in the stage section (mirrors the executor's per-step exemption in `_implementation-executor.md`). Validator S10c enforces RED-first + GREEN **and** that the `RED:` step's `expected` reads FAIL / the `GREEN:` step's reads PASS; S10e rejects a `TDD exemption:` whose reason is not one of doc-only / config-only / pure-rename (both in `validators/validate-implementation-plan-stages.py`).
+    - `### Stepwise Execution Order` — bite-sized table with `step | action | files | command | expected`. The `files` cell lists each touched path in full and `<PROJECT_ROOT>`-relative — never ellipsis-abbreviated (`…` / `...`), which does not resolve and is rejected by plan-body verification as a kind-b path mismatch. **Effective row count ≤ 8** (excluding header / divider / blank). Each step is one cohesive, self-contained change (시간 하한 없음; 함께 바뀌는 여러 파일을 포함할 수 있다); for code steps include actual code or diff sketch. **TDD ordering is MUST, not a preference:** the **first** effective step's `action` cell MUST start with the literal `RED:` and describe the failing test(s) that capture this stage's `Acceptance` **and the three declared `Test case (success|boundary|failure)` lines** (`expected` = FAIL) — the RED step encodes the case set, not a single happy-path assertion; at least one later `action` cell MUST start with the literal `GREEN:` and describe the minimal implementation that makes it pass (`expected` = PASS); an optional refactor step starts with `REFACTOR:`. **Exemption:** doc-only / config-only / pure-rename stages with no observable runtime behaviour may omit RED/GREEN by declaring one line `TDD exemption: <reason>` in the stage section (mirrors the executor's per-step exemption in `_implementation-executor.md`). Validator S10c enforces RED-first + GREEN **and** that the `RED:` step's `expected` reads FAIL / the `GREEN:` step's reads PASS; S10e rejects a `TDD exemption:` whose reason is not one of doc-only / config-only / pure-rename (both in `validators/validate-implementation-plan-stages.py`).
     - **Per-stage conformance declaration (mandatory one line, in the stage section — same placement freedom as `TDD exemption:`):** the stage MUST carry exactly one of:
       - `Conformance tests: stage-<N> — <task_root>/qa/scripts/stage-<N>.<ext> (requires=[db|io|http|external,...])` — a Tier3 verification script that proves this stage's upstream requirements (brief / requirements-discovery / error-analysis / improvement-discovery → this stage's `Acceptance`) hold against **real** DB rows, real endpoints, or the real external API — NOT mocks. When you emit this line you MUST also (a) write the script to `<task_root>/qa/scripts/stage-<N>.<ext>` and (b) add a matching entry to `<task_root>/qa/conformance-manifest.json` with fields `stageKey` (= `<task-id>-stage-<N>`), `script`, `runCommand`, `requirementIds`, `requires` (subset of `{db, io, http, external}`), `passContract`, `exemption: null`, `waiver: null`. The script's standard interface: a `main` that exits `0`=PASS / non-zero=FAIL, and whose stdout ends with `QA-RESULT: PASS|FAIL` followed by one `REQ <id>: PASS|FAIL: <근거>` line per requirement. When the verification body is a test spec, author it with the project's own test framework (devDependency) invoked via a discovery override at `<task_root>/qa/scripts/` (jest: `--config <project config> --roots <task_root>/qa/scripts`) — never hand-roll `describe`/`expect` and never widen the project's own test config; for TypeScript specs also write `<task_root>/qa/scripts/tsconfig.json` extending the project tsconfig with the runner's `types` entry so editors resolve the file.
       - `Conformance exemption: <reason>` — only for stages that touch no db/io/http/external surface, or where unit tests fully cover the increment. (If the eventual `implementation` diff actually touches one of those surfaces, `validate-run.py`'s diff-surface cross-check is BLOCKING — an exemption cannot hide a real db/io/http/external change.)
@@ -110,7 +110,7 @@
   - the YAML frontmatter MUST include the line `implementation-option:` directly under `approved:` (report-writer always emits it with an **empty value**). The user selects which Option Candidate the next `implementation` run executes by filling this line with that option's name (manual edit or `--implementation-option <name>` CLI). When left empty, the `implementation` run falls back to the `Recommended Option`.
   - **the frontmatter `approved: false` line is rendered unconditionally; if the plan-body verification gate (§5.5.9) returns `blocked-by-disagreement` or `aborted-non-result`, the writer MUST keep `approved: false` and the validator refuses any report that ships with `approved: true` under such a gate result.**
   - every ambiguity flagged during pre-planning that the user must resolve before approval registered as a `Blocks=approval` row in the `## 1. Clarification Items` table (the unified table is the single home for these — the "no separate `Open Questions` block" rule is in the shared `_common-contract.md` clarification policy)
-  - **§5.5.9 Plan Body Verification (BLOCKING).** After report-writer finishes the draft, the lead MUST run a worker peer-review round on the consolidated plan body (Option Candidates / Trade-off Matrix / Recommended Option / Stage Map and per-stage sections / Dependency / Validation Checklist / Rollback / Requirement Coverage) and populate `### 5.5.9 Plan Body Verification` in the final report. The round protocol, plan-item ID scheme (`P-Opt-*` / `P-Step-*` / `P-Dep-*` / `P-Val-*` / `P-Rb-*`), verdict semantics, gate-result classification, and dissent log format are defined in `prompts/lead/plan-body-verification.md`. The four gate-result values are `passed`, `passed-with-dissent`, `blocked-by-disagreement`, `aborted-non-result`. When the gate would have been `blocked-by-disagreement` or `aborted-non-result`, the lead MUST NOT silently flip it to one of the passing values to "unblock" the run — that is a contract violation. **Enforced:** `validators/validate-run.py` `_validate_plan_body_gate_recompute` re-derives the gate from `planItems[].verdicts` and fails when the declared `gateResult` claims a healthier outcome than the recorded votes support; `_validate_plan_item_extraction_completeness` fails when any plan-body deliverable category is under-extracted into `planItems`, so a dropped item can no longer dodge the gate. When `convergence.adversarial=true` (the default for this phase), this round uses the adversarial posture — verifiers confirm cited paths/commands and the burden of proof is on the plan — but the gate threshold stays `majority-disagree` (see that skill's §"Adversarial plan-body posture").
+  - **§5.5.9 Plan Body Verification (BLOCKING).** After report-writer finishes the draft, the lead MUST run a worker peer-review round on the consolidated plan body (Option Candidates / Trade-off Matrix / Recommended Option / Stage Map and per-stage sections / Dependency / Validation Checklist / Rollback / Requirement Coverage) and populate `### 5.5.9 Plan Body Verification` in the final report. The round protocol, plan-item ID scheme (`P-Opt-*` / `P-Step-*` / `P-Dep-*` / `P-Val-*` / `P-Rb-*`), verdict semantics, gate-result classification, and dissent log format are defined in `prompts/lead/plan-body-verification.md`. The four gate-result values are `passed`, `passed-with-dissent`, `blocked-by-disagreement`, `aborted-non-result`. When the gate would have been `blocked-by-disagreement` or `aborted-non-result`, the lead MUST NOT silently flip it to one of the passing values to "unblock" the run — that is a contract violation. **Enforced:** `validators/validate-run.py` `_validate_plan_body_gate_recompute` re-derives the gate from `planItems[].verdicts` and fails when the declared `gateResult` claims a healthier outcome than the recorded votes support; `_validate_plan_item_extraction_completeness` fails when any plan-body deliverable category is under-extracted into `planItems`, so a dropped item can no longer dodge the gate. When `convergence.adversarial=true` (the default for this phase), this round uses the adversarial posture — verifiers confirm cited paths/commands and the burden of proof is on the plan — but the gate threshold stays `majority-disagree` (see that skill's §"Adversarial plan-body posture"). majority-disagree 항목 중 `planner-fixable` 다수는 사용자 clarification 으로 승격하기 전에 report-writer 자가수정 1회를 거친다(`prompts/lead/plan-body-verification.md` "Self-fix round"). self-fix 로 해소되지 않았거나 `needs-user-input` 다수인 항목만 `Blocks=approval` clarification 이 된다. `validators/validate-run.py` `_validate_self_fix_before_clarification` 가 self-fix 없이 승격된 planner-fixable 다수 항목을 `contract-violated` 로 실패시킨다.
   - **Decision-record evaluation (sole owner)**: this phase is the **single owner** of decision-record evaluation in the okstra lifecycle. The brief never evaluates or drafts decision records — it only forwards `adr-candidate:*` signals. Every `adr-candidate:*` entry inherited from the brief's `Open Questions` is a mandatory evaluation target. In addition, evaluate every decision the recommended option introduces against the three criteria:
     1. **Hard to reverse** — would changing the decision later cost meaningfully more than deciding now?
     2. **Surprising without context** — would a future reader, seeing only the code, wonder "why was it built this way?"?

package/runtime/prompts/profiles/requirements-discovery.md

@@ -42,7 +42,7 @@
     각 단위를 새 task-key 로 시작한다(이 phase 는 다운스트림 run 을 직접 시작하지 않는다).
 - Decision-tree walk (bounded):
   - When the brief's `Desired Outcome`, classification, or routing target depends on a chain of decisions, walk that chain one branch at a time. Each branch is one `Clarification Items` row, not a free-form interview.
-  - For every clarification row, put the single best answer and one-line rationale in `Expected form` as `Recommended: ...`. Put other options and one-sentence consequences in the same cell as `Alternatives: ...`.
+  - For every clarification row, put the single best answer and one-line rationale in `Expected form` as `Recommended: (a) ...`. Put other options and one-sentence consequences in the same cell as `Alternatives: (b) ... (c) ...` — the recommended answer is option `(a)` and alternatives continue from `(b)`, so the labels read `(a) (b) (c) …` in order.
   - **Codebase-first rule**: if a branch can be resolved by `Read` / `Grep` / file inspection, resolve it that way and record `Evidence checked: <path:line>` in the `Statement` cell. Do NOT escalate to the user.
   - Budget: the unified `## 1. Clarification Items` table caps at the smaller of (a) one row per unresolved decision branch, (b) 8 rows total. Beyond the cap, fold remaining ambiguity into the routing recommendation's risk notes.
 - Expected output emphasis:

package/runtime/python/okstra_ctl/lead_runtime.py

@@ -14,6 +14,7 @@ class LeadRuntimeInfo:
     adapter_dispatch_mode: str
     session_accounting: str
     has_claude_session: bool
+    adapter_contract_relative_path: str
 
     def adapter_payload(self) -> dict[str, str]:
         return {
@@ -36,6 +37,7 @@ _LEAD_RUNTIMES = {
         adapter_dispatch_mode="team",
         session_accounting="claude-jsonl",
         has_claude_session=True,
+        adapter_contract_relative_path="lead/adapters/claude-code.md",
     ),
     "codex": LeadRuntimeInfo(
         runtime="codex",
@@ -46,6 +48,7 @@ _LEAD_RUNTIMES = {
         adapter_dispatch_mode="render-only",
         session_accounting="artifact-only",
         has_claude_session=False,
+        adapter_contract_relative_path="lead/adapters/codex.md",
     ),
     "external": LeadRuntimeInfo(
         runtime="external",
@@ -56,6 +59,7 @@ _LEAD_RUNTIMES = {
         adapter_dispatch_mode="render-only",
         session_accounting="artifact-only",
         has_claude_session=False,
+        adapter_contract_relative_path="lead/adapters/external.md",
     ),
 }
 

package/runtime/python/okstra_ctl/models.py

@@ -59,7 +59,7 @@ PROVIDER_MAPPINGS = {"claude": CLAUDE, "antigravity": ANTIGRAVITY, "codex": CODE
 # the claude provider; "report-writer" is role-only (None → caller uses lead's).
 ROLE_DEFAULTS = {
     "lead": "opus", "claude": "opus", "codex": "gpt-5.6",
-    "antigravity": "auto", "report-writer": None,
+    "antigravity": "gemini-3.1-pro", "report-writer": None,
 }
 
 

package/runtime/python/okstra_ctl/render.py

@@ -1735,6 +1735,9 @@ def inject_lead_prompt_computed_tokens(ctx: dict) -> None:
     lead_contract_path = ctx.get("OKSTRA_LEAD_CONTRACT_PATH") or str(
         home_prompts / "lead" / "okstra-lead-contract.md"
     )
+    adapter_contract_path = ctx.get("OKSTRA_LEAD_ADAPTER_CONTRACT_PATH") or str(
+        home_prompts / _lead_info(ctx).adapter_contract_relative_path
+    )
     context_loader_path = ctx.get("OKSTRA_CONTEXT_LOADER_PATH") or str(
         home_prompts / "lead" / "context-loader.md"
     )
@@ -1756,7 +1759,10 @@ def inject_lead_prompt_computed_tokens(ctx: dict) -> None:
     okstra_runtime_resources_block = (
         "## Okstra Runtime Resources\n"
         "\n"
-        f"- Lead contract: `{lead_contract_path}`\n"
+        f"- Lifecycle core contract: `{lead_contract_path}`\n"
+        f"- Selected runtime adapter contract: `{adapter_contract_path}`\n"
+        "- Read the lifecycle core first, then the selected adapter. "
+        "Only the selected adapter may define host tool spelling.\n"
         f"- Context loader: `{context_loader_path}`\n"
         f"- Team contract: `{team_contract_path}`\n"
         f"- Convergence contract: `{convergence_path}`\n"
@@ -1822,193 +1828,97 @@ def inject_lead_prompt_computed_tokens(ctx: dict) -> None:
         else "- `Antigravity worker` is not selected for this run, so no Antigravity attempt is required."
     )
 
-    # Teammate dispatch gate block: phase-conditional. CC v2.1.178 removed
-    # TeamCreate/TeamDelete + the Agent team_name param; every session owns one
-    # implicit team, so workers dispatch with Agent(name: ...) and no team_name.
-    # - release-handoff (and any other phase that renders with no workers
-    #   selected) is single-lead and dispatches no teammate at all. Emit a
-    #   short notice instead of the BLOCKING gate.
-    # - concurrent implementation runs only record an audit marker (each session
-    #   has its own implicit team, so there is no shared-team conflict).
-    # - All other phases keep the full teammate-dispatch contract.
     task_type = ctx.get("TASK_TYPE", "")
-    concurrent_stages = str(ctx.get("CONCURRENT_RUN_STAGES", "") or "").strip()
-    codex_dispatch_command = (
-        "okstra codex-dispatch "
-        f"--project-root {ctx.get('PROJECT_ROOT', '')} "
-        f"--run-manifest {ctx.get('RUN_MANIFEST_RELATIVE_PATH', '')}"
-    )
-    team_dispatch_command = (
-        "okstra team dispatch "
-        f"--project-root {ctx.get('PROJECT_ROOT', '')} "
-        f"--run-manifest {ctx.get('RUN_MANIFEST_RELATIVE_PATH', '')}"
-    )
-    team_await_command = (
-        "okstra team await "
-        f"--project-root {ctx.get('PROJECT_ROOT', '')} "
-        f"--run-manifest {ctx.get('RUN_MANIFEST_RELATIVE_PATH', '')}"
-    )
-    if task_type == "release-handoff" or not selected:
-        team_creation_gate_block = (
-            "## Single-Lead Phase (no team creation)\n"
-            "\n"
-            "This run is single-lead. There is no worker roster, no\n"
-            "`TeamCreate` call, no `Agent(...)` worker dispatch, and no\n"
-            f"convergence loop. The {lead_role} performs every step inline\n"
-            "(reading inputs, drafting commit / PR text when applicable,\n"
-            "asking the user, running git / gh, and writing the final\n"
-            "report). Do NOT call `TeamCreate` or dispatch any sub-agent\n"
-            "from this run — that would be a contract violation."
-        )
-    elif lead_runtime == "codex":
-        team_creation_gate_block = (
-            "## Codex Dispatch Gate (BLOCKING)\n"
-            "\n"
-            "This run was prepared for `leadRuntime=codex`. Do NOT call\n"
-            "`TeamCreate`, do NOT call Claude Code `Agent(...)`, and do NOT\n"
-            "invoke Claude slash skills. Codex dispatch is artifact-first and\n"
-            "uses the prepared run manifest plus CLI-backed worker wrappers.\n"
-            "\n"
-            "Required actions, in order:\n"
-            "\n"
-            "1. Inspect the run manifest and team-state paths listed below.\n"
-            "2. Emit `PROGRESS: phase-3-team-create skipped (codex-dispatch)`;\n"
-            "   there is no Claude Teams surface in this adapter.\n"
-            "3. Plan worker execution with:\n"
-            f"   `{codex_dispatch_command} --dry-run`\n"
-            "4. Dispatch supported Codex-side workers with:\n"
-            f"   `{codex_dispatch_command}`\n"
-            "   When `--workers` is omitted, unsupported roster entries such as\n"
-            "   `claude` are skipped with explicit `not-run` reasons.\n"
-            "5. Run `report-writer` only with explicit opt-in:\n"
-            f"   `{codex_dispatch_command} --enable-codex-report-writer --report-writer-codex-model <model>`\n"
-            "\n"
-            "`okstra codex-dispatch` records `team-state.dispatchMode`, writes\n"
-            "worker prompt histories when missing, persists worker results, and\n"
-            "runs post-report validation for the Codex report-writer path."
-        )
-    elif lead_runtime == "external":
-        team_creation_gate_block = (
-            "## Tmux Worker Dispatch Gate (BLOCKING)\n"
-            "\n"
-            "This run was prepared for `leadRuntime=external`. Do NOT call "
-            "`TeamCreate`, do NOT call Claude Code `Agent(...)`, and do NOT call "
-            "`okstra codex-dispatch`. This adapter dispatches workers through "
-            "okstra-owned tmux panes.\n"
-            "\n"
-            "Required actions, in order:\n"
-            "1. Inspect the run manifest and team-state paths listed below.\n"
-            "2. Emit `PROGRESS: phase-3-team-create skipped (tmux-pane)`; there is no Claude Teams surface in this adapter.\n"
-            "3. Plan worker execution with:\n"
-            f"   `{team_dispatch_command} --dry-run`\n"
-            "4. Dispatch workers with:\n"
-            f"   `{team_dispatch_command}`\n"
-            "5. Arm one background wait using this harness's async shell primitive:\n"
-            f"   `{team_await_command}`\n"
-            "6. On wake, read team-state. Worker completion is valid only from "
-            "`workerDispatches[]` plus result files; pane creation alone is not completion."
-        )
-    elif task_type == "implementation" and concurrent_stages:
-        team_creation_gate_block = (
-            "## Concurrent-run marker (BLOCKING)\n"
-            "\n"
-            "A concurrent implementation run of the same task-key holds stage(s)\n"
-            f"`{concurrent_stages}` right now. Each session owns its own implicit\n"
-            "team (`session-<leadSessionId-prefix>`), so concurrent same-task runs do\n"
-            "not share team state — this run dispatches normally and only records the\n"
-            "concurrent context for the audit trail.\n"
-            "\n"
-            "Required actions, in order:\n"
-            "\n"
-            "1. Before any dispatch, record in team-state:\n"
-            '   `teamCreate: { attempted: false, status: "skipped",'
-            f' reason: "concurrent-run", concurrentStages: [{concurrent_stages}] }}`.\n'
-            "2. Immediately after recording it, emit the checkpoint line\n"
-            "   `PROGRESS: phase-3-team-create skipped (concurrent-run)` — the\n"
-            "   phase-3 checkpoint is required and the session-conformance validator\n"
-            "   fails the run without it.\n"
-            "3. Dispatch every worker with `Agent(name: ..., run_in_background: true)`\n"
-            "   and NO `team_name`; teammates join this session's implicit team and\n"
-            "   render as split-panes when `$TMUX` is set."
-        )
-    else:
+    adapter_setup_facts: list[str] = []
+    if lead_runtime == "claude-code":
         base_name = f'okstra-{ctx.get("TASK_KEY", "")}'
         impl_stage = str(ctx.get("EFFECTIVE_STAGES", "") or "").strip()
         fv_stage = str(ctx.get("RUN_STAGE", "") or "").strip()
         stage_suffix = ""
         if task_type == "implementation" and impl_stage:
-            # stage 격리 run 은 stage 별 team — 같은 task 의 다른 stage 가 남긴
-            # team 과 이름이 충돌하지 않는다(worktree branch `-s<N>` 접미사와 동형).
             stage_suffix = f"-s{impl_stage}"
         elif task_type == "final-verification" and fv_stage:
-            # 단일-stage final-verification 도 stage 별 team. `-fv-` 를 끼워
-            # 같은 stage 의 implementation team(`-s<N>`)과도 구분한다 — 둘은
-            # 동시에 살아 있을 수 있다. whole-task 검증(RUN_STAGE 빈 값)은
-            # 기본 이름 유지.
             stage_suffix = f"-fv-s{fv_stage}"
-        team_name = sanitize_team_name(base_name, stage_suffix)
+        adapter_setup_facts.append(
+            f"- Adapter audit label: `{sanitize_team_name(base_name, stage_suffix)}`"
+        )
+    concurrent_stages = str(ctx.get("CONCURRENT_RUN_STAGES", "") or "").strip()
+    if concurrent_stages:
+        adapter_setup_facts.append(
+            f"- Prepare-recorded concurrent stages: `{concurrent_stages}`"
+        )
+    adapter_setup_block = (
+        "\n".join(adapter_setup_facts)
+        if adapter_setup_facts
+        else "- Adapter setup facts: none"
+    )
+
+    if task_type == "release-handoff" or not selected:
         team_creation_gate_block = (
-            "## Teammate Dispatch Gate (BLOCKING)\n"
-            "\n"
-            "Before any `Agent` dispatch for workers, you MUST perform Phase 3 of the\n"
-            f'okstra lead contract (`{lead_contract_path}` → "Phase 3 — Teammate setup").\n'
+            "## Single-Lead Phase (no worker dispatch)\n"
             "\n"
-            "Claude Code v2.1.178 removed the `TeamCreate` / `TeamDelete` tools and the\n"
-            "`Agent(...)` `team_name` parameter. With `CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS=1`\n"
-            "(seeded by `okstra install`) this session already owns one implicit team;\n"
-            "workers spawned with `Agent(name: ...)` auto-join it. Do NOT probe or call\n"
-            "`TeamCreate` — its absence is the normal state on every current Claude Code,\n"
-            "not an 'Agent Teams unavailable' signal, and never a reason to degrade the run.\n"
-            "\n"
-            "Required actions, in order, regardless of how many workers are selected\n"
-            "for this run (roster comes from `resultContract.requiredWorkerRoles` in\n"
-            "`task-manifest.json` — it may be 1, 2, 3, or more workers):\n"
+            "This run has no worker roster or convergence loop. The lead performs "
+            "the phase inline and follows the selected adapter only for user prompts, "
+            "artifact operations, usage collection, and cleanup."
+        )
+    else:
+        team_creation_gate_block = (
+            "## Runtime Adapter Dispatch Gate (BLOCKING)\n"
             "\n"
-            f"1. Read the team-contract resource (`{team_contract_path}`) and verify the selected worker\n"
-            "   roster against `task-manifest.json`'s `resultContract.requiredWorkerRoles`.\n"
-            "2. Record team-state BEFORE any dispatch:\n"
-            f'   `teamName: "{team_name}"` (audit/display label only) AND\n'
-            '   `teamCreate: { attempted: false, status: "implicit",'
-            " splitPane: <true if $TMUX set, else false> }`.\n"
-            '3. Dispatch every worker with `Agent(name: "<role>-worker",'
-            " run_in_background: true)` and NO `team_name`. Split-pane teammates appear\n"
-            "   automatically when `$TMUX` is set (`teammateMode: auto`); when it is\n"
-            "   unset they run in-process — both are normal, not a degraded run."
+            f"- Selected lead runtime: `{lead_runtime}`\n"
+            f"- Selected adapter contract: `{adapter_contract_path}`\n"
+            "- Read that adapter before Phase 3. Execute `prompt_user`, "
+            "`dispatch_worker`, `await_workers`, `redispatch_worker`, "
+            "`shutdown_workers`, `record_lead_event`, and `collect_usage` only "
+            "through its mapping.\n"
+            "- Do not call a primitive documented by an unselected adapter.\n"
+            "- Record the adapter-required Phase 3 state and emit the canonical "
+            "`PROGRESS: phase-3-team-create ...` checkpoint before dispatch.\n"
+            f"{adapter_setup_block}\n"
+            "- The run manifest is authoritative for concurrent-run metadata, "
+            "dispatch backend, and artifact paths."
         )
 
+    lead_intro_line = f"You are `{lead_role}` for project `{ctx.get('PROJECT_ID', '')}`."
+    lead_bootstrap_instruction = (
+        f"Read the Lifecycle core contract at `{lead_contract_path}`, then read the "
+        f"selected runtime adapter at `{adapter_contract_path}`. Read the manifests "
+        "below for all task metadata, paths, model assignments, and worker roster. "
+        "Execute `write_artifact`, `dispatch_worker`, and `await_workers` only through "
+        "the selected adapter's mapping. Follow the lifecycle core's lazy-read rules "
+        "for support resources; do not invoke hidden/internal skills."
+    )
+    worker_preamble_path = ctx.get(
+        "WORKER_PROMPT_PREAMBLE_PATH",
+        str(okstra_home() / "templates" / "worker-prompt-preamble.md"),
+    )
+    worker_dispatch_guidance = (
+        "## Worker Dispatch Contract\n"
+        "\n"
+        "- Worker prompt paths in `task-manifest.json` are assigned prompt-history "
+        "locations, not pre-rendered completion markers. An absent file means its "
+        "dispatch history has not been materialized yet.\n"
+        "- Construct each required worker prompt and follow the lifecycle core plus "
+        "selected adapter to persist its assigned history through `write_artifact` "
+        "and start it through `dispatch_worker`. Existing-history handling must stay "
+        "idempotent under those contracts.\n"
+        "- Use `await_workers` through the selected adapter and confirm terminal state "
+        "plus every required Result Path. File presence alone is never a signal to "
+        "skip; worker selection and skipped status come from `team-state`.\n"
+        "- Every worker prompt must include the anchor header "
+        f"`**Worker Preamble Path:** {worker_preamble_path}`. That file is the canonical "
+        "source for Required Reading, Error Reporting, and Output sections; do not "
+        "re-inline those blocks into worker prompt bodies."
+    )
+
     if lead_runtime == "external":
-        lead_intro_line = f"You are `{lead_role}` for project `{ctx.get('PROJECT_ID', '')}`."
-        lead_bootstrap_instruction = (
-            "Read the manifests below for all task metadata, paths, model "
-            "assignments, and worker roster. Use the tmux worker dispatch gate "
-            "in this prompt; do not invoke Claude Code skills."
-        )
         lead_session_block = (
             "## Session\n"
             "\n"
             "- Lead runtime: `external`\n"
             "- Lead session accounting: artifact-only; this harness does not expose Claude Code jsonl session IDs."
         )
-        worker_dispatch_guidance = (
-            "## Tmux Worker Dispatch\n"
-            "\n"
-            "- Worker prompt paths in `task-manifest.json` are assigned history "
-            "locations. `okstra team dispatch` materializes missing prompt files "
-            "from the run manifest and active-run-context; existing prompt files "
-            "are never overwritten.\n"
-            "- Do not call `TeamCreate`, `Agent(...)`, or `okstra codex-dispatch`. "
-            "Use `okstra team dispatch` and `okstra team await` from the gate "
-            "above for worker execution.\n"
-            "- File presence is not a signal to skip. Worker selection and skipped "
-            "statuses come from `team-state`, never from the prompts directory."
-        )
     elif lead_runtime == "codex":
-        lead_intro_line = f"You are `{lead_role}` for project `{ctx.get('PROJECT_ID', '')}`."
-        lead_bootstrap_instruction = (
-            "Read the manifests below for all task metadata, paths, model "
-            "assignments, and worker roster. Use the Codex dispatch gate in this "
-            "prompt; do not invoke Claude Code skills."
-        )
         lead_session_block = (
             "## Session\n"
             "\n"
@@ -2016,41 +1926,13 @@ def inject_lead_prompt_computed_tokens(ctx: dict) -> None:
             "- Codex run resume is artifact/checkpoint based; `okstra codex-run` "
             "does not create a Claude session id."
         )
-        worker_dispatch_guidance = (
-            "## Codex Worker Dispatch\n"
-            "\n"
-            "- Worker prompt paths in `task-manifest.json` are assigned history "
-            "locations. `okstra codex-dispatch` materializes missing prompt files "
-            "from the run manifest and active-run-context; existing prompt files "
-            "are never overwritten.\n"
-            "- Do not call `TeamCreate` or `Agent(...)`. Use the command in the "
-            "Codex Dispatch Gate above for worker execution.\n"
-            "- File presence is not a signal to skip. Worker selection and skipped "
-            "statuses come from `team-state`, never from the prompts directory."
-        )
     else:
-        lead_intro_line = f"You are `{lead_role}` for project `{ctx.get('PROJECT_ID', '')}`."
-        lead_bootstrap_instruction = (
-            f"Read the Okstra lead contract at `{lead_contract_path}` now, then read "
-            "the manifests below for all task metadata, paths, model assignments, and "
-            "worker roster. Follow the contract's lazy-read rules for support resources; "
-            "do not invoke hidden/internal skills."
-        )
         lead_session_block = (
             "## Session\n"
             "\n"
             f"- Session ID: `{ctx.get('CLAUDE_SESSION_ID', '')}`\n"
             f"- Resume: `{ctx.get('CLAUDE_RESUME_COMMAND_RELATIVE_PATH', '')}`"
         )
-        worker_dispatch_guidance = (
-            "## Worker Prompt Files (not pre-rendered)\n"
-            "\n"
-            "- The `runs/<phase>/prompts/<worker>-worker-prompt-*.md` files referenced in `task-manifest.json → artifacts.workerPromptPathByWorkerId` are **NOT** rendered by the okstra runtime. Those paths are the *assigned* locations where the prompt history MUST be written at dispatch time.\n"
-            "- Therefore: at the start of every phase the prompts/ directory is normally empty (or contains only previously-dispatched workers' files). This is expected. Do NOT narrate it as \"missing\", \"누락\", or \"not yet rendered\" — it just means dispatch has not happened yet.\n"
-            "- Before dispatching any required worker, **you (the lead) construct the worker prompt and persist it to the assigned absolute path using `Write`** (per `team-contract` rule 6). Only after persisting do you call the worker subagent (Agent tool / Codex / Antigravity wrapper). The wrapper subagents will also re-write the same file on their end; the double-write is intentional and idempotent.\n"
-            "- Do not \"check if the file exists and skip dispatch\" — file presence is not a signal to skip. Worker selection and skipping rules come from team-state, never from prompts/ directory contents.\n"
-            f"- **Worker Preamble Path (single anchor — replaces inlined `[Required reading]` and `[Error reporting]` blocks).** Every worker prompt you construct MUST include the anchor header `**Worker Preamble Path:** {ctx.get('WORKER_PROMPT_PREAMBLE_PATH', str(okstra_home() / 'templates' / 'worker-prompt-preamble.md'))}`. The file at that path is the canonical SSOT for Required Reading + Error Reporting + Output sections; workers Read it end-to-end before producing output. Do NOT re-inline those blocks into worker prompt bodies — that is the legacy ~80-line dispatch boilerplate that this anchor is designed to replace."
-        )
 
     # Compute results (deterministic from ctx, 덮어쓰기)
     ctx["LEAD_INTRO_LINE"] = lead_intro_line

package/runtime/python/okstra_ctl/report_views.py

@@ -597,24 +597,32 @@ _ENUM_CUE_WORDS: tuple[str, ...] = (
 
 def _parse_enum_options(statement: str) -> list[tuple[str, str]]:
     """Return ``[(letter, text)]`` pairs if ``statement`` looks like a
-    ``(a) X (b) Y (c) Z`` enumeration, else ``[]``. Stops at the first
-    recommendation cue (``권장``/``추천``/``사유``/``근거``) so the
+    ``(a) X (b) Y (c) Z`` enumeration, else ``[]``. The sequence may start
+    at any letter — a statement enum starts at ``(a)``, while the
+    ``Alternatives`` cell of the Expected-form contract starts at ``(b)``
+    (the recommended answer is ``(a)``) — so parsing keys off the first
+    ``(letter)`` marker found and walks the sequence from there. Stops at
+    the first recommendation cue (``권장``/``추천``/``사유``/``근거``) so the
     "(c) — recommended because ..." tail doesn't leak into the last
     option's text. Requires ≥ 2 options to trigger select rendering.
     """
     if not statement:
         return []
+    first = re.search(r"\(([a-z])\) ", statement)
+    if not first:
+        return []
+    letters = [chr(c) for c in range(ord(first.group(1)), ord("z") + 1)]
     out: list[tuple[str, str]] = []
     cursor = 0
-    for i, letter in enumerate(_ENUM_LETTERS):
+    for i, letter in enumerate(letters):
         anchor = f"({letter}) "
         idx = statement.find(anchor, cursor)
         if idx < 0:
             break
         start = idx + len(anchor)
         end_candidates: list[int] = []
-        if i + 1 < len(_ENUM_LETTERS):
-            n_idx = statement.find(f"({_ENUM_LETTERS[i + 1]}) ", start)
+        if i + 1 < len(letters):
+            n_idx = statement.find(f"({letters[i + 1]}) ", start)
             if n_idx >= 0:
                 end_candidates.append(n_idx)
         for cue in _ENUM_CUE_WORDS:
@@ -643,6 +651,13 @@ def _lettered_option(letter: str, text: str) -> str:
     return f"({letter}) {text}"
 
 
+def _strip_leading_letter_label(text: str) -> str:
+    """Drop a leading ``(a)`` / ``(b)`` … contract label so the caller can
+    re-letter the option exactly once (the contract labels the recommended
+    answer `(a)` and alternatives from `(b)`)."""
+    return re.sub(r"^\([a-z]\)\s*", "", text)
+
+
 def _parse_expected_form_options(expected_form: str) -> list[tuple[str, str]]:
     """Parse the ``Expected form`` contract format
     (``Recommended: <answer> — <rationale>; Alternatives: <options>``,
@@ -662,7 +677,7 @@ def _parse_expected_form_options(expected_form: str) -> list[tuple[str, str]]:
         alt_body = rec_body[alt_idx + len(_ALTERNATIVES_CUE):]
         rec_body = rec_body[:alt_idx]
     # The rationale follows " — "; the option keeps only the answer part.
-    answer = rec_body.split(" — ", 1)[0].strip(" .,;—-")
+    answer = _strip_leading_letter_label(rec_body.split(" — ", 1)[0].strip(" .,;—-"))
     options: list[tuple[str, str]] = []
     next_letter_idx = 0
     if answer:
@@ -678,7 +693,7 @@ def _parse_expected_form_options(expected_form: str) -> list[tuple[str, str]]:
             options.append((letter, _lettered_option(letter, text)))
             next_letter_idx += 1
     else:
-        alt_text = alt_body.strip(" .,;—-")
+        alt_text = _strip_leading_letter_label(alt_body.strip(" .,;—-"))
         if alt_text and next_letter_idx < len(_ENUM_LETTERS):
             letter = _ENUM_LETTERS[next_letter_idx]
             options.append((letter, _lettered_option(letter, alt_text)))

package/runtime/python/okstra_ctl/team_reconcile.py

@@ -15,7 +15,9 @@ recorded pane — those are left for graceful shutdown.
 CC v2.1.178 removed ``TeamDelete``: the implicit team ends with the session and
 run-end teardown only dismisses teammates via ``shutdown_request``. Reconcile
 keeps the roster honest so a dismissed-but-dead member does not linger as a
-live pill — see okstra-lead-contract.md "Run-scoped pane & teammate lifecycle".
+live pill — see okstra-lead-contract.md "Run-scoped worker-resource lifecycle"
+for neutral cleanup ownership and the selected Claude adapter's
+"Run-scoped resource lifecycle" for this provider-specific reconciliation.
 
 Roster resolution (``--project-root``) exists because ``team-state.lead.sessionId``
 is a phase-3 snapshot: Claude Code re-issues the session id across resume /

package/runtime/schemas/final-report-v1.0.schema.json

@@ -1508,6 +1508,7 @@
             "aborted-non-result"
           ]
         },
+        "selfFixRoundApplied": { "type": "boolean" },
         "planItems": {
           "type": "array",
           "items": {
@@ -1525,6 +1526,7 @@
                   { "type": "string", "pattern": "^C-\\d{3,}$" }
                 ]
               },
+              "selfFixNote": { "type": "string" },
               "verdicts": {
                 "type": "array",
                 "items": {
@@ -1537,6 +1539,7 @@
                       "enum": ["AGREE", "DISAGREE", "SUPPLEMENT", "verification-error"]
                     },
                     "breakageKind": { "type": "string" },
+                    "fixability": { "enum": ["planner-fixable", "needs-user-input"] },
                     "note": { "type": "string" }
                   }
                 }