okstra 0.199.1 → 0.199.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "okstra",
-  "version": "0.199.1",
+  "version": "0.199.2",
   "description": "Host-aware multi-provider cross-verification orchestrator runtime and agent skills.",
   "license": "MIT",
   "author": "devonshin",

package/runtime/BUILD.json

@@ -1,5 +1,5 @@
 {
-  "package": "0.199.1",
-  "builtAt": "2026-09-11T21:21:59.712Z",
+  "package": "0.199.2",
+  "builtAt": "2026-09-11T23:34:24.321Z",
   "repoRoot": "/home/runner/work/okstra/okstra"
 }

package/runtime/prompts/launch.template.md

@@ -57,7 +57,7 @@ For every other task type:
 - Pointer `status: terminal` → the lifecycle ends here. Say the task is finished and quote the pointer's `rationale`. Do not propose a run and do not send the user to `/okstra-inspect`: the decision is already made, so there is nothing to inspect. If this run registered follow-up tasks, name them and the command that starts one.
 - Pointer `status: blocked` → the pointer's `rationale` names what is in the way and what to run. Quote it and issue that command — `/okstra-user-response` for the `C-NNN` ids it lists, or `/okstra-run` for the phase it names.
 - Pointer `status: pending` with a `rationale` → the user's own input is what comes next. Quote the `rationale` and issue the command it names. Do not re-run the phase that just completed, and do not send the user to `/okstra-inspect`: a finished phase has nothing to inspect, and re-running it discards the result the user is being asked to act on.
-- Phase 7 `validate-run` failed → one line naming the blocking cause, then `/okstra-run` to re-run this phase. Only a failure matching the blocking allowlist (`okstra_ctl.blocking_checks`) reaches this row; every other finding was demoted to an advisory, printed as `validate-run: advisory — <finding>`, and the run passed. Name those advisories in one line and take the command from the matching pointer row above — an advisory is not a reason to re-run.
+- Phase 7 `validate-run` failed → one line naming the blocking cause, then use the blocked pointer's `phase` as the recovery target with `/okstra-run`; re-run the current phase only when that target is empty. Only a failure matching the blocking allowlist (`okstra_ctl.blocking_checks`) reaches this row; every other finding was demoted to an advisory, printed as `validate-run: advisory — <finding>`, and the run passed. Name those advisories in one line and take the command from the matching pointer row above — an advisory is not a reason to re-run.
 - Otherwise → `/okstra-inspect status` for this task.
 
 Name every file in this reply as a markdown link — `[<what it is>](<path>)`, path inside the parentheses — so the user can open it. `reportPaths.markdown` in the `report-finalize` result already carries this run's report, report record, and team state that way. Commands stay in backticks.

package/runtime/prompts/lead/adapters/cmux.md

@@ -6,6 +6,8 @@ This adapter maps the neutral Okstra lead operations to a cmux session, where Ok
 
 It overrides only the worker-dispatch portion of the selected host relay, not the host or lead contract. Your own runtime still decides how you read files, ask the user, and record your session — this file only decides how workers are started, awaited, and reclaimed.
 
+Keep the selected host relay's dispatch permission guidance when calling `okstra team dispatch`. For a restricted Codex lead, its `Permission at the dispatch boundary` guidance applies to every live dispatch, including reverify and critic jobs; selecting cmux does not grant execution privileges.
+
 ## Capability declaration
 
 | Field | Value |

package/runtime/prompts/lead/okstra-lead-contract.md

@@ -512,7 +512,7 @@ For every other task type:
 - Pointer `status: terminal` and the result carries `nextInGroup` → the task is finished and the task-group has a task not yet started: say this task is finished, then close on `/okstra-run` for `nextInGroup.briefId` from its `brief` path — the group's start order is the brief ordinal, and `nextCommand.note` already names the task and its brief.
 - Pointer `status: blocked` → the pointer's `rationale` names what is in the way and what to run. Quote it and issue that command — `/okstra-user-response` for the `C-NNN` ids it lists, or `/okstra-run` for the phase it names.
 - Pointer `status: pending` with a `rationale` → the user's own input is what comes next. Quote the `rationale` and issue the command it names. Do not re-run the phase that just completed, and do not send the user to `/okstra-inspect`: a finished phase has nothing to inspect, and re-running it discards the result the user is being asked to act on.
-- Phase 7 `validate-run` failed → one line naming the blocking cause, then `/okstra-run` to re-run this phase with the recorded sidecar. Only a failure matching the blocking allowlist (`okstra_ctl.blocking_checks`) reaches this row; every other finding was demoted to an advisory, printed as `validate-run: advisory — <finding>`, and the run passed. Name those advisories in one line and take the command from the matching pointer row above — an advisory is not a reason to re-run.
+- Phase 7 `validate-run` failed → one line naming the blocking cause, then use the blocked pointer's `phase` as the recovery target with `/okstra-run`; re-run the current phase only when that target is empty. Only a failure matching the blocking allowlist (`okstra_ctl.blocking_checks`) reaches this row; every other finding was demoted to an advisory, printed as `validate-run: advisory — <finding>`, and the run passed. Name those advisories in one line and take the command from the matching pointer row above — an advisory is not a reason to re-run.
 - Otherwise → `/okstra-inspect status` for this task.
 
 When the host native picker is available and two of those rows could apply, ask with that picker (recommended first). Do not end the turn after the status dump.

package/runtime/prompts/lead/report-writer.md

@@ -123,16 +123,17 @@ For historical schema-v1 Markdown only, the following heading table remains a re
 
 **Enforced:** `okstra_ctl.report_finalize.V3_STEP_ORDER` is the order — `report-finalize` runs the steps from that tuple, so the sequence cannot be reordered by a caller. Running the steps by hand is what this rule forbids, and that path is not reachable through the CLI.
 
-Do not run the eight steps below manually. Invoke `okstra report-finalize`; contract 3.0 runs them in this order:
+Do not run the nine steps below manually. Invoke `okstra report-finalize`; contract 3.0 runs them in this order:
 
 1. **`token-usage`** — collect usage into team state without touching the final record.
 2. **`project-activity`** — report assembly validates every owner input and publishes the final record once.
-3. **`translate`** — for a non-English `reportLanguage`, materialize and dispatch the translator worker and require its `*.i18n.<lang>.json` sidecar; a no-op for English or when the sidecar already exists.
-4. **`render-views`** — render the Markdown reading copy and human HTML, with the translation sidecar overlaid.
-5. **`spawn-followups`** — materialize registered follow-up tasks.
-6. **`validate-run`** — validate the record, views, run manifest, and team state.
-7. **`record-group-memory`** — write this run's conclusion (headline, decisions, watch-outs, open follow-ups, record path, next phase) and the group's start order into the task-group's `group-context.md` okstra region, creating the file when the group has none; skipped, like teardown, when an earlier step failed. Sibling tasks read it as `## Task-Group Memory`.
-8. **`teardown-stages`** — remove eligible stage worktrees after successful validation.
+3. **`preflight`** — run the same schema and conformance checks used by final validation before translation, without writing run status. Structural failure skips translation; rendering and final validation still record the failure. `--only translate` also includes this check.
+4. **`translate`** — for a non-English `reportLanguage`, materialize and dispatch the translator worker and require its `*.i18n.<lang>.json` sidecar; a no-op for English or when the sidecar already exists.
+5. **`render-views`** — render the Markdown reading copy and human HTML, with the translation sidecar overlaid.
+6. **`spawn-followups`** — materialize registered follow-up tasks.
+7. **`validate-run`** — validate the record, views, run manifest, and team state.
+8. **`record-group-memory`** — write this run's conclusion (headline, decisions, watch-outs, open follow-ups, record path, next phase) and the group's start order into the task-group's `group-context.md` okstra region, creating the file when the group has none; skipped, like teardown, when an earlier step failed. Sibling tasks read it as `## Task-Group Memory`.
+9. **`teardown-stages`** — remove eligible stage worktrees after successful validation.
 
 After `report-finalize` returns, the lead — not the report writer — closes the run with the launch prompt's User closeout: one command the user can run now.
 

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

@@ -9,12 +9,14 @@ at Phase 5, BEFORE constructing the verifier worker dispatch prompts.
 
 - Every verdict comes from a fresh session with no shared context, never from the 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 is the primary self-review safeguard: each verifier is a separate invocation with its own context window. Reusing the executor's model is acceptable. The model comes from the run's stored assignment.
-- Verifiers read from the SAME working tree path the Executor used so they observe the exact diff the Executor produced. Verifiers remain strictly read-only there.
+- Verifiers read from the SAME working tree path the Executor used so they observe the exact diff the Executor produced. Source files, lockfiles, Git state, and shared links remain read-only. Declared verification commands may create their normal worktree-local build/cache outputs and install dependencies with a frozen lockfile. This is the bounded exception to the preceding write restriction; it does not permit source repairs, moving shared links, or redirecting build outputs outside the worktree. Run-owned logs remain in the run artifact directories.
 
 **Enforced:** `_validate_verifier_command_log_is_read_only` in `validators/validate-run.py` scans every `verifierResults[].readOnlyCommandLog` for source-mutating commands (`sed -i`, `git checkout --`/`restore`/`reset --hard`/`stash`/`clean`/`apply`, `patch -p`, `rm -rf`, `truncate`). Read-only forms (`git stash list`, `git clean --dry-run`, `git apply --check`) pass.
 
 ## Verifier QA duties (independent re-run mandate)
 
+`okstra_ctl.qa_commands.find_unfrozen_installs` rejects unfrozen npm/pnpm/yarn/bun installs in both the plan preflight and the verifier command log. If an approved command conflicts with these restrictions or cannot run in the provisioned worktree, report the exact checklist row and route to `implementation-planning`; do not substitute a command during verification.
+
 Every verifier acts as a QA gate, not just a diff reviewer. Trusting the executor's reported evidence is forbidden — verifiers MUST reproduce it themselves from the same worktree path the executor used.
 
 **Enforced:** `_validate_verifier_reran_independently` in `validators/validate-run.py` fails an empty `independentValidationRerun`. What you wrote in it is not pattern-matched — the wording check that used to reject phrasings citing the executor is gone, because it fired on reports that had reproduced the run and merely said so. Write the command you ran and its outcome; the Discrepancy rule below is what makes you name the divergence.

package/runtime/prompts/profiles/forbidden-actions.json

@@ -47,7 +47,7 @@
   ],
   "implementation-planning": [
     "source code edits of any kind (Edit/Write on project source files is forbidden)",
-    "file writes outside the run`s artifact directories (`reports/`, `prompts/`, `state/`, `manifests/`, `worker-results/`, `status/`, `sessions/`) and the task-root qa tree (`<task_root>/qa/` — the Tier3 conformance scripts, manifest, and tsconfig this phase MUST write per the Stage Map conformance contract); in particular, do not write to `docs/superpowers/specs/` or `docs/superpowers/plans/`",
+    "file writes outside the run`s artifact directories (`reports/`, `prompts/`, `state/`, `manifests/`, `worker-results/`, `status/`, `sessions/`), including task-root QA scripts, manifest, and tsconfig (planning declares conformance commands and required dependencies; implementation writes these files); in particular, do not write to `docs/superpowers/specs/` or `docs/superpowers/plans/`",
     "executing builds, migrations, deployments, or any state-mutating command",
     "starting `implementation` inside this run (must be a separate run authorised by an approved deliverable from this phase), even if the user says \"다음 단계 진행해\"",
     "dispatching parallel sub-agents beyond the required worker roster (okstra owns worker fan-out)",

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

@@ -1,5 +1,9 @@
 # Implementation Planning Profile
 
+Validation commands are executable inputs: preserve their newlines, quotes, and code bodies. Use frozen dependency installation (`npm ci`, `pnpm install --frozen-lockfile`, or the package manager's equivalent). Name QA scripts with absolute task-artifact paths when a command runs from a stage worktree; `.okstra/tasks/...` relative to that worktree does not point to the project task. `stage_validation_executability_errors` enforces command restrictions at planning validation, implementation entry, and report preflight, including advisory plan-body runs.
+
+Plan for the actual worktree layout before approval. Shared documentation directories can be links to the main checkout. Choose a build command compatible with those links (for example, an installed Next.js version may provide `next build --webpack`); verify the available option rather than assuming it. Do not plan for a verifier to move links or repair its environment. Compare negative-case assertions with the brief and the script body: a requirement to cache existing assets does not establish that missing assets should be cached. Record any changed expectation in a new plan revision; preserve the earlier approved plan.
+
 ```yaml
 roles:
   - role: planner
@@ -185,7 +189,7 @@ roles:
       Layout split (the implementer writes these, not this phase): executable scripts (conformance + any real-IO test) live under `<task_root>/qa/scripts/`; data sidecars (`conformance-manifest.json`, `result-*.json`) stay at the `qa/` root. This declaration is enforced at four layers: `validators/validate-implementation-plan-stages.py` check **S11** forces every stage to carry one of the two lines; at the planning boundary `validators/validate-run.py` `_validate_planning_conformance_declared` accepts a well-formed `Conformance tests:` line even when the script file and manifest entry are absent (malformed `requires` still fails); the matching `implementation` stage run that inherited `Conformance tests:` fails closed when the script file is missing (`_validate_conformance`); and the manifest JSON structure — including each entry's `script` living under `qa/scripts/` and a `runCommand` that does not change cwd — is enforced by `validate_conformance_manifest` when the implementer writes the entry.
     - `### Stage Exit Contract` — predicted added/modified files, newly exposed identifiers/types/endpoints, downstream-usable resources.
     - `### Stage Validation` — pre / mid / post exact commands or observable outcomes for this stage only.
-      - **Run-executable only (BLOCKING).** A `validationChecklist` row that carries `stageRefs` gates that stage's carry, so it MUST be executable by the implementation run itself — no deployment, no manual walk-through, no observation "by hand", no credentials the run does not hold. The implementation phase forbids deploys and holds no deploy credentials, so such a row can never pass and blocks a stage with zero code defects (observed: dev-10341 VC-013/VC-014). Manual or deployed-environment verification belongs in the brief's `External Gates` and final-verification's user-owned external QA — record it there without `stageRefs`. **Enforced:** `okstra_ctl.implementation_direction.validate_selected_direction_plan` (`_stage_validation_executability_errors`) rejects stage-gating rows whose observation text requires a manual or deployed-environment step.
+      - **Run-executable only (BLOCKING).** A `validationChecklist` row that carries `stageRefs` gates that stage's carry, so it MUST be executable by the implementation run itself — no deployment, no manual walk-through, no observation "by hand", no credentials the run does not hold. The implementation phase forbids deploys and holds no deploy credentials, so such a row can never pass and blocks a stage with zero code defects (observed: dev-10341 VC-013/VC-014). Manual or deployed-environment verification belongs in the brief's `External Gates` and final-verification's user-owned external QA — record it there without `stageRefs`. **Enforced:** `okstra_ctl.implementation_direction.validate_selected_direction_plan` (`stage_validation_executability_errors`) rejects stage-gating rows whose observation text requires a manual or deployed-environment step.
       - **Dependency precondition (stages that run the project toolchain).** The planning worktree is created without installed dependencies, so a stage whose steps call `npm` / `yarn` / `pytest` / `cargo` / equivalent cannot have those commands succeed at plan time — they exit `127`, not RED/GREEN. Declare the install **once** as a `phase: pre` row in `### Validation Checklist` (e.g. `VC-008 — the implementation run's stage worktree has workspace dependencies installed`) and have every such stage's `Stage Validation` cite that `VC-NNN` in its `pre:` line. Do not repeat the install commands per stage, and do not silently assume the tooling is present: a plan that never states the precondition produces steps whose commands never resolve, which the §5.5.9 round then reports as unverifiable. **Enforced (advisory):** `validators/validate-run.py` `_detect_missing_dependency_precondition` warns when a toolchain-invoking stage cites no `VC-NNN`, or cites one that is not `phase: pre`. Whether the cited row genuinely covers dependencies is a §5.5.9 judgement, not a machine check. Detection uses the token allowlist in `scripts/okstra_ctl/build_tools.py`; a project overrides it with `buildToolTokens` in `.okstra/project.json`.
   - **Vertical-slice-first partition rule (1st-class):** the grouping anchor is a **thin end-to-end vertical slice** — one stage delivers a single user-observable increment, crossing whatever layers are needed (data → service → API → UI) to make that one increment work. File/module proximity is demoted to the **intra-slice grouping rule**: within a slice, keep steps touching the same file/directory/module together so the diff, PR, and rollback unit stay cohesive. **Horizontal layer-splitting is forbidden** — never carve "the DB layer" into one stage and "the service layer" into the next; that produces stages that ship no standalone user value. A stage is split ONLY when (a) a real `depends-on` data/contract dependency exists, (b) effective steps would exceed 8, or (c) it is a distinct vertical slice (a different user-value increment). Maximising the number of parallel stages is NOT a reason to split — parallelism is an emergent property of independent stages, never a partitioning goal. **Config propagation is not a slice (BLOCKING):** a dependent stage whose planned paths are all configuration/CI files (`Dockerfile`, `docker-compose*`, `*.yml` / `*.yaml`, `.env*`) merely propagates a value another stage introduced — it ships no user-value increment of its own. Fold that work into the introducing stage as its own step(s) and separate it by **commits**, never by stages: each extra stage costs a full implementation run (executor + verifiers, 30min+ observed) for a few config lines. A first stage with no dependency is exempt — a task whose whole scope is configuration is legitimate. **Enforced:** `okstra_ctl.implementation_direction.validate_selected_direction_plan` (`_micro_stage_fold_errors`).
   - **Project-boundary partition rule (hard boundary):** a *project* boundary is either (a) a different repository / `PROJECT_ROOT`, or (b) a different top-level independently-deployable module within one repo. A stage maps to a single worktree on one repo/branch, so **no stage may contain edits belonging to more than one project** — this is a hard split that overrides the ≤8-step merging allowance; never co-locate two projects' changes in one stage to save a stage. Two cases:

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

@@ -178,6 +178,14 @@ Display the question only through the selected tool. Do not print it or its opti
 
 ## Codex dispatch details
 
+### Permission at the dispatch boundary
+
+Before a live CLI worker dispatch, check the current host's declared sandbox and approval policy. In a restricted Codex session, request the host's supported execution permission on the dispatch command itself (`sandbox_permissions: "require_escalated"` for `exec_command` when that mechanism is available and permitted). Scope the request to the prepared run and explain that it starts the selected worker processes. Follow the host's approval decision; a wizard confirmation or a successful preflight does not grant this permission.
+
+Apply this guidance to both `okstra worker-dispatch` and the cmux override's `okstra team dispatch`, including initial workers, reverify, critic, report-writer, and retries. Read-only previews do not start workers. A session already authorized to execute outside the sandbox does not need another request. When the host prohibits escalation, preserve the pending invocation and report the execution constraint instead of trying an alternate launcher or weakening host controls.
+
+The worker's `--sandbox danger-full-access` flag only selects the child Codex policy; it does not remove restrictions inherited from the parent process. If startup reports `Operation not permitted`, retain the exact error and distinguish initialization failure from a worker verdict. Retry only through the permitted host mechanism after the execution conditions change, within the existing retry limit; do not repeat the same restricted invocation. This is host-call guidance, not a permission grant or a runtime-enforced check.
+
 - For convergence reverify, consume the persisted round plan exactly. This adapter may map and transport each returned batch, but it cannot change batch membership and does not classify findings or branch on task type, provider, or model identity.
 - Do not invoke Claude Code team or subagent tools.
 - The prepared run manifest and team-state are the dispatch authority. A `runner=native-session` assignment stays in the current Codex host; a `runner=cli-wrapper` assignment uses the registered provider wrapper. Unsupported explicitly requested workers fail; an adapter must not silently change the roster.

package/runtime/python/okstra_ctl/agent/prompt_cli/dynamic_verifier.py

@@ -28,6 +28,7 @@ from ...convergence_store import (
 from ...worker_prompt_policy import (
     CRITIC_VERIFY_DISPATCH_KIND,
     PLAN_VERIFY_DISPATCH_KIND_PREFIX,
+    is_plan_critic_verification,
     verification_dispatch_round,
 )
 from .inputs import AgentPromptCliError
@@ -81,7 +82,10 @@ def _dynamic_verifier_source(
         and manifest.get("executionIdentityVersion") == 2
     )
     is_reverify = (
-        args.assignment_ref.startswith("reverify/")
+        (args.assignment_ref.startswith("reverify/") or is_plan_critic_verification(
+            task_type=str(manifest.get("taskType", "")),
+            assignment_ref=args.assignment_ref, dispatch_kind=args.dispatch_kind,
+        ))
         and args.audience == "reverification-worker"
     )
     source = args.source_role_execution_ref

package/runtime/python/okstra_ctl/agent/prompt_cli/run_identity.py

@@ -10,6 +10,7 @@ from typing import Any, Mapping
 
 from ...worker_prompt_policy import (
     CRITIC_DUTY_BY_ASSIGNMENT_SEGMENT,
+    is_plan_critic_verification,
     resolve_prompt_plan_for_manifest,
 )
 from .inputs import AgentPromptCliError
@@ -35,7 +36,12 @@ def _validate_run_identity(
     elif assignment_ref.startswith("critic/"):
         scope = assignment_ref.split("/", 1)[1]
         expected = CRITIC_DUTY_BY_ASSIGNMENT_SEGMENT.get(scope, "")
-        if not expected or dispatch_kind != "critic":
+        if is_plan_critic_verification(
+            task_type=str(manifest.get("taskType", "")),
+            assignment_ref=assignment_ref, dispatch_kind=dispatch_kind,
+        ):
+            expected = "reverification-worker"
+        elif not expected or dispatch_kind != "critic":
             raise AgentPromptCliError("critic assignment identity is invalid")
         # provider 대조는 여기 두지 않는다. critic 의 `worker_id` 는 배정 참조의
         # 마지막 마디(`scope` / `acceptance`)이고 provider 이름이 아니다

package/runtime/python/okstra_ctl/conformance.py

@@ -61,6 +61,13 @@ def normalize_conformance_script(
     value = script[len(prefix):] if script.startswith(prefix) else script
     while value.startswith("./"):
         value = value[2:]
+    if task_root is not None and value.startswith(".okstra/"):
+        for parent in task_root.resolve().parents:
+            if parent.name == ".okstra" and task_root.resolve().is_relative_to(
+                parent / "tasks"
+            ):
+                value = str((parent.parent / value).resolve())
+                break
     if task_root is not None and value.startswith("/"):
         try:
             return Path(value).resolve().relative_to(task_root.resolve()).as_posix()

package/runtime/python/okstra_ctl/convergence_store.py

@@ -17,6 +17,7 @@ from .json_boundary import JsonBoundaryError, load_owned_object, write_owned_obj
 
 
 DYNAMIC_VERIFIER_SOURCE_ROLES = frozenset({
+    "critic",
     "analyser",
     "designer",
     "planner",
@@ -163,12 +164,14 @@ def reserve_dynamic_verifier(
     manifest = read_execution_manifest(manifest_path)
     if manifest.legacy:
         raise ExecutionManifestError("cannot reserve a dynamic verifier in v1 data")
+    authority = load_owned_json_object(manifest_path)
     _validate_dynamic_verifier_request(
         manifest.role_executions,
         source_role_execution_ref,
         duty_id,
+        task_type=str(authority.get("taskType", "")),
+        dispatch_kind=dispatch_kind or f"reverify-r{round_number}",
     )
-    authority = load_owned_json_object(manifest_path)
     if authority.get("taskKey") not in (None, task_key):
         raise ExecutionManifestError("dynamic verifier taskKey does not match manifest")
     project_root = _manifest_project_root(authority, manifest_path)
@@ -219,7 +222,12 @@ def _validate_dynamic_verifier_request(
     roles: tuple[RoleExecution, ...],
     source_role_execution_ref: str,
     duty_id: str,
+    *,
+    task_type: str,
+    dispatch_kind: str,
 ) -> None:
+    from .worker_prompt_policy import is_plan_verify_dispatch_kind
+
     try:
         duty_role = role_for_duty(duty_id)
     except RoleCatalogError as exc:
@@ -238,6 +246,13 @@ def _validate_dynamic_verifier_request(
         raise ExecutionManifestError(
             f"dynamic verifier source role is not eligible: {source.role}"
         )
+    if source is not None and source.role == "critic" and not (
+        task_type == "implementation-planning"
+        and is_plan_verify_dispatch_kind(dispatch_kind)
+    ):
+        raise ExecutionManifestError(
+            "critic source role is eligible only for planning verification"
+        )
 
 
 def _manifest_project_root(

package/runtime/python/okstra_ctl/error_log_core.py

@@ -31,7 +31,7 @@ def parse_records(paths: list[Path]) -> tuple[list[dict], int]:
         except (OSError, UnicodeDecodeError):
             skipped += 1
             continue
-        for line in text.splitlines():
+        for line_number, line in enumerate(text.splitlines(), 1):
             line = line.strip()
             if not line:
                 continue
@@ -42,6 +42,7 @@ def parse_records(paths: list[Path]) -> tuple[list[dict], int]:
                 continue
             if isinstance(rec, dict):
                 rec["_sourceLog"] = str(path)
+                rec["_sourceLine"] = line_number
                 records.append(rec)
             else:
                 skipped += 1

package/runtime/python/okstra_ctl/error_report.py

@@ -100,12 +100,31 @@ def prior_run_error_digest(
             )
         ],
     )
+    examples: dict[tuple[str, str], str] = {}
+    for record in carried:
+        message = str(record.get("message") or "")[:1200]
+        command = str(record.get("command") or "")[:800]
+        if message or command:
+            examples[(message, command)] = (
+                f"{record['_sourceLog']}:{record['_sourceLine']}"
+            )
+    details = (
+        _md_table(
+            ["Message", "Command", "Source"],
+            [
+                [message, command, source]
+                for (message, command), source in list(examples.items())[-20:]
+            ],
+        )
+        if examples
+        else ""
+    )
     return (
         "# Prior-Run Errors\n\n"
         "`contract-violation` and `tool-failure` records this task's earlier "
         "runs wrote. These are not findings about the work — they are traps "
         "that fired before and can fire again in this run.\n\n"
-        f"{table}\n"
+        f"{table}\n\n{details}\n"
     )
 
 

package/runtime/python/okstra_ctl/implementation_direction.py

@@ -31,6 +31,7 @@ from .json_boundary import (
     write_owned_object_atomic,
 )
 from .report_views import normalize_direction_selection_identity
+from .qa_commands import find_denied_tokens
 from .scope_provenance import brief_end_state_id_sequence
 from .user_response import UserResponseError, parse_direction_selection
 
@@ -814,14 +815,31 @@ _MANUAL_VALIDATION_MARKERS = (
 )
 
 
-def _stage_validation_executability_errors(
+def stage_validation_executability_errors(
     planning: Mapping[str, Any],
 ) -> list[str]:
     failures: list[str] = []
     for row in planning.get("validationChecklist") or ():
-        if not isinstance(row, Mapping) or not row.get("stageRefs"):
+        if not isinstance(row, Mapping):
             continue
-        lowered = str(row.get("commandOrObservation") or "").lower()
+        command = str(row.get("commandOrObservation") or "")
+        denied = find_denied_tokens(command)
+        if re.search(r"(?<![\w/])\.?/?\.okstra/tasks/", command):
+            denied.append(
+                "project-relative QA path (use the absolute task artifact path; keep worktree cwd)"
+            )
+        if re.search(r">\s*/(?:tmp|private/tmp|var/tmp)/", command):
+            denied.append(
+                "output outside the worktree (use a worktree-local output path)"
+            )
+        if denied:
+            failures.append(
+                f"validationChecklist {row.get('id')} conflicts with verifier command rules: "
+                f"{'; '.join(denied)}; correct and approve the plan before implementation"
+            )
+        if not row.get("stageRefs"):
+            continue
+        lowered = command.lower()
         matched = [
             marker for marker in _MANUAL_VALIDATION_MARKERS if marker in lowered
         ]
@@ -947,6 +965,6 @@ def validate_selected_direction_plan(
             planning, brief_end_state_id_sequence(Path(brief_path))
         )
     )
-    failures.extend(_stage_validation_executability_errors(planning))
+    failures.extend(stage_validation_executability_errors(planning))
     failures.extend(_micro_stage_fold_errors(planning))
     return failures

package/runtime/python/okstra_ctl/plan_items_cli.py

@@ -469,6 +469,18 @@ def _label(key: str) -> str:
     return " ".join(part.capitalize() for part in key.replace("Id", " ID").split())
 
 
+def _render_literal(label: str, value: str, indent: str = "") -> list[str]:
+    """명령·코드의 줄바꿈을 보존하고 본문보다 긴 울타리로 감싼다."""
+    fence = "`" * max(
+        3, 1 + max((len(part) for part in re.findall(r"`+", value)), default=0)
+    )
+    body = "".join(indent + "  " + row for row in value.splitlines(keepends=True))
+    ending = "" if value.endswith("\n") else "\n"
+    return [
+        f"{indent}- {label}:\n\n{indent}  {fence}text\n{body}{ending}{indent}  {fence}\n"
+    ]
+
+
 def _render_object_list(key: str, value: object) -> list[str]:
     if not isinstance(value, list):
         raise PlanItemContractError(f"plan item {key} must be an array")
@@ -491,6 +503,8 @@ def _render_object_list(key: str, value: object) -> list[str]:
                     raise PlanItemContractError(
                         f"plan item {field_path} must be scalar"
                     )
+                elif field == "details" and isinstance(field_value, str):
+                    rows.extend(_render_literal(f"`{field_path}`", field_value, "    "))
                 else:
                     rows.append(
                         f"    - `{field_path}`: `{scalar(field_value)}`\n"
@@ -542,6 +556,8 @@ def _render_scalar_or_list(key: str, value: object, indent: str = "") -> list[st
         return rows
     if isinstance(value, Mapping):
         raise PlanItemContractError(f"plan item {key} must be scalar")
+    if key in {"command", "commandOrObservation"} and isinstance(value, str):
+        return _render_literal(_label(key), value, indent)
     return [indent + line(_label(key), value)]
 
 

package/runtime/python/okstra_ctl/qa_commands.py

@@ -72,6 +72,31 @@ def _has_insta_update_set(cmd: str) -> bool:
     return match.group(1).lower() != "no"
 
 
+def find_unfrozen_installs(cmd: str) -> list[str]:
+    """계획과 실행 기록에서 같은 잠금파일 고정 조건을 판정한다."""
+    found: list[str] = []
+    if _has_npm_install_without_ci(cmd):
+        found.append("npm install (use 'npm ci' instead)")
+    for match in re.finditer(r"\b(pnpm|yarn|bun)\s+(?:install|i)\b([^;&|\n]*)", cmd):
+        flags = match.group(2).split()
+        frozen = "--frozen-lockfile" in flags or (
+            match.group(1) == "yarn" and "--immutable" in flags
+        )
+        disabled = any(
+            flag
+            in {
+                "--no-frozen-lockfile",
+                "--frozen-lockfile=false",
+                "--no-immutable",
+                "--immutable=false",
+            }
+            for flag in flags
+        )
+        if not frozen or disabled:
+            found.append(f"{match.group(1)} install (requires a frozen lockfile)")
+    return found
+
+
 def find_denied_tokens(cmd: str) -> list[str]:
     """`cmd` 안에 포함된 모든 denied 토큰 목록을 반환. 비어 있으면 안전."""
     if not isinstance(cmd, str):
@@ -84,8 +109,7 @@ def find_denied_tokens(cmd: str) -> list[str]:
     for sub in _DENIED_SUBSTRINGS:
         if sub in cmd:
             found.append(sub)
-    if _has_npm_install_without_ci(cmd):
-        found.append("npm install (use 'npm ci' instead)")
+    found.extend(find_unfrozen_installs(cmd))
     if _has_insta_update_set(cmd):
         found.append("INSTA_UPDATE=<not-no>")
     return found

package/runtime/python/okstra_ctl/report_finalize.py

@@ -93,6 +93,7 @@ STEP_SPAWN_FOLLOWUPS = "spawn-followups"
 STEP_VALIDATE_RUN = "validate-run"
 STEP_RECORD_GROUP_MEMORY = "record-group-memory"
 STEP_TEARDOWN_STAGES = "teardown-stages"
+STEP_PREFLIGHT = "preflight"
 
 STEP_ORDER = (
     STEP_PROJECT_ACTIVITY,
@@ -112,6 +113,7 @@ STEP_ORDER = (
 V3_STEP_ORDER = (
     STEP_TOKEN_USAGE,
     STEP_PROJECT_ACTIVITY,
+    STEP_PREFLIGHT,
     # Before the render that overlays its sidecar.
     STEP_TRANSLATE,
     STEP_RENDER_VIEWS,
@@ -401,6 +403,11 @@ def build_commands(ctx: FinalizeContext) -> list[tuple[str, list[str]]]:
     if ctx.report_contract_version != "3.0":
         return commands
     by_name = dict(commands)
+    by_name[STEP_PREFLIGHT] = [
+        *_validate_run_command(ctx, ctx.data_path),
+        "--section",
+        "preflight",
+    ]
     usage = by_name[STEP_TOKEN_USAGE]
     marker = usage.index("--substitute-data")
     by_name[STEP_TOKEN_USAGE] = usage[:marker]
@@ -585,6 +592,8 @@ def run_finalize(
 
     if only:
         selected = set(only)
+        if ctx.report_contract_version == "3.0" and STEP_TRANSLATE in selected:
+            selected.add(STEP_PREFLIGHT)
         contract_order = (
             V3_STEP_ORDER if ctx.report_contract_version == "3.0" else STEP_ORDER
         )
@@ -603,15 +612,20 @@ def run_finalize(
 
     first_failure = ""
     validated = False
+    preflight_failed = False
     for name, command in commands:
         # 실패한 시퀀스가 worktree 를 거두면 재작업 대상이 사라지고, 검증 안 된
         # 레코드를 기억하면 형제 task 가 그것을 결론으로 읽는다.
         if name in _SKIPPED_AFTER_FAILURE and first_failure:
             continue
+        if name == STEP_TRANSLATE and preflight_failed:
+            continue
         if before_step is not None:
             before_step(name)
         result = _run_finalize_step(ctx, name, command)
         steps.append(step_payload(name, command, result))
+        if name == STEP_PREFLIGHT:
+            preflight_failed = result.returncode != 0
         if result.returncode != 0 and not first_failure:
             first_failure = f"{name} failed with exit code {result.returncode}"
         if name == STEP_VALIDATE_RUN and result.returncode == 0:
@@ -1082,6 +1096,12 @@ def closeout_command(result: Mapping[str, Any]) -> dict[str, str]:
         if isinstance(step, Mapping)
     )
     if failed_validate:
+        recovery = promote_next_phase(result.get("nextRecommendedPhase"))
+        if recovery["status"] == STATUS_BLOCKED and recovery["phase"]:
+            return {
+                "command": f"/okstra-run → {recovery['phase']}",
+                "note": recovery["rationale"],
+            }
         return {
             "command": "/okstra-run",
             "note": "validate-run failed — name the blocking cause in one line, "

package/runtime/python/okstra_ctl/run.py

@@ -394,6 +394,16 @@ def _validate_approved_plan_conformance(path: Path) -> None:
     if loaded is None:
         return
     data_path, data = loaded
+    from .implementation_direction import stage_validation_executability_errors
+
+    command_errors = stage_validation_executability_errors(
+        data.get("implementationPlanning") or {}
+    )
+    if command_errors:
+        raise PrepareError(
+            f"approved plan command preflight failed: {data_path}\n"
+            + "\n".join(command_errors)
+        )
     bad = malformed_conformance_stages(data)
     if not bad:
         return

package/runtime/python/okstra_ctl/worker_prompt_contract.py

@@ -391,6 +391,19 @@ def complete_reverify_instruction(
         if not body.lstrip().startswith(("## ", "**")):
             body = "## Instructions\n\n" + body
         body = "\n".join(prefix) + "\n\n" + body
+    if task_type == "implementation-planning":
+        # 저장된 금지 목록은 감사 대조용으로 유지하되 폐기된 작성 의무를 정정한다.
+        body = body.rstrip() + (
+            "\n\n## Planning conformance ownership\n\n"
+            "Planning declares conformance commands and required dependencies; "
+            "implementation writes the QA scripts, manifest, and tsconfig. "
+            "Do not create those files during planning. Their absence before "
+            "implementation is not a planning defect by itself. This phase "
+            "ownership supersedes any legacy requirement in the frozen Forbidden "
+            "actions block saying this phase MUST write those artifacts. "
+            "Verify that the plan assigns their creation to implementation and "
+            "provides executable commands and required dependencies.\n"
+        )
     if _OUTPUT_CONTRACT_HEADING not in body:
         body = body.rstrip() + "\n\n" + output_contract.strip() + "\n"
     errors = _validate_output_contract_block(body)

package/runtime/python/okstra_ctl/worker_prompt_policy.py

@@ -121,6 +121,16 @@ def is_plan_verify_dispatch_kind(dispatch_kind: str) -> bool:
     return _numbered_round(dispatch_kind, PLAN_VERIFY_DISPATCH_KIND_PREFIX) is not None
 
 
+def is_plan_critic_verification(
+    *, task_type: str, assignment_ref: str, dispatch_kind: str,
+) -> bool:
+    return (
+        task_type == "implementation-planning"
+        and assignment_ref == "critic/scope"
+        and is_plan_verify_dispatch_kind(dispatch_kind)
+    )
+
+
 def verification_dispatch_round(dispatch_kind: str) -> int | None:
     """검증 kind 가 적는 라운드 번호. 번호 없는 kind(`critic-verify`)는 1,
     검증 kind 가 아니거나 번호가 깨졌으면 None.

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

@@ -28,19 +28,21 @@ Single read-side entry point for okstra runtime inspection plus the one status m
 
 ## Step 0: Preflight (shared)
 
+Resolve `<host-runtime>` from the launcher's `OKSTRA_RUNTIME_HOST` when present; otherwise use the registered host ID declared by the current harness (`codex` in Codex, `claude-code` in Claude Code). This follows `okstra-run`'s host selection rule. Do not infer the host from worker models, installed executables, or `PATH`. If neither source identifies the host, report that it is unknown instead of substituting Claude Code. Keep the same resolved host when retrying against another project directory.
+
 <!-- BEGIN FRAGMENT: bash-invocation-rule -->
 Run one Bash tool call, starting with the literal token `okstra` (never wrapped in `if`/`eval`/`export`/`$(...)`/`VAR=...`/`||`/`&&`/`npx` — a non-literal leading token defeats the `Bash(okstra:*)` permission match):
 <!-- END FRAGMENT: bash-invocation-rule -->
 
 ```bash
-okstra preflight --runtime claude-code
+okstra preflight --runtime <host-runtime>
 ```
 
 The project check only sees the cwd of the Bash call. When the user is asking about a project that is **not** the cwd (a sibling repo, a monorepo subdir, or a project named explicitly in the request), the bare form can report `Okstra preflight: failed` — a false negative, not a missing setup; do not hard-stop on it.
 
 Branch on the fixed first line:
 - `Okstra preflight: ready` → carry `Project root` as a literal string; it is the base for every sub-command step below.
-- `Okstra preflight: failed` → before concluding "no setup", ask whether the user pointed at a specific project directory. If they did, re-run targeting it: `okstra preflight --runtime claude-code --cwd <that-dir>` (`--cwd` is the sanctioned way to target a project — a leading `cd` would break the permission match). Only if this also fails do you show `Reason` and `Recovery`, then stop.
+- `Okstra preflight: failed` → before concluding "no setup", ask whether the user pointed at a specific project directory. If they did, re-run targeting it: `okstra preflight --runtime <host-runtime> --cwd <that-dir>` (`--cwd` is the sanctioned way to target a project — a leading `cd` would break the permission match). Only if this also fails do you show `Reason` and `Recovery`, then stop.
 
 <!-- BEGIN FRAGMENT: preflight-outdated-cli -->
 If the call fails with `unknown command: preflight`, the `okstra` binary on PATH predates this skill — tell the user to update it (`npm i -g okstra@latest`), then stop (`/okstra-setup` does not update the binary).

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

@@ -475,4 +475,4 @@ Do not read the wizard state file directly. `okstra wizard outcome` exposes any
 - Echo each captured answer (`result.echo`) on one short line so the user sees what was registered.
 - Name every file you show the user as a markdown link — `[<what it is>](<path>)`, with the path inside the parentheses. That is the only form the host renders as clickable; a path in backticks is text the user has to copy out. The `report-finalize` result's `reportPaths.markdown` carries the run's report, report record, and team state already in that form. Commands stay in backticks — a link is for a file, not for something to run.
 - Never invent identity; if a `text` prompt returns an empty answer where the wizard rejects it, the user must retry.
-- After Step 6, begin the lead workflow without re-summarizing the skill itself. For a single run, the end of Step 6 is the end of the run — but in an unattended chain where `orchestration.chainStages` has 2+ elements, repeat Step 6 per stage until Step 7's queue is empty (or it stops at a "not ready" / exception gate), then finish. When the lead (or this skill, after the lead returns) reports the run over, close with the user's next action — one command they can run now. A prohibition is not a next action. Take the pointer from the `report-finalize` result's top-level `nextRecommendedPhase` (`phase`, `status`, `rationale`; also on stderr as `next phase status:` / `next phase:` / `next phase rationale:`) — do not re-derive it from the report, and treat a `nextRecommendedPhaseError` as "pointer unreadable", said in one line before the `validate-run` branch. The same result also carries `nextCommand` — `{command, note}`, the table below already applied to this run. When `command` is non-empty it is the close; when it is empty the `note` says what to do with the `rationale` instead. After `implementation-planning`, open `blocks: approval` rows → `/okstra-user-response`. A recorded `accept-risk` / `select` / `answer` is not an open blocker. No open approval blocker → `/okstra-run` → `implementation` or `--approve` (do not start another planning run; do not say `/okstra-inspect`). For every other task type, quote the pointer's `rationale` in every branch — that sentence is the report's own reason and it is what the user asked to be analysed. Pointer `status: ready` → `/okstra-run` for that phase; `status: terminal` → say the task is finished, name any follow-up tasks this run registered, and do not say `/okstra-inspect`; `status: blocked` → issue the command the `rationale` calls for (`/okstra-user-response` for the `C-NNN` ids, `/okstra-run` for the phase it names); `validate-run` failed → one-line cause then `/okstra-run`; otherwise `/okstra-inspect status`.
+- After Step 6, begin the lead workflow without re-summarizing the skill itself. For a single run, the end of Step 6 is the end of the run — but in an unattended chain where `orchestration.chainStages` has 2+ elements, repeat Step 6 per stage until Step 7's queue is empty (or it stops at a "not ready" / exception gate), then finish. When the lead (or this skill, after the lead returns) reports the run over, close with the user's next action — one command they can run now. A prohibition is not a next action. Take the pointer from the `report-finalize` result's top-level `nextRecommendedPhase` (`phase`, `status`, `rationale`; also on stderr as `next phase status:` / `next phase:` / `next phase rationale:`) — do not re-derive it from the report, and treat a `nextRecommendedPhaseError` as "pointer unreadable", said in one line before the `validate-run` branch. The same result also carries `nextCommand` — `{command, note}`, the table below already applied to this run. When `command` is non-empty it is the close; when it is empty the `note` says what to do with the `rationale` instead. After `implementation-planning`, open `blocks: approval` rows → `/okstra-user-response`. A recorded `accept-risk` / `select` / `answer` is not an open blocker. No open approval blocker → `/okstra-run` → `implementation` or `--approve` (do not start another planning run; do not say `/okstra-inspect`). For every other task type, quote the pointer's `rationale` in every branch — that sentence is the report's own reason and it is what the user asked to be analysed. Pointer `status: ready` → `/okstra-run` for that phase; `status: terminal` → say the task is finished, name any follow-up tasks this run registered, and do not say `/okstra-inspect`; `status: blocked` → issue the command the `rationale` calls for (`/okstra-user-response` for the `C-NNN` ids, `/okstra-run` for the phase it names); `validate-run` failed → one-line cause then `/okstra-run` for the blocked pointer's `phase` when present, otherwise the current phase; otherwise `/okstra-inspect status`.

package/runtime/validators/forbidden_actions.py

@@ -108,11 +108,14 @@ def verifier_mutation_hits(command_log: str) -> list[tuple[str, str]]:
     로그는 자유 문자열이라 줄 단위로 본다 — 어느 명령이 문제인지 그대로 보고해야
     작성자가 고칠 자리를 안다. heredoc 본문은 기록되는 데이터이므로 걷어낸다.
     """
+    from okstra_ctl.qa_commands import find_unfrozen_installs
+
     hits: list[tuple[str, str]] = []
     for raw in strip_heredoc_bodies(command_log or "").splitlines():
         line = raw.strip()
         if not line or line.startswith("#"):
             continue
+        hits.extend((label, line) for label in find_unfrozen_installs(line))
         for label, pattern in (*_VERIFIER_MUTATION, *_VERIFIER_SOURCE_MUTATION):
             if pattern.search(line):
                 hits.append((label, line))

package/runtime/validators/validate-run.py

@@ -902,11 +902,22 @@ def update_workflow_metadata(
         if current_phase:
             phase_states[current_phase] = current_phase_state
         last_completed_phase = workflow.get("lastCompletedPhase", "")
+        recovery = next_phase.project(report_data or {})
+        recovery_phase = recovery["phase"]
+        can_backtrack = (
+            current_phase in PHASE_SEQUENCE
+            and recovery_phase in PHASE_SEQUENCE
+            and PHASE_SEQUENCE.index(recovery_phase)
+            < PHASE_SEQUENCE.index(current_phase)
+        )
         next_recommended_phase = next_phase.make(
+            phase=recovery_phase if can_backtrack else "",
             status=next_phase.STATUS_BLOCKED,
             rationale=_blocked_rationale(
-                current_phase,
-                inherited_pointer["rationale"],
+                recovery_phase if can_backtrack else current_phase,
+                recovery["rationale"]
+                if can_backtrack
+                else inherited_pointer["rationale"],
                 failures,
                 run_manifest_path=str(run_manifest.get("runManifestPath") or ""),
             ),
@@ -2197,6 +2208,12 @@ def _validate_planning_conformance_declared(
     if not isinstance(ip, dict):
         return
     _planning_conformance_declarations(ip.get("stages"), failures)
+    if ip.get("planningContract") != "selected-direction":
+        from okstra_ctl.implementation_direction import (
+            stage_validation_executability_errors,
+        )
+
+        failures.extend(stage_validation_executability_errors(ip))
     for conflict in exempt_stage_surface_conflicts(data, surface_patterns):
         failures.append(
             "conformance gate BLOCKING: stage "
@@ -9363,13 +9380,62 @@ def _data_schema_failures(data: dict) -> list[str]:
     ]
 
 
+def run_preflight(report_path: Path, run_manifest_path: Path) -> int:
+    """번역·표시·상태 갱신 전에 정본의 구조와 적합성만 검사한다."""
+    try:
+        data = load_json(_data_path_for(report_path))
+        manifest = load_json(run_manifest_path)
+        if not isinstance(data, dict) or not isinstance(manifest, dict):
+            raise TypeError("preflight requires report and run-manifest JSON objects")
+    except (OSError, ValueError, TypeError) as exc:
+        print(json.dumps({"ok": False, "failures": [str(exc)]}))
+        return 2
+    failures = _data_schema_failures(data)
+    task_type = manifest.get("taskType")
+    warnings: list[str] = []
+    if task_type in ("implementation", "final-verification"):
+        project_root = Path(
+            str(manifest.get("projectRoot") or run_manifest_path.parent)
+        )
+        warnings = _validate_conformance(
+            report_path,
+            failures,
+            surface_patterns=_project_surface_patterns(project_root),
+            approved_plan_path=_approved_plan_path_from_run_inputs(
+                run_manifest_path, failures
+            ),
+        )
+    elif task_type == "implementation-planning":
+        from okstra_ctl.implementation_direction import (
+            stage_validation_executability_errors,
+        )
+
+        failures.extend(
+            stage_validation_executability_errors(
+                data.get("implementationPlanning") or {}
+            )
+        )
+        _validate_planning_conformance_declared(report_path, failures)
+    print(
+        json.dumps(
+            {
+                "ok": not failures,
+                "failures": list(dict.fromkeys(failures)),
+                "warnings": warnings,
+            },
+            ensure_ascii=False,
+        )
+    )
+    return 2 if failures else 0
+
+
 def main() -> int:
     parser = argparse.ArgumentParser(
         description="Validate okstra run contract artifacts."
     )
     parser.add_argument(
         "--section",
-        choices=(SECTION_FULL, SECTION_PLAN_BODY),
+        choices=(SECTION_FULL, SECTION_PLAN_BODY, "preflight"),
         default=SECTION_FULL,
         help=(
             "Which contract surface to validate. `full` (default) validates the "
@@ -9415,6 +9481,13 @@ def main() -> int:
     )
     args = parser.parse_args()
 
+    if args.section == "preflight":
+        if not args.report or not args.run_manifest:
+            parser.error("--section preflight requires --report and --run-manifest")
+        return run_preflight(
+            Path(args.report).resolve(), Path(args.run_manifest).resolve()
+        )
+
     if args.section == SECTION_PLAN_BODY:
         if args.narrative and args.state and not args.report:
             return run_plan_body_inputs(

package/runtime/validators/validate_session_conformance.py

@@ -561,6 +561,11 @@ def _progress_line_from_event(event) -> tuple[str, str, str] | None:
         message = details.get("message")
         tail = f" {message}" if isinstance(message, str) and message else ""
         line = f"PROGRESS: {phase}{tail}"
+    worker = details.get("worker")
+    if isinstance(worker, str) and worker.strip():
+        from okstra_ctl.lead_progress import render_progress_line
+
+        line = render_progress_line(phase, [("worker", worker), ("detail", line)])
     return (event.timestamp, phase, line)