okstra 0.167.0 → 0.169.0

package/runtime/python/okstra_ctl/worker_dispatch.py

@@ -0,0 +1,104 @@
+"""Provider-neutral dispatcher for verified CLI-backed worker assignments."""
+from __future__ import annotations
+
+import argparse
+import json
+import sys
+from pathlib import Path
+from typing import Any, Mapping, Sequence
+
+from . import dispatch_core
+from .adapters.dispatch.cli_wrapper import CliWrapperDispatchPort
+from .application.dispatch_assignments import dispatch_assignments
+from .dispatch_state import DispatchError
+from .models import provider_wrappers
+from .ports.worker_dispatch import WorkerDispatchRequest
+
+
+SUPPORTED_CLI_WORKERS = provider_wrappers("analyser")
+
+
+def main(argv: Sequence[str] | None = None) -> int:
+    args = _parser().parse_args(argv)
+    try:
+        if args.jobs_file and args.workers:
+            raise DispatchError("--jobs-file and --workers cannot be combined")
+        request = _dispatch_request(args)
+        port = CliWrapperDispatchPort(
+            supported_worker_wrappers=SUPPORTED_CLI_WORKERS,
+            unsupported_worker_label="worker-dispatch",
+            required_lead_runtime=None,
+            cli_wrapper_assignments_only=True,
+            default_provider_by_worker_id={"report-writer": "claude"},
+        )
+        plan = dispatch_assignments(request, port)
+        backend_plan = plan.backend_plan
+        if backend_plan is None:
+            raise DispatchError("CLI wrapper dispatch did not produce a backend plan")
+        if args.dry_run:
+            _print_json(_backend_payload(backend_plan, dry_run=True))
+            return 0
+        code = dispatch_core.dispatch_cli_wrapper_plan(backend_plan)
+        _print_json({**_backend_payload(backend_plan, dry_run=False), "exitCode": code})
+        return code
+    except DispatchError as exc:
+        print(f"error: {exc}", file=sys.stderr)
+        return 2
+
+
+def _dispatch_request(args: argparse.Namespace) -> WorkerDispatchRequest:
+    return WorkerDispatchRequest(
+        project_root=Path(args.project_root),
+        run_manifest=Path(args.run_manifest),
+        workspace_root=Path(args.workspace_root),
+        okstra_bin=Path(args.okstra_bin) if args.okstra_bin else None,
+        requested_workers=tuple(_parse_workers(args.workers)),
+        idle_timeout_seconds=_parse_idle_timeout(args.idle_timeout_seconds),
+        dispatch_kind=args.dispatch_kind,
+        jobs_file=Path(args.jobs_file) if args.jobs_file else None,
+    )
+
+
+def _backend_payload(backend_plan, *, dry_run: bool) -> dict[str, Any]:
+    payload = backend_plan.to_payload(dry_run=dry_run)
+    payload.pop("workerDispatches", None)
+    return payload
+
+
+def _parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(
+        prog="okstra worker-dispatch",
+        description="Dispatch verified CLI-backed workers for a prepared run.",
+    )
+    parser.add_argument("--project-root", required=True)
+    parser.add_argument("--run-manifest", required=True)
+    parser.add_argument("--workspace-root", required=True)
+    parser.add_argument("--okstra-bin", default="")
+    parser.add_argument("--workers", default="")
+    parser.add_argument("--dry-run", action="store_true")
+    parser.add_argument("--idle-timeout-seconds", default="600")
+    parser.add_argument("--dispatch-kind", default="initial")
+    parser.add_argument("--jobs-file", default="")
+    return parser
+
+
+def _parse_workers(raw: str) -> list[str]:
+    return [item.strip() for item in raw.split(",") if item.strip()]
+
+
+def _parse_idle_timeout(raw: str) -> int:
+    try:
+        value = int(raw)
+    except ValueError as exc:
+        raise DispatchError("--idle-timeout-seconds must be an integer") from exc
+    if value < 0:
+        raise DispatchError("--idle-timeout-seconds must be non-negative")
+    return value
+
+
+def _print_json(payload: Mapping[str, Any]) -> None:
+    print(json.dumps(payload, ensure_ascii=False, indent=2))
+
+
+if __name__ == "__main__":
+    raise SystemExit(main(sys.argv[1:]))

package/runtime/python/okstra_ctl/worker_prompt_body.py

@@ -11,42 +11,25 @@ ANALYSIS_WORKER_LABELS = {
     "codex": "Codex worker",
     "antigravity": "Antigravity worker",
 }
-# An implementation audience shares this body but not its premise: the executor
-# owns the diff and the verifier grades it, so neither is producing one of the
-# independent findings that cross-verification triangulates.
-ROLE_STATEMENTS = {
-    "executor": (
-        "You are the Executor for this implementation stage — the only worker "
-        "permitted to mutate project files. Carry the stage end to end and "
-        "produce the worker result."
-    ),
-    "verifier": (
-        "You are a verifier for this implementation stage. Reproduce its QA "
-        "yourself, stay read-only on project files, and return an independent "
-        "verdict."
-    ),
-}
-
-
 def analysis_prompt_body(
     manifest: Mapping[str, Any],
     active_context: Mapping[str, Any],
     worker_id: str,
     model: str,
-    role: str,
     plan: PromptPlan,
 ) -> list[str]:
     """Render the provider-neutral body for an initial analysis audience."""
     label = ANALYSIS_WORKER_LABELS.get(worker_id, f"{worker_id} worker")
+    pane_role = {
+        "implementation-executor": "executor",
+        "implementation-verifier": "verifier",
+    }.get(plan.audience, "worker")
     return [
         f"**Model:** {label}, {model}",
-        f"**Pane role:** {role}",
+        f"**Pane role:** {pane_role}",
         "",
         f"# {label} Dispatch",
         "",
-        "## Role",
-        _role_statement(label, role),
-        "",
         "## Task",
         f"- Task key: `{_require_string(manifest, 'taskKey')}`",
         f"- Task type: `{_require_string(manifest, 'taskType')}`",
@@ -62,16 +45,6 @@ def analysis_prompt_body(
         "- Write the audit sidecar to Audit sidecar path as the preamble requires.",
         "- Cite evidence with file paths and line numbers whenever you make a claim.",
     ]
-
-
-def _role_statement(label: str, role: str) -> str:
-    return ROLE_STATEMENTS.get(
-        role,
-        f"You are the {label} for okstra cross-verification. "
-        "Produce an independent worker result.",
-    )
-
-
 def analysis_input_lines(
     manifest: Mapping[str, Any],
     active_context: Mapping[str, Any],
@@ -108,12 +81,6 @@ def report_writer_prompt_body(
         "",
         "# Report Writer Worker Dispatch",
         "",
-        "## Role",
-        (
-            "You are the Report writer worker. Author the final-report data.json, "
-            "its rendered Markdown sibling, and the worker-result pointer."
-        ),
-        "",
         "## Task",
         f"- Task key: `{_require_string(manifest, 'taskKey')}`",
         f"- Task type: `{_require_string(manifest, 'taskType')}`",

package/runtime/python/okstra_ctl/worker_prompt_contract.py

@@ -1,6 +1,7 @@
 """Compact initial final-verification prompt contract."""
 from __future__ import annotations
 
+import json
 import re
 from dataclasses import dataclass
 from pathlib import Path
@@ -81,6 +82,11 @@ _WORKER_SPECIFIC_PREFIXES = (
     "**File write mode:**",
     "**Model:**",
     "**Pane role:**",
+    "**Provider:**",
+    "**Model execution value:**",
+    "**Runner:**",
+    "**Host runtime:**",
+    "**Host model value:**",
 )
 _WORKER_LABEL_RE = re.compile(
     r"\b(?:Claude|Codex|Antigravity) worker\b",
@@ -95,6 +101,8 @@ class PromptRecord:
     path: Path
     expected_model: str | None = None
     expected_delivery_mode: str | None = None
+    metadata_path: Path | None = None
+    expected_duty_audience: str | None = None
 
 
 def validate_final_verification_initial_prompt(text: str) -> list[str]:
@@ -305,7 +313,8 @@ def _validate_model_header(text: str, expected_model: str | None) -> list[str]:
     """
     if expected_model is None:
         return []
-    model = _model_value(_header_values(text, MODEL_HEADER))
+    task_text = text.split("\n\n## Task Instructions\n\n", 1)[-1]
+    model = _model_value(_header_values(task_text, MODEL_HEADER))
     if model is None:
         return ["exactly one non-empty **Model:** <label>, <model> header is required"]
     if model != expected_model:
@@ -314,13 +323,34 @@ def _validate_model_header(text: str, expected_model: str | None) -> list[str]:
 
 
 def _validate_record_metadata(text: str, record: PromptRecord) -> list[str]:
-    return [
+    errors = [
         *_validate_delivery_mode(
             _header_values(text, PROMPT_DELIVERY_MODE_HEADER),
             record.expected_delivery_mode,
         ),
         *_validate_model_header(text, record.expected_model),
     ]
+    if record.expected_duty_audience is None:
+        return errors
+    if record.metadata_path is None:
+        return [*errors, "agent invocation metadata path is required"]
+    try:
+        metadata = json.loads(
+            record.metadata_path.read_text(encoding="utf-8")
+        )
+    except (OSError, UnicodeError, ValueError):
+        return [*errors, "agent invocation metadata is invalid"]
+    duty = metadata.get("dutyContract") if isinstance(metadata, dict) else None
+    if (
+        not isinstance(duty, dict)
+        or metadata.get("audience") != record.expected_duty_audience
+        or duty.get("id") != record.expected_duty_audience
+    ):
+        errors.append(
+            "agent invocation duty does not match expected audience: "
+            + record.expected_duty_audience
+        )
+    return errors
 
 
 def _validate_evidence_ledger_header(

package/runtime/python/okstra_ctl/worker_prompt_policy.py

@@ -4,6 +4,7 @@ from __future__ import annotations
 from dataclasses import dataclass
 from typing import Any, Literal, Mapping
 
+from .agent_invocation import AgentAudience
 from .analysis_inputs import ANALYSIS_TASK_TYPES
 
 
@@ -12,6 +13,7 @@ PromptAudience = Literal[
     "implementation-executor",
     "implementation-verifier",
     "report-writer",
+    "translator",
     "reverify",
     "lead-only",
 ]
@@ -68,6 +70,7 @@ WORKER_ERROR_CONTRACT_FILENAME = "worker-error-contract.md"
 @dataclass(frozen=True)
 class PromptPlan:
     audience: PromptAudience
+    duty_audience: AgentAudience
     equality_group: str | None
     packet_only: bool
     allow_coding_preflight: bool
@@ -90,6 +93,10 @@ def resolve_prompt_plan(
         return _plan("lead-only")
     if not worker_id.strip():
         raise ValueError("worker ID is required")
+    if worker_id == "translator" or dispatch_kind == "translator":
+        if worker_id != "translator" or dispatch_kind != "translator":
+            raise ValueError("translator worker and dispatch kind must match")
+        return _plan("translator", duty_audience="translator")
     if dispatch_kind.startswith("reverify-r"):
         return _plan("reverify")
     # A critic pass keeps the full analysis contract — worker anchor headers, the
@@ -99,6 +106,15 @@ def resolve_prompt_plan(
     # analysis prompts makes `validate_analysis_prompt_set` compare two prompts
     # that are *supposed* to differ and fail every critic-enabled run.
     analysis_equality_group = None if dispatch_kind == "critic" else "analysis-core"
+    analysis_duty: AgentAudience = (
+        "acceptance-critic"
+        if dispatch_kind == "critic" and task_type == "final-verification"
+        else "scope-critic"
+        if dispatch_kind == "critic"
+        else "acceptance-verifier"
+        if task_type == "final-verification"
+        else "analysis-worker"
+    )
     if task_type == "implementation" and not executor_worker_id:
         raise ValueError("implementation executor worker ID is required")
     if worker_id == "report-writer":
@@ -119,6 +135,7 @@ def resolve_prompt_plan(
     if task_type == "final-verification":
         return _plan(
             "analysis",
+            duty_audience=analysis_duty,
             equality_group=analysis_equality_group,
             packet_only=True,
             required_headers=FINAL_VERIFICATION_HEADERS,
@@ -128,11 +145,17 @@ def resolve_prompt_plan(
     if task_type == "improvement-discovery":
         return _plan(
             "analysis",
+            duty_audience=analysis_duty,
             equality_group=analysis_equality_group,
             packet_only=True,
             required_headers=(GRILLING_LOG_HEADER,),
         )
-    return _plan("analysis", equality_group=analysis_equality_group, packet_only=True)
+    return _plan(
+        "analysis",
+        duty_audience=analysis_duty,
+        equality_group=analysis_equality_group,
+        packet_only=True,
+    )
 
 
 def resolve_prompt_plan_for_manifest(
@@ -154,6 +177,7 @@ def resolve_prompt_plan_for_manifest(
 def _plan(
     audience: PromptAudience,
     *,
+    duty_audience: AgentAudience | None = None,
     equality_group: str | None = None,
     packet_only: bool = False,
     allow_coding_preflight: bool = False,
@@ -163,6 +187,7 @@ def _plan(
 ) -> PromptPlan:
     return PromptPlan(
         audience=audience,
+        duty_audience=duty_audience or _duty_audience(audience),
         equality_group=equality_group,
         packet_only=packet_only,
         allow_coding_preflight=allow_coding_preflight,
@@ -172,6 +197,18 @@ def _plan(
     )
 
 
+def _duty_audience(audience: PromptAudience) -> AgentAudience:
+    return {
+        "analysis": "analysis-worker",
+        "implementation-executor": "implementation-executor",
+        "implementation-verifier": "implementation-verifier",
+        "report-writer": "report-writer",
+        "translator": "translator",
+        "reverify": "reverification-worker",
+        "lead-only": "lead",
+    }[audience]
+
+
 def _worker_facing_headers(
     audience: PromptAudience,
     required_headers: tuple[str, ...],

package/runtime/skills/okstra-code-review/SKILL.md

@@ -107,9 +107,19 @@ okstra code-review target --branch <name> [--base <ref>] --project-root <project
 
 A large census is never truncated. Report the cell count and confirm before dispatching — a silent cut is a false "I looked at everything" signal.
 
-## Step 3 — Dispatch four reviewers in parallel
+## Step 3 — Materialize and dispatch four reviewers in parallel
 
-Send all four Agent calls in **one message**, `subagent_type: "general-purpose"`. Every brief carries:
+Every reviewer and later gap-fill is a separate auditable standalone invocation. Before dispatch, create
+`.okstra/agent-invocations/code-review/<invocation-id>.instructions.md` from that reviewer's brief, then run
+`okstra agent-prompt materialize` with `--purpose code-review`, `--audience code-reviewer`, and the canonical
+`.prompt.md` path beside it. Pass the current host runtime, selected provider, and `--model-role analyser`;
+the returned assignment is authoritative. Run `okstra agent-prompt verify` against the returned
+`metadataPath` before invoking any model.
+
+For a native host call, pass the verified prompt body and `hostModelValue`. For a deterministic provider
+process, run `okstra worker-dispatch` with the verified prompt path and `modelExecutionValue`; never
+substitute one model value for the other. Dispatch the four verified calls in parallel when the host supports
+it. Every brief carries:
 
 - the diff, plus the work directory path so the reviewer can read whole files for context
 - the project layout in one or two lines (where source, tests, and — if the routing found one — domain / ports / adapters live)
@@ -130,9 +140,18 @@ Axis scope — the `Reads` column names that group's rules, and a brief never re
 
 Say it plainly in every brief: **the census is law** — work the cells exactly as given, return a verdict for every one, never re-derive the list. There is no length budget; dropping a finding to stay brief is the failure this skill exists to prevent.
 
+Capture each raw model return under `.okstra/agent-invocations/code-review/.tmp/`. Publish it with
+`okstra agent-prompt materialize-result`, publish the immutable completion marker with
+`okstra agent-prompt complete`, then run `okstra agent-prompt verify-completion`. Parse only the
+`returnedBody` emitted by that last command. A model response without a verified completion is not a
+review result and cannot contribute a verdict.
+
 ## Step 3.5 — Audit the coverage
 
-Diff each reviewer's returned cells against the slice you handed it. Any cell without a verdict → re-dispatch **one gap-fill agent per axis**, carrying only the missing cells and the same brief. Repeat until every cell of every axis has a verdict.
+Diff each reviewer's verified `returnedBody` cells against the slice you handed it. Any cell without a verdict
+→ dispatch **one gap-fill invocation per axis**, carrying only the missing cells and the same brief. Each
+gap-fill uses a new invocation ID and repeats the full materialize → verify → dispatch → materialize-result →
+complete → verify-completion boundary from Step 3. Repeat until every cell of every axis has a verdict.
 
 A missing verdict is unfinished work, never an implicit `clean`. Do not start Step 4 while a single cell is unaccounted for.
 

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

@@ -258,7 +258,22 @@ okstra render-bundle \
   --<each-remaining-renderArgs-key> "<corresponding-value>"
 ```
 
-`render-bundle` auto-supplies `--workspace-root` and forces `--render-only`. Stdout prints `okstra task root:`, `okstra instruction-set:`, and the full rendered lead prompt. Parse the labelled lines for `TASK_ROOT` and `INSTRUCTION_SET_PATH`. Also watch for an optional `okstra concurrent-run stages:` label line — present only when a concurrent run is detected (see "Concurrent-run detection branch" below).
+`render-bundle` auto-supplies `--workspace-root` and forces `--render-only`. Stdout prints `okstra task root:`, `okstra instruction-set:`, `okstra run manifest:`, and the full rendered lead prompt. Parse the labelled lines for `TASK_ROOT`, `INSTRUCTION_SET_PATH`, and `RUN_MANIFEST_PATH`. Also watch for an optional `okstra concurrent-run stages:` label line — present only when a concurrent run is detected (see "Concurrent-run detection branch" below).
+
+Before acting as the lead, read `resources.leadPromptMetadataPath` from the run
+manifest and execute the host-native specification-link gate:
+
+```bash
+okstra agent-prompt record-dispatch \
+  --project-root <projectRoot> \
+  --run-manifest <RUN_MANIFEST_PATH> \
+  --metadata <projectRoot/resources.leadPromptMetadataPath> \
+  --enforcement-mode host-native-spec-link-gate
+```
+
+Do not continue from the rendered prompt if this command fails. This record
+associates the current-session lead with a verified invocation specification;
+it does not claim that the host exposed or attested the delivered prompt bytes.
 
 The python function underneath is mutex-protected (`~/.okstra/.locks/<task-key>.lock`), writes `run-context-*.json` + `run-inputs-*.json` + all manifests + discovery files, and registers the run in `~/.okstra/recent.jsonl` with status `prepared`.
 

package/runtime/skills/okstra-schedule-gen/SKILL.md

@@ -221,7 +221,16 @@ When you do skip, insert in the section's position exactly: `> _Gantt Chart skip
 ```
 
 3. **Run the deterministic gate first.** Execute `python3 ~/.okstra/lib/validators/validate-schedule.py <draft> --selection-json <selection>`. Do not dispatch the narrative verifier when this exits non-zero.
-4. **Run the independent LLM verifier second.** Only after the deterministic gate passes, dispatch an independent verifier subagent with the draft and selection JSON, but without the lead's reasoning. It returns `pass` plus concrete findings. Give it these checks:
+4. **Run the independent LLM verifier second.** Only after the deterministic gate passes, create
+   `.okstra/agent-invocations/schedule-verification/<invocation-id>.instructions.md` containing the draft,
+   selection JSON, and checks below, but none of the lead's reasoning. Materialize its sibling `.prompt.md`
+   with `okstra agent-prompt materialize`, `--purpose schedule-verification`,
+   `--audience schedule-verifier`, the current host runtime, the selected provider, and
+   `--model-role analyser`. Run `okstra agent-prompt verify` against the returned `metadataPath` before
+   dispatch. A native host call receives the verified prompt body and `hostModelValue`; a deterministic
+   provider process runs `okstra worker-dispatch` with the prompt path and `modelExecutionValue`. These
+   values are not interchangeable.
+   The verifier returns `pass` plus concrete findings. Give it these checks:
    - **Executable ordering** — stage sequence, `Depends On`, and Gantt bar positions tell the same story; nothing depends on something scheduled after it.
    - **Arithmetic** — the Work Breakdown `Days` column sums to the At a Glance `Days` cell and to the `Effort sum` line.
    - **Engineering-only scope** — no approval gate, permission check, stakeholder alignment or decision checklist.
@@ -231,6 +240,11 @@ When you do skip, insert in the section's position exactly: `> _Gantt Chart skip
    - **One language.** Table cells and stage titles follow the schedule's prose language; only headings and field labels stay English literals.
 
    These last three are the checks no validator can make. Do not accept a `pass` that skipped them.
+
+   Capture the raw return under `.okstra/agent-invocations/schedule-verification/.tmp/`, then run
+   `okstra agent-prompt materialize-result`, `okstra agent-prompt complete`, and
+   `okstra agent-prompt verify-completion` in that order. Parse only the `returnedBody` emitted by
+   `verify-completion`; an inline or unverified response cannot pass this gate.
 5. **Revise from the first gate after every change.** If either gate requests a change, the lead revises the same draft in place, then starts again at the deterministic `--selection-json` gate. Allow **Max 2 revise cycles** total across both gates.
 6. **Gate publication.** Only the same draft that passes both gates may be promoted in Step 6. If it still fails after the second revision, do not write the final file; remove the paired staging artifacts and report the residual findings in Korean.
 

package/runtime/templates/implementation-worker-preamble.md

@@ -2,16 +2,6 @@
 
 This file is shared by the `implementation-executor` and `implementation-verifier` audiences. Read it end-to-end, then read the role sidecar enumerated by the prompt. Before work, also read the shared file named by `**Worker Error Contract Path:**`; error rules live only there.
 
-## Operating standard (read before any output)
-
-Work like a senior engineer who owns this result, not a commentator on it.
-- Evidence over assertion — back every claim with a file:line, or mark it an explicit assumption. Never state the unverified as fact.
-- Read before you reason — read each required input end to end; when you lack basis, write "insufficient evidence" instead of filling the gap plausibly.
-- Shortest sound path — chase the most likely cause first; don't re-verify what is settled or pad with restatement.
-- Decide, don't survey — when options exist, give the trade-off and one recommendation, not an exhaustive list.
-- Fit what's here — match the surrounding code and prose; size the response to the request.
-- Hold your own line — reason from your independent angle; do not drift toward the other workers' likely answers or echo the user. Triangulation fails if your view isn't genuinely yours.
-
 ## Required reading
 
 - Read the implementation role sidecar named by the prompt end-to-end. The executor sidecar owns mutation behavior; the verifier sidecar owns read-only review behavior.

package/runtime/templates/report-writer-prompt-preamble.md

@@ -2,15 +2,6 @@
 
 This file is the audience-specific contract for `report-writer`. Read it end-to-end. Before work, also read the shared file named by `**Worker Error Contract Path:**`; error rules live only there.
 
-## Operating standard (read before any output)
-
-Work like a senior engineer who owns this result, not a commentator on it.
-- Evidence over assertion — back every claim with a file:line, or mark it an explicit assumption. Never state the unverified as fact.
-- Read before you reason — read each required input end to end; when you lack basis, write "insufficient evidence" instead of filling the gap plausibly.
-- Shortest sound path — chase the most likely cause first; don't re-verify what is settled or pad with restatement.
-- Decide, don't survey — when options exist, give the trade-off and one recommendation, not an exhaustive list.
-- Fit what's here — match the surrounding code and prose; size the response to the request.
-
 ## Required reading
 
 Read every input enumerated by the Phase 6 dispatch end-to-end: task/analysis inputs, worker results, convergence state, the instruction-set-local `final-report-template.md`, and the task-type excerpt `final-report-schema.json`. Do not pull the full repository template or schema when the scoped instruction-set copies are provided.

package/runtime/templates/reports/settings.template.json

@@ -49,17 +49,6 @@
         ]
       }
     ],
-    "PreToolUse": [
-      {
-        "matcher": "Write|Edit|MultiEdit|NotebookEdit",
-        "hooks": [
-          {
-            "type": "command",
-            "command": "bash \"$HOME/.okstra/prompts/coding-preflight/scripts/preedit-check.sh\""
-          }
-        ]
-      }
-    ],
     "SessionEnd": [
       {
         "hooks": [

package/runtime/templates/worker-prompt-preamble.md

@@ -2,16 +2,6 @@
 
 This file is the audience-specific contract for initial `analysis` workers. Read it end-to-end from the path selected by the dispatch prompt. Before doing work, also read the shared file named by `**Worker Error Contract Path:**`; that file is the only source for error-sidecar rules.
 
-## Operating standard (read before any output)
-
-Work like a senior engineer who owns this result, not a commentator on it.
-- Evidence over assertion — back every claim with a file:line, or mark it an explicit assumption. Never state the unverified as fact.
-- Read before you reason — read each required input end to end; when you lack basis, write "insufficient evidence" instead of filling the gap plausibly.
-- Shortest sound path — chase the most likely cause first; don't re-verify what is settled or pad with restatement.
-- Decide, don't survey — when options exist, give the trade-off and one recommendation, not an exhaustive list.
-- Fit what's here — match the surrounding code and prose; size the response to the request.
-- Hold your own line — reason from your independent angle; do not drift toward the other workers' likely answers or echo the user. Triangulation fails if your view isn't genuinely yours.
-
 ## Required reading
 
 Read `analysis-packet.md`, the primary compact input, end-to-end. Source files named as fallback/evidence paths are read only when a finding needs to verify a citation, fill a packet gap, or resolve ambiguity. Do not read `final-report-template.md` or `final-report-schema.json`; analysis workers produce findings, not the final report.

package/runtime/validators/lib/fixtures.sh

@@ -526,5 +526,98 @@ if lead_sid:
 write_json(team_state_path, team_state)
 write_json(run_manifest_path, run_manifest)
 write_json(task_manifest_path, task_manifest)
+
+# The synthetic fixture accepts lead and completed-worker results, so it must
+# create the same verified invocation records and result links as a real run.
+# Keep the deliberately omitted worker prompt absent: the first validator pass
+# still exercises the historical prompt-history failure before the helper
+# restores that file.
+if WORKSPACE_ROOT:
+    from okstra_ctl.agent_invocation import (
+        AgentInstruction,
+        AgentInstructionSource,
+        AgentInvocationRequest,
+        agent_model_assignment_from_payload,
+        prepare_agent_invocation,
+    )
+    from okstra_ctl.dispatch_state import (
+        link_agent_dispatch_result,
+        record_verified_agent_dispatch,
+    )
+
+    lead_record = record_verified_agent_dispatch(
+        project_root=project_root,
+        run_manifest_path=run_manifest_path,
+        metadata_path=project_root / run_manifest["leadPromptMetadataPath"],
+        enforcement_mode="host-native-spec-link-gate",
+    )
+    link_agent_dispatch_result(
+        project_root=project_root,
+        run_manifest_path=run_manifest_path,
+        dispatch_id=lead_record["dispatchId"],
+        result_path=report_path,
+    )
+
+    assignments = run_manifest["invocationAssignments"]
+    contract = run_manifest["agentContract"]
+    reservation_root = project_root / contract["invocationReservationRootPath"]
+    for worker in team_state.get("workers", []):
+        if not isinstance(worker, dict) or worker.get("status") != "completed":
+            continue
+        worker_id = str(worker.get("workerId") or "").strip()
+        prompt_relative = str(worker.get("promptPath") or "").strip()
+        result_relative = str(worker.get("resultPath") or "").strip()
+        if not worker_id or not prompt_relative or not result_relative:
+            continue
+        source_prompt = project_root / prompt_relative
+        if not source_prompt.is_file():
+            continue
+        assignment_ref = f"initial/{worker_id}"
+        invocation_id = f"validation-fixture-{worker_id}"
+        invocation_prompt = reservation_root / f"{invocation_id}.prompt.md"
+        prepared = prepare_agent_invocation(AgentInvocationRequest(
+            invocation_id=invocation_id,
+            worker_id=worker_id,
+            audience=(
+                "report-writer" if worker_id == "report-writer"
+                else "analysis-worker"
+            ),
+            assignment_ref=assignment_ref,
+            purpose=None,
+            assignment=agent_model_assignment_from_payload(
+                assignments[assignment_ref]
+            ),
+            instruction=AgentInstruction(
+                anchor_lines=(),
+                body=source_prompt.read_text(encoding="utf-8"),
+                source_paths=(
+                    AgentInstructionSource("project", prompt_relative),
+                ),
+            ),
+            project_root=project_root,
+            run_manifest_path=run_manifest_path,
+            duty_root=project_root / contract["dutyRootPath"],
+            prompt_path=invocation_prompt,
+            metadata_path=invocation_prompt.with_name(
+                invocation_prompt.name + ".meta.json"
+            ),
+            dispatch_kind="validation-fixture",
+        ))
+        dispatch = record_verified_agent_dispatch(
+            project_root=project_root,
+            run_manifest_path=run_manifest_path,
+            metadata_path=prepared.metadata_path,
+            enforcement_mode=(
+                "host-native-spec-link-gate"
+                if prepared.assignment.runner == "native-session"
+                else "core-pre-dispatch"
+            ),
+        )
+        link_agent_dispatch_result(
+            project_root=project_root,
+            run_manifest_path=run_manifest_path,
+            dispatch_id=dispatch["dispatchId"],
+            result_path=project_root / result_relative,
+        )
 PY
 }

package/runtime/validators/lib/validate-assets.sh

@@ -41,20 +41,12 @@ def check(source_path: Path, target_path: Path) -> None:
 
 # 1. Worker agent files: agents/workers/*-worker.md -> runtime/agents/workers/*-worker.md
 #
-# `_cli-wrapper-template.md` is a build-time render INPUT, not a shipped
-# artifact — tools/build.mjs renders it (with each *.params.json) into
-# codex-worker.md / antigravity-worker.md and excludes the template itself from the
-# runtime payload. Skip it here so parity is checked only on shipped files.
-# Keep this set in sync with TEMPLATE_INPUT_BASENAMES in tools/build.mjs.
-template_input_basenames = {"_cli-wrapper-template.md"}
 workers_source = agents_source_root / "workers"
 workers_target = runtime_root / "agents" / "workers"
 if not workers_source.is_dir():
     errors.append(f"missing agents/workers source directory: {workers_source}")
 else:
     for source_path in sorted(workers_source.glob("*.md")):
-        if source_path.name in template_input_basenames:
-            continue
         check(source_path, workers_target / source_path.name)
 
 # 2. Lead contract + internal lead resources: prompts/lead/* + prompts/coding-preflight/*