okstra 0.189.4 → 0.190.0

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

@@ -14,6 +14,8 @@ until Phase 5 ends, then drop from active context for Phase 6/7.
   - **How to set the working directory**: every command and native edit MUST target `{{EXECUTOR_WORKTREE_PATH}}`, never the lead session's original project directory. The selected runtime adapter owns the exact native command syntax. Provider CLI wrappers inject the worktree at the CLI layer. For tools that accept an explicit working-directory flag (`git -C <path>`, `cargo --manifest-path`, `pytest --rootdir`), prefer that form.
 - **Synced okstra state directory.** At provision time Okstra may symlink `.project-docs/` from the repo's **main worktree** into the task worktree. This is NOT an independent copy — writes through it land in the main worktree. Inside this run the executor MUST confine okstra artifact writes to its own task scope (i.e. `.okstra/tasks/<this-task-id>/...`). Other synced directories, if present due to local configuration, are not implicit okstra context; read them only when the brief explicitly cites them as source material.
 
+**Enforced:** the worktree path reaches this worker as the `**Worktree:**` anchor (`scripts/okstra_ctl/worker_prompt_policy.py` `IMPLEMENTATION_HEADERS`), the CLI wrapper is started with that path as cwd by `scripts/okstra_ctl/dispatch_core.py`, and `scripts/okstra_ctl/execution_mutation_audit.py` `_source_changes` reports a mutation that landed outside the attempt's `writePolicy` roots.
+
 ## Pre-implementation context exploration (executor before first edit)
 
 - **Three BLOCKING gates bind this run, and their bodies travel with this prompt** — inlined under their own headings, or named by path under `## Required prompt resources`. Follow the delivered body verbatim; a gate re-typed from memory is a skipped gate. Each gate's own body owns its rule list, so nothing here restates it:
@@ -27,11 +29,13 @@ Gate delivery (lead / maintainer — stripped before this body reaches a worker)
 persisted executor prompt in that order under EAGER_INCLUDE, and lists their
 paths under `## Required prompt resources` under LAZY_PATH_REFERENCE; a CLI
 executor cannot read the profiles directory, so the file reference alone never
-reaches it. Enforcement: the CLI wrapper refuses an Executor dispatch whose
-persisted prompt lacks the heading `Coding-conventions preflight`
-(`<SENTINEL_PREFIX>_PREFLIGHT_MISSING`) or either post-write heading
-(`<SENTINEL_PREFIX>_POSTWRITE_GATE_MISSING`) — see
-`prepare_agent_invocation()` before `worker-dispatch`.
+reaches it. Enforcement: `_required_resource_path_candidates` names the three
+bodies for the `implementation-executor` audience, so composing the prompt is
+what puts them there — there is no separate dispatch-time heading check, and a
+missing heading means the composer did not run, not that a worker dropped it.
+The `<SENTINEL_PREFIX>_PREFLIGHT_MISSING` /
+`<SENTINEL_PREFIX>_POSTWRITE_GATE_MISSING` sentinels were the CLI-wrapper
+template's check; that template is gone.
 -->
 - **Stage discipline (when a preceding stage is `done`):** its code is behavior-frozen — you may call, extend, or compose with it, never change what it already does. The rule body travels with this prompt the same way the gates do (`prompts/profiles/_stage-discipline.md`); only its `implementation` bullet binds you, the `implementation-planning` one binds the planner. Declaration-level — no wrapper sentinel.
 - **Non-interactive auto-execution (BLOCKING for `runner=cli-wrapper`).** A CLI-wrapper executor runs head-less — there is no human at the keyboard. Skills loaded during the run (tdd, coding-preflight, and others) contain "get user approval", "state your plan to the user and wait", or "ask before proceeding" gates written for interactive sessions; in this run those gates are **already satisfied** by the upstream `implementation-planning` approval (the plan this stage executes was human-approved). The executor MUST NOT stop to request approval, MUST NOT end its turn after only producing a plan, and MUST carry the stage through end-to-end — RED → GREEN → refactor → per-cycle commit → `### Stage Carry Evidence`. The ONLY skill step to skip is the interactive user-approval prompt itself; every other skill rule (TDD discipline, conventions, real-IO isolation) still binds. Stopping early for approval in a head-less run is the observed empty-exit failure (exit 0, no diff): treat it as `contract-violated`.

package/runtime/prompts/profiles/_implementation-self-check.md

@@ -26,3 +26,5 @@ fails, fix it or surface the violation — do not claim done on a failing item.
 
 Close with a `Self-check coverage:` line naming the files you verified the
 per-file items against, so the Coverage footer above and this gate reconcile.
+
+**Enforced:** `scripts/okstra_ctl/initial_prompt_materialization.py` `_required_resource_path_candidates` names this body for the `implementation-executor` audience, so it is appended to every executor prompt rather than left to a file reference the CLI executor cannot open; `agents/workers/claude-worker.md` carries the same obligation for the in-process worker, which has no wrapper in front of it.

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

@@ -212,10 +212,7 @@ the command re-run does not:
   the fix diff also forces `FAIL`. Files untouched since `<prev-head>` are
   out of static-sweep scope — they already passed the previous full sweep.
 
-Enforcement: the carried-finding re-check lands in the verifier result file
-(Phase 5.5 convergence consumes it); a fix-run verifier result that cites no
-carried findings is a contract violation the lead records via
-`okstra error-log append-observed --error-type contract-violation`.
+**Enforced:** the fix run's carried findings come from the open cycle's ledger — `scripts/okstra_ctl/fix_cycles.py` `open_cycle` / `packet_summary` put them in this run's packet, so the verifier is given the set it must re-check rather than recalling it. The re-check itself lands in the verifier result file that Phase 5.5 convergence consumes; a fix-run verifier result citing no carried finding is a contract violation the lead records via `okstra error-log append-observed --error-type contract-violation`.
 
 ### DB / IO / SQL change — real-execution gate (mock-only acceptance forbidden)
 
@@ -233,6 +230,8 @@ A mocked unit test cannot observe the SQL a query builder actually emits — `co
 
 If every verifier present in the resolved roster ends with a non-result terminal status (`timeout`, `error`, `not-run`) — i.e. zero independent verdicts were produced — the run MUST end with status `blocked` and route to a follow-up `error-analysis` run. The Okstra lead MUST NOT substitute its own verdict in place of the missing verifier outputs; synthesis requires at least one independent verifier's verdict. If one or more verifiers fail but at least one returns a verdict, the run proceeds with the surviving verdict(s) and the final report MUST explicitly notate which verifiers were unavailable, with the captured error / timeout evidence per failed verifier. Record such a verifier's `verifierResults[].verdict` as `not-run`, never as `FAIL`: `FAIL` is a rejection of the diff and it drives two gates — it blocks a passing verdict and it opens a stage fix cycle — so spending it on a verifier that produced no verdict manufactures a defect that does not exist.
 
+**Enforced:** `validators/validate-run.py` `_validate_verifier_fail_blocks_verdict` fails a report whose `verifierResults[].verdict` is `FAIL` while `finalVerdict.verdictToken` passes, so a `FAIL` spent on a non-result cannot be quietly absorbed at synthesis; `validate_team_state` requires the terminal status and reason this policy branches on for every roster verifier.
+
 ## Verifier-specific forbidden actions (any occurrence → terminal status `contract-violated`)
 
 - running lint / formatter auto-fix modes during a verifier's re-run — `eslint --fix`, `prettier --write`, `ruff check --fix`, `rustfmt` (writes by default; verifiers MUST use `cargo fmt --check` or `rustfmt --check`), `gofmt -w`, `black .` (use `black --check`), `isort .` (use `isort --check-only`), or any equivalent rewrite mode

package/runtime/prompts/profiles/_stage-discipline.md

@@ -11,24 +11,31 @@ resolver matches it anywhere and would recurse on this file itself.
 
 ## Stage discipline — preceding stages are behavior-frozen
 
-A stage that is already `done` — a `depends-on` predecessor whose work is merged into this run's base — is **behavior-frozen**: code it added or modified keeps its existing behavior. Later stages MAY call, extend, or compose with that code, but
-MUST NOT change what it already does. This preserves the verified-stays-verified
-invariant — a completed, conformance-passed stage must not silently regress when
+A stage that is already `done` — a `depends-on` predecessor whose work is merged into this run's base — is **behavior-frozen**: code it added or modified keeps its existing behavior. Later stages call, extend, or compose with that code
+without changing what it already does. This preserves the verified-stays-verified
+invariant — a completed, conformance-passed stage should not silently regress when
 a later stage runs.
 
+No code compares this stage's diff against the file set a preceding stage
+touched, so this rule reaches the run as an instruction, not as a gate. What is
+checked is narrower: the verifier's rejection survives synthesis
+(`validators/validate-run.py` `_validate_verifier_fail_blocks_verdict`) and a
+mutation outside the attempt's write policy is reported
+(`scripts/okstra_ctl/execution_mutation_audit.py` `_source_changes`).
+
 - **implementation-planning** — decompose stages forward-only. No stage's scope
   may require altering an earlier stage's behavior; each stage builds additively
   on its predecessors' Stage Exit Contracts. If delivering an increment would
   force changing an earlier stage's behavior, that earlier stage was mis-scoped —
   fold the change into that stage or re-partition; do not plan a later stage that
   rewrites it.
-- **implementation** — the executor MUST NOT alter the behavior of any file added
+- **implementation** — the executor does not alter the behavior of any file added
   or modified by a preceding done stage. Touching such a file to *extend* it (a
   new branch, a new caller, an additive field) is allowed; changing its existing
   behavior is not. If a plan step appears to require a behavior change to
   prior-stage code, treat it as a planning defect. Do two things and only these: record the finding, then route
   to a new `implementation-planning` run. Never silently rewrite the prior-stage code.
   - **Report evidence (declaration-level).** When this stage modifies a file that
-    a preceding stage added or modified, the final report MUST record three facts in the deliverable's edits / Validation Evidence section: which file,
+    a preceding stage added or modified, the final report records three facts in the deliverable's edits / Validation Evidence section: which file,
     why it was touched, and how the prior stage's behavior was preserved. Absent that
     note, a reviewer treats a prior-stage edit as an unverified regression risk.

package/runtime/prompts/profiles/final-verification.md

@@ -85,7 +85,7 @@ roles:
   - **Read-only command log**: any pre-existing test/validation command touched during this run MUST be listed with its exact command line and one honest status — `executed` (ran; carries its exit code) / `advisory` (external Tier 3 did not PASS; carries observed/expected results and remains user-owned) / `env-unavailable` (should run but cannot in this environment — missing replica DB, container, or service; carries the reason, never a faked pass) / `not-configured` (no such qa-command tier) / `rejected` (a mutating/denied token — skipped, carries the denied token). A check that could not run locally is recorded as `env-unavailable` or `advisory` according to the external QA policy — never silently dropped and never reported as `executed` with an invented exit code. Mutating-command prohibition is the shared read-only boundary (see Non-goals); it is not restated per row.
   - **Could-not-verify roll-up (§5.8.9)**: the template mechanically aggregates every not-confirmed check into one scannable list — `gap` requirement-coverage rows, `advisory` / `not-configured` / `env-unavailable` / `rejected` command rows, and `blocked` manual tests. You do not hand-author it, but you MUST give those rows their honest status so nothing unverified hides across sections: a check silently recorded as `executed`/`covered` will not surface in the roll-up. This is okstra's answer to "say what could not be verified this run."
   - **Routing recommendation**: `finalVerification.routingRecommendation` is an **object** with exactly two fields — `target`, one value of the enum below, and `rationale`, the sentence tying that choice to the verdict and the blocker list. Free routing prose is not the field; a target named only in the prose does not route the task, because Phase 7 projects `workflow.nextRecommendedPhase` from `target` alone. The seven allowed targets are `release-handoff`, `release-handoff(stage-group)`, `error-analysis`, `implementation-option-selection`, `implementation-planning`, `implementation`, and `done`. Both `release-handoff` forms are allowed ONLY when the verdict is release-ready — `accepted`, or `conditional-accept` with every condition declaring `blocksReleaseHandoff: false`. Plain `release-handoff` is additionally allowed ONLY when the verification scope (the `Verification scope:` line of the injected `VERIFICATION_TARGET` block, recorded as the report's `verificationScope` field) is `whole-task`; a release-ready `single-stage` run routes to `release-handoff(stage-group)` (or `implementation` / `done`) instead. `done` ends the lifecycle here. Enforcement: `schemas/final-report-v2.0.schema.json` rejects a `target` outside the enum, a missing `rationale`, and a string in place of the object; `validators/validate-run.py` rejects a missing `target`, a verdict that is not release-ready routed to either `release-handoff` form (naming the condition ids that block it), and a `single-stage` report whose routing cites plain `release-handoff`.
-  - **Verified-row recording** (single-stage scope only): when the verdict is release-ready, the lead MUST run `okstra handoff record-verified --plan-run-root <plan-run-root> --stage <N> --report-path <final-report.md path> --data-json <final-report data.json path>` and quote the command + exit code in the report. The helper re-validates taskType/scope/verdict from data.json against the same release-gate rule, so a blocked, condition-blocked, or whole-task report is rejected at the tool layer, and the row records the token the report actually carries. **Enforced:** `validators/validate-run.py` `_validate_verified_row_recorded` requires a `verified` row in `runs/implementation-planning/consumers.jsonl` for every release-ready stage — the helper validated its own inputs but nothing checked it had ever run, leaving reports that said `accepted` while the registry said unverified, so the stage was never offered for a stage-group PR.
+  - **Verified-row recording** (single-stage scope only): when the verdict is release-ready, the lead MUST run `okstra handoff record-verified --plan-run-root <plan-run-root> --stage <N> --report-path <final-report.md path> --data-json <final-report data.json path>` and quote the command + exit code in the report. The helper checks the latest verification manifest, task/stage identity, report pointer, prepared target, and recorded implementation commit. It records the captured commit and original verdict, including conditional acceptance conditions. A missing target or mismatched commit requires re-verification. Recording happens before final validation; eligibility is granted only after that verification passes validation. **Enforced:** `okstra_ctl.handoff_verification` validates the evidence, and `validators/validate-run.py` `_validate_verified_row_recorded` requires a `verified` row matching this report, captured commit, and verdict.
 - Clarification request policy (phase-specific addendum — shared policy is in `_common-contract.md`):
   - populate `## 1. Clarification Items` only when a blocker hinges on information only the user can supply (deployment intent, intended target environment, business-rule interpretation); use `Blocks=next-phase` for items that gate continuing to release-handoff
 - Self-review pass before finalising the report (the Okstra lead runs this; do not delegate it):

package/runtime/prompts/profiles/implementation.md

@@ -72,3 +72,5 @@ The bulk of this profile's body is split into three sidecars so the lead's Phase
 | `prompts/profiles/_implementation-deliverable.md` | Start of Phase 6 (after Phase 5.5 convergence completes, before report-writer dispatch prompt construction) | Required deliverable shape, Validation / TDD evidence rules, Verifier results structure, Self-review pass, Lead post-stage persistence |
 
 **Entering Phase 5 / 6 while the relevant sidecar is not in the lead's context is BLOCKING — the phase entry is refused.** After reading a sidecar, the lead must continue into the phase's follow-up action within a single turn (i.e. the sidecar's rules take effect starting from the very turn it is read).
+
+**Enforced:** `validators/validate_session_conformance.py` `_check_entry_guard_reads` requires each sidecar's read inside the run window and before that sidecar's phase checkpoint — `_ENTRY_GUARD_READS` carries the same table, so a lead that entered the phase without loading one is named in the run's findings.

package/runtime/prompts/profiles/release-handoff.md

@@ -25,6 +25,7 @@ roles: []
   - the lead MUST capture `git status --short` and confirm the working tree is clean. Dirty state aborts the run; release-handoff packages the commits produced by `implementation`, it does not stage or commit changes.
   - the lead MUST capture `git rev-parse --abbrev-ref HEAD` and record it as the **feature branch**. If the current branch is itself `main`, `master`, `prod`, `preprod`, `staging`, or `dev`, the run MUST end immediately — release-handoff never operates on a base branch.
   - the lead MUST confirm `git log --oneline <base>..HEAD` contains at least one implementation commit. If it is empty, the run MUST end with status `blocked` and route back to `implementation`.
+  - In whole-task mode, compare `git rev-parse <handoff-branch>` with `finalVerification.sourceImplementationReport.capturedHeadSha` in the cited latest verification report, both at entry and immediately before pushing. Any mismatch stops delivery and requires final-verification again. In stage-group mode, run `okstra handoff eligible` again before pushing and confirm each selected stage is still eligible; assemble already checks the recorded verified commits. Record the compared commits and eligibility output in Executed Commands. These pre-push comparisons are lead instructions; the automated entry and assembly checks are enforced by `okstra_ctl.handoff_verification` and the handoff tests.
 - User interaction protocol (Okstra lead — performed in order, using the selected runtime adapter's interactive prompt):
   1. **Action selection** — present three choices and capture exactly one:
      - `local checkout` — bring a verified branch into the MAIN worktree for local testing (no push, no PR). Two targets: the whole-task branch (whole-task mode only), or a single stage's stack branch (`--stage N`, available in both modes since stage branches survive verification). See step 1c. When `HANDOFF_MODE` is `stage-group`, offer only the per-stage target.
@@ -33,7 +34,7 @@ roles: []
      If the user picks `skip`, route directly to the final-report self-review pass.
   1c. **Local checkout execution** (only when the user picked `local checkout`) — first ask which target — when `HANDOFF_MODE` is `whole-task`, offer both the whole-task branch and one stage's stack branch; when it is `stage-group`, offer only the per-stage target — listing the selectable stage numbers (from the approved plan's Stage Map, since the run input document carries no Stage Map). Then confirm with the user that okstra will remove the corresponding okstra worktree (when it still exists) and `git checkout <branch>` in the MAIN worktree, and that the base branch is never modified. On confirmation run:
       `okstra handoff local-checkout --project-root <project root> --project-id <id> --task-group <g> --task-id <t>` — append `--stage <N>` for the per-stage target.
-      Exit 1 means a precondition failed (MAIN worktree dirty, registry entry missing, or checkout failed): show the error verbatim and re-ask the action selection. On success the okstra worktree for that target no longer exists — if the lead's cwd was inside it, EVERY subsequent step (final-report authoring included) MUST use absolute paths or run from the MAIN worktree. Then route to the final-report self-review pass.
+      Exit 1 means a precondition failed (MAIN worktree dirty, registry entry missing, another run of this task still `in-progress`, the target branch already deleted, or checkout failed): show the error verbatim and re-ask the action selection. On success the okstra worktree for that target no longer exists — if the lead's cwd was inside it, EVERY subsequent step (final-report authoring included) MUST use absolute paths or run from the MAIN worktree. Then route to the final-report self-review pass.
   - **stage-group mode step order** (overrides the default Q1→Q3 sequence): after Q1 picks `push + PR`, run (1) base-branch selection first — identical to Q2 below, because the dependency-closure check needs `origin/<base>`; (2) G2 stage confirmation (step 1g); (3) assemble (step 2g); then Q2b and Q3 as usual, with the collector branch as the PR head.
   1g. **G2 — stage confirmation**: the stage selection already happened before the run (wizard `handoff_stage_pick`, or the CLI `--stages` flag) and is fixed in `HANDOFF_STAGES`. Display it as a one-line confirmation (`PR target stage: <csv> — proceeding`) and proceed; do NOT re-ask the multi-select. Only if `HANDOFF_MODE` is `stage-group` but `HANDOFF_STAGES` is empty (defensive, should not happen) run `okstra handoff eligible --plan-run-root <plan-run-root> --approved-plan <approved plan path>` and ask the user to pick from the eligible stages.
   2g. **assemble**: run `okstra handoff assemble --plan-run-root <...> --approved-plan <...> --project-root <project root> --project-id <id> --task-group <g> --task-id <t> --work-category <c> --stages <csv> --base <chosen-base>`. Exit 2 means a stage-vs-stage merge conflict: show the `conflicts` paths and stop (route: reshape the group or resolve manually). Exit 1 means an eligibility/closure violation: show the error verbatim and re-ask G2. On success the returned `branch` is the PR head branch for every subsequent step.
@@ -44,7 +45,7 @@ roles: []
      The chosen base MUST NOT equal the feature branch. If it does, re-ask.
   2b. **Pre-merge conflict probe** (only when the user picked `push + PR`) — before the push/PR step, the lead MUST refresh the base ref and probe for merge conflicts against it:
      - run `git fetch origin <chosen-base>` (read-only on the local working tree).
-     - run `git merge-tree --write-tree --merge-base origin/<chosen-base> HEAD origin/<chosen-base>`. A non-zero exit code OR conflict markers (`<<<<<<<`, `=======`, `>>>>>>>`) in the output indicate a merge conflict against the chosen base.
+     - run `git merge-tree --write-tree <handoff-branch> origin/<chosen-base>`. Use the verified task branch in whole-task mode or the branch returned by assemble in stage-group mode, regardless of the current directory's HEAD. Exit 0 means clean. Exit 1 with a result-tree object ID on the first stdout line means a merge conflict. A missing result tree, or any other exit code, is an execution error: stop and report it, without offering permission to proceed as if it were a content conflict. An invalid ref can also return exit 1, so the exit code alone is insufficient.
      - If no conflict is detected, proceed silently to Q3 (do NOT add a confirmation prompt — keep the happy path frictionless).
      - If a conflict IS detected, present the conflicting paths (parsed from the `merge-tree` output) and capture exactly one:
        - `proceed anyway` — continue to Q3; the PR will be opened with conflicts and the final report MUST flag this in `Merge Conflict Probe`.
@@ -64,7 +65,7 @@ roles: []
   - **Filled-body self-check (runs on the drafted body, before Q3 shows it).** "Fill in the placeholders" is only observable if someone checks that they were filled, so scan the drafted body for these and carry the result into Q3: a residual HTML comment or template marker (`<!-- … -->`, `_Describe your changes…_`, a bare `TODO` / `FIXME` the diff did not introduce), an unchecked `- [ ]` box with no inline N/A justification, a section heading whose body is empty, and a whole body short enough to carry no substance. Each hit is reported to the user with its line — never silently left in, and never auto-filled with invented content. The user remains free to accept it; the point is that they see it before choosing `use as-is`.
 - Allowed actions during the run (Okstra lead only):
   - read-only inspection: `git status`, `git status --short`, `git diff`, `git log`, `git rev-parse`, `git ls-remote --heads origin <name>`, `gh pr list --head <branch>`, `gh pr view <url>`.
-  - merge-conflict probe (only when the user picked `push + PR`): `git fetch origin <chosen-base>` and `git merge-tree --write-tree --merge-base origin/<chosen-base> HEAD origin/<chosen-base>`. Both are non-mutating with respect to the working tree.
+  - merge-conflict probe (only when the user picked `push + PR`): `git fetch origin <chosen-base>` and the exact `git merge-tree` command from step 2b. Both preserve the working tree and branch tips.
   - feature-branch push (only when the user picked `push + PR`): `git push -u origin <current-branch>`. The pushed ref MUST be the feature branch — never the chosen base branch. (stage-group mode: the collector branch returned by assemble)
   - PR creation (only when the user picked `push + PR` AND no PR with the same head already exists on origin): `gh pr create --base <chosen-base> --head <current-branch> --title "<title>" --body "<body>"`. The title and body are the user-confirmed PR draft.
   - PR reuse: if `gh pr list --head <branch> --state open --json url --jq '.[0].url'` returns a URL, treat that PR as already existing — record the URL in the final report and SKIP `gh pr create`.

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

@@ -81,6 +81,7 @@
       "echo_template": "task-type: {value}",
       "options": {
         "_RECOMMENDED_SUFFIX": " (recommended)",
+        "_BRIEF_SUFFIX": " (recommended · brief 가 지목한 진입 단계)",
         "_APPROVE_SUFFIX": " (recommended · 계획 승인 후 구현)",
         "_RERUN_SUFFIX": " (현재 phase 재실행)",
         "_BLOCKED_RERUN_SUFFIX": " (현재 phase 재실행 — 열린 명료화에 답한 뒤)",
@@ -648,7 +649,7 @@
     "worktree_not_git": "  worktree      : git 저장소 아님 — `{path}` 에서 직접 진행",
     "worktree_impl_new": "  worktree      : stage {stage} 새 worktree `{path}` (브랜치 `{branch}`, base 는 run 준비 시 해소)",
     "worktree_impl_reuse": "  worktree      : 기존 stage {stage} worktree `{path}` (브랜치 `{branch}`)",
-    "worktree_impl_auto": "  worktree      : stage 자동 선택 — `{path}` 아래 stage-<N>/ worktree 생성/재사용",
+    "worktree_impl_auto": "  worktree      : stage 자동 선택 — `{path}` 옆에 `…--stage-<N>` worktree 생성/재사용",
     "clarification_sidecars_empty": "  user-responses: 없음 — final-report 만 첨부됩니다",
     "clarification_sidecars_attached": "  user-responses: 사이드카 {files}개 · 답변 {count}개 함께 첨부 — {ids}",
     "clarification_sidecars_none_parsed": "답변으로 셀 항목 없음 (reframe 등)",

package/runtime/python/okstra_ctl/adapters/dispatch/cmux.py

@@ -15,6 +15,11 @@ from .cli_wrapper import CliWrapperDispatchPort
 
 CMUX_ADAPTER_NAME = "cmux"
 CMUX_RELAY_CONTRACT = "lead/adapters/cmux.md"
+# pane 워커는 프롬프트 파일을 그대로 읽는 CLI 프로세스라, 본문을 실어 보내는
+# 쪽과 경로만 주는 쪽 중 어느 것도 강제하지 않는다. 실려 보내는 쪽을 선언하는
+# 이유는 `lazy-path-reference` 가 명료화 답변과 fix carry 블록을 프롬프트에서
+# 통째로 빼기 때문이다 — 그 두 블록은 리소스 목록에 경로로도 실리지 않는다.
+CMUX_INITIAL_PROMPT_DELIVERY_MODE = "eager-include"
 
 
 class CmuxDispatchPort:
@@ -49,6 +54,7 @@ class CmuxDispatchPort:
             adapter_name=CMUX_ADAPTER_NAME,
             dispatch_mode="team",
             relay_contract=CMUX_RELAY_CONTRACT,
+            initial_prompt_delivery_mode=CMUX_INITIAL_PROMPT_DELIVERY_MODE,
         )
 
     def worker_write_capability(self) -> WorkerWriteCapability:

package/runtime/python/okstra_ctl/adapters/hosts/antigravity/adapter.py

@@ -32,6 +32,7 @@ DESCRIPTOR = HostDescriptor(
     session_accounting="artifact-only",
     has_claude_session=False,
     relay_contract=str(Path(__file__).with_name("relay.md").resolve()),
+    initial_prompt_delivery_mode="eager-include",
 )
 
 

package/runtime/python/okstra_ctl/adapters/hosts/antigravity/relay.md

@@ -76,12 +76,12 @@ Render every numbered item as its option label followed by its description verba
 |---|---|
 | `read_artifacts` | Read the manifest-provided paths through the current Antigravity host file interface. |
 | `write_artifact` | Write only core-authorized `.okstra/` artifacts and preserve their schemas. |
-| `prompt_user` | Ask through the current host text/question interface and stop at approval gates until an explicit answer arrives. |
+| `prompt_user` | Ask through the current host text/question interface and stop at approval gates until an explicit answer arrives. Emit the question as the last thing in that turn: assistant text emitted after the call renders below the question and separates it from the user's answer. |
 | `dispatch_worker` | Verify each materialized invocation first. Dispatch `runner=native-session` through the current host with the returned `promptPath` and `hostModelValue`. Dispatch `runner=cli-wrapper` through `okstra worker-dispatch`, which consumes `modelExecutionValue`. **Not in a cmux run:** when `terminalBackend` is `cmux-pane`, the cmux adapter overrides this row. |
 | `await_workers` | Await native host workers through the host primitive and CLI workers through their status sidecars, then verify terminal state and Result Paths. |
 | `redispatch_worker` | Materialize and verify a fresh invocation, then start a fresh native worker or deterministic `worker-dispatch` attempt according to the persisted runner. |
 | `shutdown_workers` | Perform host or process cleanup only for resources owned by this run. |
-| `record_lead_event` | Append progress and activity records to the manifest-provided `leadEventsPath`. Emit the matching `PROGRESS:` line and, when an activity record is required, the immediately following `ACTIVITY:` line from the same structured fields. |
+| `record_lead_event` | Append progress and activity records to the manifest-provided `leadEventsPath`. Use `okstra lead-progress append --phase <phase-id>` for a checkpoint and `okstra agent-activity append --kind <kind>` for an activity record; both resolve the ledger path from the run manifest. Emit the matching `PROGRESS:` line — the command prints it as `progressLine` — and, when an activity record is required, the immediately following `ACTIVITY:` line from the same structured fields. |
 | `collect_usage` | Collect host- or artifact-backed usage through the existing Okstra token-usage path; do not substitute another runtime's session log. |
 
 ## Antigravity dispatch details

package/runtime/python/okstra_ctl/adapters/hosts/capability_adapter.py

@@ -142,6 +142,15 @@ class CapabilityInteractionPort:
         kind = "numbered-multi" if prompt.multi else "numbered-single"
         return InteractionPlan(kind, AnswerProtocol("numbered", multi=prompt.multi))
 
+    @property
+    def native_option_limit(self) -> int:
+        """이 호스트의 네이티브 단일선택기가 한 화면에 받는 옵션 수.
+
+        추천 목록을 만드는 쪽이 이 수를 넘기지 않아야 `plan` 이
+        `numbered-single` 로 내리지 않는다.
+        """
+        return self._limits.max_options
+
     def _native_options_fit(self, prompt: WizardPrompt) -> bool:
         labels = tuple(option.label for option in prompt.options)
         return (

package/runtime/python/okstra_ctl/adapters/hosts/claude-code/adapter.py

@@ -42,6 +42,7 @@ DESCRIPTOR = HostDescriptor(
     session_accounting="claude-jsonl",
     has_claude_session=True,
     relay_contract=str(Path(__file__).with_name("relay.md").resolve()),
+    initial_prompt_delivery_mode="eager-include",
 )
 
 

package/runtime/python/okstra_ctl/adapters/hosts/claude-code/relay.md

@@ -12,7 +12,7 @@ This adapter maps the neutral Okstra lead operations to Claude Code host primiti
 | `leadRoleLabel` | `Claude lead` |
 | `userPromptMode` | `native-question` |
 | `workerDispatchBackend` | `mixed` |
-| `initialPromptDeliveryMode` | `lazy-path-reference` |
+| `initialPromptDeliveryMode` | `eager-include` |
 | `sessionAccounting` | `claude-jsonl` |
 | `resumeMode` | `session-id` |
 | `teardownMode` | `teammate-shutdown` |
@@ -140,12 +140,12 @@ For a `host-text` mapping, render each numbered item as its option label followe
 |---|---|
 | `read_artifacts` | Use the host file-read primitive and preserve the core contract's read order. |
 | `write_artifact` | Use the host file-write primitive only for paths authorized by the active lifecycle phase. |
-| `prompt_user` | Use `AskUserQuestion` for approvals and clarifications that fit `nativeLimits`. Do not print a numbered list in chat while that tool is available. Do not infer an answer from silence. |
+| `prompt_user` | Use `AskUserQuestion` for approvals and clarifications that fit `nativeLimits`. Do not print a numbered list in chat while that tool is available. Emit the question as the last thing in that turn: assistant text emitted after the call renders below the question and separates it from the user's answer. Do not infer an answer from silence. |
 | `dispatch_worker` | First verify the materialized invocation metadata. Dispatch `runner=native-session` through `Agent(name: "<role>", run_in_background: true)` without `team_name`, with `hostModelValue` and a summon message only — never the prompt body. The summon is exactly: `Your complete dispatch instructions are the document at <absolute promptPath>. Read that document in full before doing anything else — every line, continuing with offset until end of file — then execute it exactly. Do not act on this message alone.` The verified `promptPath` is already persisted and metadata-verified; inlining its body into the `Agent` call duplicates it in the lead context and lets the two copies drift. Dispatch `runner=cli-wrapper` with the deterministic shell command `okstra worker-dispatch --project-root <root> --run-manifest <path> --workers <ids>`; never wrap that process in another `Agent(...)` call. **Not in a cmux run:** when the run manifest's `terminalBackend` is `cmux-pane`, `prompts/lead/adapters/cmux.md` overrides this row. |
 | `await_workers` | Arm one background shell poll for the pending Result Paths; the spawn acknowledgement is not completion. |
 | `redispatch_worker` | Materialize and verify a fresh invocation, then use a fresh native `Agent(...)` session or `okstra worker-dispatch` attempt according to the persisted runner. |
 | `shutdown_workers` | For each confirmed-complete worker selected for cleanup, send `SendMessage(to: <name>, message: { type: "shutdown_request" })` to idle the roster member **and** call `TaskStop(task_id: "<name>")` to stop its background task. Both are required; neither subsumes the other. |
-| `record_lead_event` | Append progress and activity records to the manifest-provided `leadEventsPath`, including activity-contract-v1 records. Emit the matching `PROGRESS:` line and, when an activity record is required, the immediately following `ACTIVITY:` line from the same structured fields. |
+| `record_lead_event` | Append progress and activity records to the manifest-provided `leadEventsPath`, including activity-contract-v1 records. Use `okstra lead-progress append --phase <phase-id>` for a checkpoint and `okstra agent-activity append --kind <kind>` for an activity record; both resolve the ledger path from the run manifest. Emit the matching `PROGRESS:` line — the command prints it as `progressLine` — and, when an activity record is required, the immediately following `ACTIVITY:` line from the same structured fields. |
 | `collect_usage` | Run `okstra token-usage` against the team-state; it reads the run-scoped `~/.claude/projects` session JSONL evidence. |
 
 ## Dispatch variants

package/runtime/python/okstra_ctl/adapters/hosts/codex/adapter.py

@@ -33,6 +33,7 @@ DESCRIPTOR = HostDescriptor(
     session_accounting="artifact-only",
     has_claude_session=False,
     relay_contract=str(Path(__file__).with_name("relay.md").resolve()),
+    initial_prompt_delivery_mode="eager-include",
 )
 
 

package/runtime/python/okstra_ctl/adapters/hosts/codex/relay.md

@@ -110,23 +110,37 @@ Read this contract when `okstra preflight` returns this file as `runtimeReadines
 }
 ```
 
-For `request_user_input`, send one to three questions. Each question carries `id` (`prompt.step` or `questions[].step`), a header of at most 12 characters (`Q1`…`Q3`), the rendered question text including the progress suffix, and every wizard option as `{label, description}` in original order — the tool has no option `value` field. Do not include an `Other` option; the client adds a free-form row. Native plans are emitted only when the prompt fits `nativeLimits` (unique labels, two or three options, one to three questions) and no grouped question is multi-select. Other prompts use the text mapping so no option is dropped. Look up each answer by question `id`. The selected strings are in `answers[id].answers`. Match those strings to option labels, emit their `value` fields in original option order, and join with `,` when more than one is present. If the typed Other text matches no label, submit it unchanged.
+For `request_user_input`, send one to three questions. Each question carries `id` (`prompt.step` or `questions[].step`), a header of at most 12 characters (`Q1`…`Q3`), the rendered question text including the progress suffix, and every wizard option as `{label, description}` in original order — the tool has no option `value` field. **Send the wizard's free-input option (`__free_input__`) as the last row like any other choice**; it is the row that routes the answer into the wizard's own text step, and dropping it leaves the user with no way to answer anything the options do not cover. Do not invent an extra `Other` row of your own — the client already adds its own free-form row beside the options. Native plans are emitted only when the prompt fits `nativeLimits` (unique labels, two or three options, one to three questions) and no grouped question is multi-select. Other prompts use the text mapping so no option is dropped. Look up each answer by question `id`. The selected strings are in `answers[id].answers`. Match those strings to option labels, emit their `value` fields in original option order, and join with `,` when more than one is present. If the user typed into the client's own free-form row and the text matches no option label, do not submit that text to a `pick` step — it accepts option values only. Submit `__free_input__` when the step offers it, then submit the typed text unchanged as the answer to the text step the wizard asks next. Submit the text unchanged directly only when the step has no free-input option.
 
 For a `host-text` mapping, render each numbered item as its option label followed by its description verbatim; preserve every item and its order. The next user message is the raw answer: do not translate a number such as `1`, a CSV reply such as `1, 3`, an option label, or an option value before `okstra wizard step`. For `sequential-group`, collect one raw reply per question in order and build one compact JSON object keyed by the corresponding `questions[].step`; the wizard owns all normalization.
 
 
+### Client-aware question tool selection
+
+Before intersecting `semanticFunctions` with live capabilities, prefer `request_user_input` when the current session permits that call. Use its live restrictions rather than assuming it is always Plan-only: Codex CLI can enable it in Default mode with `default_mode_request_user_input`. The JSON mapping above remains the terminal picker contract.
+
+Use `request_user_input_async` only when the current client explicitly supports interactive asynchronous question cards, such as the Codex desktop app, and the synchronous tool is unavailable. Callable does not mean selectable: the Codex terminal (`codex-tui`, session source `cli`) can accept an asynchronous question but render it as a plain bulleted agent message. Do not count that terminal delivery as `native_single_select` or `native_question_group`. For a supported desktop client, replace the `function` of both native entries above with `request_user_input_async` and use the mapping below. Keep the conservative `nativeLimits` and the numbered mapping for multi-selection.
+
+If the user requested a selectable interface in the terminal and `request_user_input` is unavailable, keep the current wizard step pending instead of printing its options. `okstra install` enables `features.default_mode_request_user_input` when a Codex home exists, through `ensureCodexQuestionPicker` in `src/lib/host-config.mts`. Restart or resume the Codex session after installation and reread this relay. Changing the feature does not replace the current session's tool catalog. Preserve the existing wizard state-file path and call `okstra wizard step --state-file <existing-path> --no-submit` after resuming; do not initialize a replacement wizard or submit a guessed answer. If installation reports a configuration shape it cannot safely edit, its recovery command is `codex features enable default_mode_request_user_input`. Apply a configuration change only when authorized by the user, otherwise present the recovery command. The feature's availability is reported by `codex features list`; older clients without it need a client update or a mode in which the synchronous tool is permitted.
+
+For each asynchronous question send `{title, options}`. Put the question label, progress suffix, recommendation context, and option descriptions in `title`; put every original option label in the `options` string array in original order. Preserve the wizard's free-input option and do not add an extra Other option. Keep the correspondence between question position, wizard step, option label, and option value for this call. Send a group in one call.
+
+The immediate `{accepted: true}` response acknowledges delivery; it is not a user answer. Keep the call pending until the user's asynchronous reply arrives. Read each reply's `answer` and map its question position to the stored step. Map the selected label to the original option value; apply the synchronous free-form routing rule above for unmatched text. Submit one option value for a single question or one compact step-to-value JSON object for a group.
+
+Display the question only through the selected tool. Do not print it or its options again in commentary or final text. Do not call a second question tool, re-emit the same wizard step, or resubmit a question while its answer is pending. A preselected option is not an answer. Re-prompt only after an explicit answer fails wizard validation or the user requests a change. These are lead relay instructions; the runtime does not observe host UI emissions.
+
 ## Semantic operation mapping
 
 | Operation | Mapping |
 |---|---|
 | `read_artifacts` | Read the manifest-provided paths through the current host's file interface. |
 | `write_artifact` | Write only core-authorized `.okstra/` artifacts and preserve their schemas. |
-| `prompt_user` | Use `request_user_input` for approvals and clarifications that fit `nativeLimits` (two or three options). Do not print a numbered list in chat while that tool is available. Otherwise ask through host text and stop until an explicit answer arrives. |
+| `prompt_user` | Use the client-appropriate, mode-available question tool selected above for clarifications that fit `nativeLimits`. Show the question once through that tool and wait for the actual answer. Emit the question as the last thing in that turn: assistant text emitted after the call renders below the question and separates it from the user's answer. Follow the host's separate restrictions for permission requests. Use host text for unsupported interactions only when the user has not required a selectable interface; otherwise preserve the pending step and follow the recovery above. |
 | `dispatch_worker` | Verify each materialized invocation first. Dispatch `runner=native-session` with the current Codex host's primitive, the returned `promptPath`, and `hostModelValue`. Pass `runner=cli-wrapper` assignments to `okstra worker-dispatch --project-root <root> --run-manifest <path> --workers <ids>`; use `--dry-run` first when required. **Not in a cmux run:** when `terminalBackend` is `cmux-pane`, the cmux adapter overrides this row. |
 | `await_workers` | Await native host workers through the host primitive and CLI workers through synchronous dispatch, then verify team-state terminal records and Result Paths for both. |
 | `redispatch_worker` | Materialize and verify a fresh invocation, then start a fresh native worker or `okstra worker-dispatch` attempt according to the persisted runner. |
 | `shutdown_workers` | Perform process cleanup when a wrapper remains live; otherwise this operation is a no-op recorded in state. |
-| `record_lead_event` | Append progress and activity records to the manifest-provided `leadEventsPath`. Emit the matching `PROGRESS:` line and, when an activity record is required, the immediately following `ACTIVITY:` line from the same structured fields. |
+| `record_lead_event` | Append progress and activity records to the manifest-provided `leadEventsPath`. Use `okstra lead-progress append --phase <phase-id>` for a checkpoint and `okstra agent-activity append --kind <kind>` for an activity record; both resolve the ledger path from the run manifest. Emit the matching `PROGRESS:` line — the command prints it as `progressLine` — and, when an activity record is required, the immediately following `ACTIVITY:` line from the same structured fields. |
 | `collect_usage` | Collect artifact/rollout-backed usage through the existing Okstra token-usage path; never read Claude session JSONL as a substitute. |
 
 ## Codex dispatch details

package/runtime/python/okstra_ctl/adapters/hosts/external/adapter.py

@@ -32,6 +32,7 @@ DESCRIPTOR = HostDescriptor(
     session_accounting="artifact-only",
     has_claude_session=False,
     relay_contract=str(Path(__file__).with_name("relay.md").resolve()),
+    initial_prompt_delivery_mode="eager-include",
 )
 
 

package/runtime/python/okstra_ctl/adapters/hosts/external/relay.md

@@ -76,12 +76,12 @@ Render every numbered item as its option label followed by its description verba
 |---|---|
 | `read_artifacts` | Read the manifest-provided paths through the current host's file or shell interface. |
 | `write_artifact` | Write only core-authorized `.okstra/` artifacts and preserve their schemas. |
-| `prompt_user` | Ask through the host text/question interface and require an explicit approval or clarification response. |
+| `prompt_user` | Ask through the host text/question interface and require an explicit approval or clarification response. Emit the question as the last thing in that turn: assistant text emitted after the call renders below the question and separates it from the user's answer. |
 | `dispatch_worker` | Verify each materialized invocation, then run deterministic `okstra worker-dispatch --project-root <root> --run-manifest <path>` for CLI assignments. Use `okstra team dispatch` only when the selected pane backend owns visible panes. |
 | `await_workers` | Run `okstra team await --project-root <root> --run-manifest <path>` through the host's asynchronous shell facility. |
 | `redispatch_worker` | Create the core-specified fresh jobs file and dispatch it with a new `dispatchKind`; never reuse a live worker conversation. |
 | `shutdown_workers` | Run `okstra team teardown --project-root <root> --run-manifest <path>` only after the user-approved cleanup gate. |
-| `record_lead_event` | Append progress and activity records to the manifest-provided `leadEventsPath`. Emit the matching `PROGRESS:` line and, when an activity record is required, the immediately following `ACTIVITY:` line from the same structured fields. |
+| `record_lead_event` | Append progress and activity records to the manifest-provided `leadEventsPath`. Use `okstra lead-progress append --phase <phase-id>` for a checkpoint and `okstra agent-activity append --kind <kind>` for an activity record; both resolve the ledger path from the run manifest. Emit the matching `PROGRESS:` line — the command prints it as `progressLine` — and, when an activity record is required, the immediately following `ACTIVITY:` line from the same structured fields. |
 | `collect_usage` | Collect artifact/CLI-log-backed usage through the existing Okstra token-usage path; never substitute another runtime's session log. |
 
 ## External dispatch details
@@ -91,7 +91,7 @@ Render every numbered item as its option label followed by its description verba
 - Worker completion is valid only from `workerDispatches[]`, terminal status sidecars, and required Result Paths. Pane creation alone is not completion.
 - Reverify uses a fresh jobs file at `runs/<task-type>/state/reverify-jobs-r<N>-<task-type>-<seq>.json`, sets `dispatchKind: "reverify-r<N>"`, and dispatches with `okstra team dispatch --project-root <root> --run-manifest <path> --dispatch-kind reverify-r<N> --jobs-file <jobs-file>`.
 - Report-writer uses a fresh one-job jobs file with `dispatchKind: "report-writer"` and the same schema, then dispatches through `okstra team dispatch --project-root <root> --run-manifest <path> --jobs-file <jobs-file>`.
-- Every reverify or report-writer jobs file carries `workerId`, `provider`, `role`, `modelExecutionValue`, `promptPath`, `promptMetadataPath`, `invocationId`, `assignmentRef`, `audience`, the five prompt digests, `resultPath`, `workerResultPath`, and `completionPaths`. `worker-dispatch` verifies these fields before launching the provider process. For reverify, set `role` to `worker-reverify-r<N>`. The report-writer completion paths include its narrative Markdown, worker-result pointer, and audit sidecar; Phase 7 later assembles `data.json`.
+- Generate v2 reverify and report-writer jobs files with `okstra agent-prompt jobs --project-root <root> --run-manifest <path> --dispatch-kind <kind> --metadata <prompt-meta.json> [--metadata <prompt-meta.json>] --out <jobs-file>`. It verifies the inputs and derives canonical identity, role, result paths, and all five digests. Reverify uses role `verifier`; its round belongs to `dispatchKind`. Do not transcribe metadata fields or add `workerId` to v2 files. Existing v1 jobs-file consumers remain available. Report-writer completion uses the narrative and worker-result pointer; Phase 7 later assembles `data.json`.
 - After either dispatch, run `okstra team await --project-root <root> --run-manifest <path>` before evaluating terminal status or completion paths.
 
 ## Completion, cleanup, and resume

package/runtime/python/okstra_ctl/adapters/hosts/grok/adapter.py

@@ -32,6 +32,7 @@ DESCRIPTOR = HostDescriptor(
     session_accounting="artifact-only",
     has_claude_session=False,
     relay_contract=str(Path(__file__).with_name("relay.md").resolve()),
+    initial_prompt_delivery_mode="eager-include",
 )
 
 

package/runtime/python/okstra_ctl/adapters/hosts/grok/relay.md

@@ -136,12 +136,12 @@ For a `host-text` mapping, render each numbered item as its option label followe
 |---|---|
 | `read_artifacts` | Read the manifest-provided paths through the current Grok host file interface. |
 | `write_artifact` | Write only core-authorized `.okstra/` artifacts and preserve their schemas. |
-| `prompt_user` | Use `ask_user_question` for approvals and clarifications that fit `nativeLimits`. Do not print a numbered list in chat while that tool is available. Do not infer an answer from silence. |
+| `prompt_user` | Use `ask_user_question` for approvals and clarifications that fit `nativeLimits`. Do not print a numbered list in chat while that tool is available. Emit the question as the last thing in that turn: assistant text emitted after the call renders below the question and separates it from the user's answer. Do not infer an answer from silence. |
 | `dispatch_worker` | Verify the materialized invocation. Use the host primitive with `promptPath` and `hostModelValue` for `native-session`; use deterministic `okstra worker-dispatch` with `modelExecutionValue` for `cli-wrapper`. **Not in a cmux run:** the cmux adapter overrides this row. |
 | `await_workers` | Await through the selected common dispatch backend, then verify terminal state and Result Paths. |
 | `redispatch_worker` | Start a fresh attempt from the persisted assignment and record the supplied dispatch kind. |
 | `shutdown_workers` | Clean up only host or process resources owned by this run. |
-| `record_lead_event` | Append progress and activity records to the manifest-provided `leadEventsPath`. Emit the matching `PROGRESS:` line and, when an activity record is required, the immediately following `ACTIVITY:` line from the same structured fields. |
+| `record_lead_event` | Append progress and activity records to the manifest-provided `leadEventsPath`. Use `okstra lead-progress append --phase <phase-id>` for a checkpoint and `okstra agent-activity append --kind <kind>` for an activity record; both resolve the ledger path from the run manifest. Emit the matching `PROGRESS:` line — the command prints it as `progressLine` — and, when an activity record is required, the immediately following `ACTIVITY:` line from the same structured fields. |
 | `collect_usage` | Return explicit unavailable lead usage until Grok registers a session transcript or CLI usage artifact contract. |
 
 ## Completion, cleanup, and resume

package/runtime/python/okstra_ctl/adapters/hosts/kimi/adapter.py

@@ -32,6 +32,7 @@ DESCRIPTOR = HostDescriptor(
     session_accounting="artifact-only",
     has_claude_session=False,
     relay_contract=str(Path(__file__).with_name("relay.md").resolve()),
+    initial_prompt_delivery_mode="eager-include",
 )
 
 

package/runtime/python/okstra_ctl/adapters/hosts/kimi/relay.md

@@ -75,12 +75,12 @@ Render every numbered item as its option label followed by its description verba
 |---|---|
 | `read_artifacts` | Read the manifest-provided paths through the current Kimi host file interface. |
 | `write_artifact` | Write only core-authorized `.okstra/` artifacts and preserve their schemas. |
-| `prompt_user` | Ask through the current host text interface and wait for an explicit answer. |
+| `prompt_user` | Ask through the current host text interface and wait for an explicit answer. Emit the question as the last thing in that turn: assistant text emitted after the call renders below the question and separates it from the user's answer. |
 | `dispatch_worker` | Verify the materialized invocation. Use the host primitive with `promptPath` and `hostModelValue` for `native-session`; use deterministic `okstra worker-dispatch` with `modelExecutionValue` for `cli-wrapper`. **Not in a cmux run:** the cmux adapter overrides this row. |
 | `await_workers` | Await through the selected common dispatch backend, then verify terminal state and Result Paths. |
 | `redispatch_worker` | Start a fresh attempt from the persisted assignment and record the supplied dispatch kind. |
 | `shutdown_workers` | Clean up only host or process resources owned by this run. |
-| `record_lead_event` | Append progress and activity records to the manifest-provided `leadEventsPath`. Emit the matching `PROGRESS:` line and, when an activity record is required, the immediately following `ACTIVITY:` line from the same structured fields. |
+| `record_lead_event` | Append progress and activity records to the manifest-provided `leadEventsPath`. Use `okstra lead-progress append --phase <phase-id>` for a checkpoint and `okstra agent-activity append --kind <kind>` for an activity record; both resolve the ledger path from the run manifest. Emit the matching `PROGRESS:` line — the command prints it as `progressLine` — and, when an activity record is required, the immediately following `ACTIVITY:` line from the same structured fields. |
 | `collect_usage` | Return explicit unavailable lead usage until Kimi registers a session transcript or CLI usage artifact contract. |
 
 ## Completion, cleanup, and resume

package/runtime/python/okstra_ctl/adapters/providers/codex/adapter.py

@@ -16,13 +16,13 @@ from okstra_ctl.domain.worker_presentation import SplitText
 import okstra_ctl.model_discovery as model_discovery
 
 
-# Slugs and order follow the provider catalog the codex CLI caches in
-# `~/.codex/models_cache.json` (read 2026-08-26, client 0.150.0): sol / terra /
-# luna are the three visible 5.6 entries, in the priority the provider assigns.
+# 모델 식별자와 순서는 Codex의 `~/.codex/models_cache.json`을 따른다
+# (2026-09-07 확인, 클라이언트 0.153.4): astra / sol / terra / luna.
 # `gpt-5.6` is not a slug that catalog offers at all, so it is gone from here;
 # its rate moved to `_LEGACY_CODEX_PRICING` so past runs still price.
 CODEX = {
     # ChatGPT-account hosts serve these models without per-token billing.
+    "gpt-6-astra": ModelSpec("gpt-6-astra", "gpt-6-astra", "gpt-6-astra"),
     "gpt-5.6-sol": ModelSpec("gpt-5.6-sol", "gpt-5.6-sol", "gpt-5.6-sol"),
     "gpt-5.6-terra": ModelSpec("gpt-5.6-terra", "gpt-5.6-terra", "gpt-5.6-terra"),
     "gpt-5.6-luna": ModelSpec("gpt-5.6-luna", "gpt-5.6-luna", "gpt-5.6-luna"),