okstra 0.127.0 → 0.129.0

package/runtime/python/okstra_ctl/worker_prompt_contract.py

@@ -0,0 +1,316 @@
+"""Compact initial final-verification prompt contract."""
+from __future__ import annotations
+
+import re
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any, Mapping, Sequence
+
+from .worker_prompt_policy import PromptPlan, resolve_prompt_plan_for_manifest
+
+
+MAX_FINAL_VERIFICATION_DIRECTIVE_LINES = 40
+MAX_FINAL_VERIFICATION_BODY_LINES = 96
+
+_DIRECTIVE_HEADING = "## Run-specific directive"
+_WORKER_ERROR_CONTRACT_HEADER = "**Worker Error Contract Path:**"
+_PRIMARY_PACKET_RE = re.compile(
+    r"(?im)^-\s+Primary analysis packet:\s+`[^`\n]*analysis-packet\.md`\s*$"
+)
+_COPIED_SECTION_PATTERNS = (
+    ("Primary focus areas", re.compile(r"(?im)^(?:#{1,6}\s+|-\s+)Primary focus areas\b")),
+    (
+        "Required deliverable shape",
+        re.compile(r"(?im)^(?:#{1,6}\s+|-\s+)Required deliverable shape\b"),
+    ),
+    (
+        "Self-review pass",
+        re.compile(r"(?im)^(?:#{1,6}\s+|-\s+)Self-review pass\b"),
+    ),
+)
+_NON_BODY_PREFIXES = (
+    "**Project Root:**",
+    "**Prompt History Path:**",
+    "**Result Path:**",
+    "Assigned worker prompt history path:",
+    "**Worker Preamble Path:**",
+    "**Errors log path:**",
+    "**Errors sidecar path:**",
+    "**Read scope:**",
+    "**Worktree:**",
+    "**Verification scope:**",
+    "**Verification base ref:**",
+    "**Verification head ref:**",
+    "**Verification target path:**",
+    "**Verification target digest:**",
+)
+_REQUIRED_TARGET_PREFIXES = (
+    "**Worktree:**",
+    "**Verification scope:**",
+    "**Verification base ref:**",
+    "**Verification head ref:**",
+    "**Verification target path:**",
+    "**Verification target digest:**",
+)
+_WORKER_SPECIFIC_PREFIXES = (
+    "**Prompt History Path:**",
+    "**Result Path:**",
+    "Assigned worker prompt history path:",
+    "**Errors sidecar path:**",
+    "**Worker Result Path:**",
+    "**Model:**",
+    "**Pane role:**",
+)
+_WORKER_LABEL_RE = re.compile(
+    r"\b(?:Claude|Codex|Antigravity) worker\b",
+    re.IGNORECASE,
+)
+
+
+@dataclass(frozen=True)
+class PromptRecord:
+    worker_id: str
+    dispatch_kind: str
+    path: Path
+
+
+def validate_final_verification_initial_prompt(text: str) -> list[str]:
+    """Return deterministic compact-prompt contract violations."""
+    errors: list[str] = []
+    _reject_literal(
+        text,
+        "**Coding preflight pack:**",
+        "Coding preflight pack is forbidden for final-verification",
+        errors,
+    )
+    _reject_literal(
+        text,
+        "**Verification diff stat:**",
+        "inline Verification diff stat is forbidden; use verification-target.md",
+        errors,
+    )
+    _reject_literal(
+        text,
+        "## Source / fallback paths",
+        "Source / fallback paths is forbidden; use analysis-packet.md",
+        errors,
+    )
+    for label, pattern in _COPIED_SECTION_PATTERNS:
+        if pattern.search(text):
+            errors.append(f"copied {label} section is forbidden; use analysis-packet.md")
+    _validate_compact_target_identity(text, errors)
+    packet_count = len(_PRIMARY_PACKET_RE.findall(text))
+    if packet_count != 1:
+        errors.append(
+            "exactly one Primary analysis packet path is required "
+            f"(found {packet_count})"
+        )
+    directive_count = text.count(_DIRECTIVE_HEADING)
+    if directive_count > 1:
+        errors.append("at most one Run-specific directive section is allowed")
+    if directive_count == 1:
+        directive_lines = _directive_nonblank_lines(text)
+        if directive_lines > MAX_FINAL_VERIFICATION_DIRECTIVE_LINES:
+            errors.append(
+                "Run-specific directive exceeds "
+                f"{MAX_FINAL_VERIFICATION_DIRECTIVE_LINES} nonblank lines "
+                f"(found {directive_lines})"
+            )
+    body_lines = _body_nonblank_lines(text)
+    if body_lines > MAX_FINAL_VERIFICATION_BODY_LINES:
+        errors.append(
+            f"prompt body exceeds {MAX_FINAL_VERIFICATION_BODY_LINES} "
+            f"nonblank lines (found {body_lines})"
+        )
+    return errors
+
+
+def normalise_analysis_prompt(text: str) -> str:
+    """Remove only permitted worker identity, model, role, and path deltas."""
+    normalized: list[str] = []
+    for line in text.replace("\r\n", "\n").replace("\r", "\n").splitlines():
+        stripped = line.strip()
+        prefix = next(
+            (candidate for candidate in _WORKER_SPECIFIC_PREFIXES if stripped.startswith(candidate)),
+            "",
+        )
+        if prefix:
+            normalized.append(f"{prefix} <worker-specific>")
+            continue
+        normalized.append(_WORKER_LABEL_RE.sub("<analysis-worker>", line.rstrip()))
+    return "\n".join(normalized).strip() + "\n"
+
+
+def validate_analysis_prompt_set(prompts: Mapping[str, str]) -> list[str]:
+    """Require byte-identical normalized bodies for initial analysis workers."""
+    if len(prompts) < 2:
+        return []
+    normalized = {
+        worker_id: normalise_analysis_prompt(text)
+        for worker_id, text in sorted(prompts.items())
+    }
+    baseline_worker = next(iter(normalized))
+    baseline = normalized[baseline_worker]
+    different = [
+        worker_id
+        for worker_id, body in normalized.items()
+        if body != baseline
+    ]
+    if not different:
+        return []
+    workers = ", ".join([baseline_worker, *different])
+    return [f"normalized initial analysis prompts differ across workers: {workers}"]
+
+
+def validate_final_verification_prompt_paths(
+    prompt_paths: Mapping[str, Path],
+) -> list[str]:
+    """Validate persisted initial prompts and their normalized equality."""
+    records = [
+        PromptRecord(worker_id, "initial", path)
+        for worker_id, path in sorted(prompt_paths.items())
+    ]
+    return validate_initial_prompt_records(
+        manifest={"taskType": "final-verification"},
+        records=records,
+    )
+
+
+def validate_initial_prompt_records(
+    *,
+    manifest: Mapping[str, Any],
+    records: Sequence[PromptRecord],
+) -> list[str]:
+    """Validate prompt audiences and compare their normalized equality groups."""
+    errors: list[str] = []
+    equality_groups: dict[str, dict[str, str]] = {}
+    for record in records:
+        plan = _resolve_record_plan(manifest, record, errors)
+        if plan is None or plan.audience in {"lead-only", "reverify"}:
+            continue
+        try:
+            text = record.path.read_text(encoding="utf-8")
+        except OSError as exc:
+            errors.append(
+                f"{record.worker_id}: cannot read prompt {record.path}: {exc}"
+            )
+            continue
+        errors.extend(
+            f"{record.worker_id}: {error}"
+            for error in _validate_prompt_for_plan(text, plan, manifest)
+        )
+        if plan.equality_group:
+            group = equality_groups.setdefault(plan.equality_group, {})
+            group[record.worker_id] = text
+    for prompts in equality_groups.values():
+        errors.extend(validate_analysis_prompt_set(prompts))
+    return errors
+
+
+def _resolve_record_plan(
+    manifest: Mapping[str, Any],
+    record: PromptRecord,
+    errors: list[str],
+) -> PromptPlan | None:
+    try:
+        return resolve_prompt_plan_for_manifest(
+            manifest=manifest,
+            worker_id=record.worker_id,
+            dispatch_kind=record.dispatch_kind,
+        )
+    except ValueError as exc:
+        errors.append(f"{record.worker_id}: {exc}")
+        return None
+
+
+def _validate_prompt_for_plan(
+    text: str,
+    plan: PromptPlan,
+    manifest: Mapping[str, Any],
+) -> list[str]:
+    errors: list[str] = []
+    _require_non_empty_header(text, _WORKER_ERROR_CONTRACT_HEADER, errors)
+    if manifest.get("taskType") == "final-verification" and plan.audience == "analysis":
+        return [*errors, *validate_final_verification_initial_prompt(text)]
+    if not plan.allow_coding_preflight:
+        _reject_literal(
+            text,
+            "**Coding preflight pack:**",
+            "Coding preflight pack is forbidden for this prompt audience",
+            errors,
+        )
+    for prefix in plan.required_headers:
+        _require_non_empty_header(text, prefix, errors)
+    if plan.audience == "analysis":
+        packet_count = len(_PRIMARY_PACKET_RE.findall(text))
+        if packet_count != 1:
+            errors.append(
+                "exactly one Primary analysis packet path is required "
+                f"(found {packet_count})"
+            )
+    return errors
+
+
+def _require_non_empty_header(
+    text: str,
+    prefix: str,
+    errors: list[str],
+) -> None:
+    matches = [
+        line.strip()
+        for line in text.splitlines()
+        if line.strip().startswith(prefix)
+    ]
+    if len(matches) != 1 or not matches[0][len(prefix):].strip():
+        errors.append(f"exactly one non-empty {prefix} header is required")
+
+
+def _reject_literal(
+    text: str,
+    literal: str,
+    message: str,
+    errors: list[str],
+) -> None:
+    if literal in text:
+        errors.append(message)
+
+
+def _validate_compact_target_identity(text: str, errors: list[str]) -> None:
+    stripped_lines = [line.strip() for line in text.splitlines()]
+    for prefix in _REQUIRED_TARGET_PREFIXES:
+        matches = [line for line in stripped_lines if line.startswith(prefix)]
+        if len(matches) != 1 or not matches[0][len(prefix):].strip():
+            errors.append(f"exactly one non-empty {prefix} header is required")
+    scope_line = next(
+        (line for line in stripped_lines if line.startswith("**Verification scope:**")),
+        "",
+    )
+    scope = scope_line.removeprefix("**Verification scope:**").strip()
+    if scope and scope not in {"whole-task", "single-stage"}:
+        errors.append("Verification scope must be whole-task or single-stage")
+    digest_line = next(
+        (
+            line
+            for line in stripped_lines
+            if line.startswith("**Verification target digest:**")
+        ),
+        "",
+    )
+    digest = digest_line.removeprefix("**Verification target digest:**").strip()
+    if digest and not re.fullmatch(r"sha256:[0-9a-f]{64}", digest):
+        errors.append("Verification target digest must be sha256:<64 lowercase hex>")
+
+
+def _directive_nonblank_lines(text: str) -> int:
+    section = text.split(_DIRECTIVE_HEADING, 1)[1]
+    section = re.split(r"(?m)^##\s+", section, maxsplit=1)[0]
+    return sum(1 for line in section.splitlines() if line.strip())
+
+
+def _body_nonblank_lines(text: str) -> int:
+    return sum(
+        1
+        for line in text.splitlines()
+        if line.strip()
+        and not any(line.strip().startswith(prefix) for prefix in _NON_BODY_PREFIXES)
+    )

package/runtime/python/okstra_ctl/worker_prompt_headers.py

@@ -5,6 +5,12 @@ from pathlib import Path
 from typing import Any, Mapping
 
 from .paths import okstra_home
+from .worker_prompt_policy import (
+    PromptPlan,
+    WORKER_ERROR_CONTRACT_FILENAME,
+    WORKER_PREAMBLE_FILENAME_BY_AUDIENCE,
+    resolve_prompt_plan_for_manifest,
+)
 
 
 class WorkerPromptHeaderError(Exception):
@@ -36,29 +42,93 @@ def worker_prompt_headers(
     prompt_rel: str,
     result_rel: str,
     worker_id: str,
+    dispatch_kind: str,
     manifest: Mapping[str, Any],
     active_context: Mapping[str, Any],
 ) -> list[str]:
     """Render the team-contract worker prompt anchor headers."""
     prompt_path = _resolve_project_path(project_root, prompt_rel)
-    return [
+    errors_log_path = _errors_log_path(project_root, manifest, active_context)
+    errors_sidecar_path = _worker_errors_sidecar_path(
+        project_root,
+        manifest,
+        active_context,
+        worker_id,
+    )
+    plan = _prompt_plan(manifest, worker_id, dispatch_kind)
+    headers = [
         f"**Project Root:** {project_root}",
         f"**Prompt History Path:** {prompt_rel}",
         f"**Result Path:** {result_rel}",
         f"Assigned worker prompt history path: {prompt_path}",
-        f"**Worker Preamble Path:** {_worker_preamble_path()}",
-        f"**Coding preflight pack:** {_coding_preflight_pack_path(active_context)}",
-        f"**Errors log path:** {_errors_log_path(project_root, manifest, active_context)}",
-        (
-            f"**Errors sidecar path:** "
-            f"{_worker_errors_sidecar_path(project_root, manifest, active_context, worker_id)}"
-        ),
+        f"**Worker Preamble Path:** {_worker_preamble_path(plan, active_context)}",
+        f"**Worker Error Contract Path:** {_worker_error_contract_path(active_context)}",
+    ]
+    if plan.allow_coding_preflight:
+        headers.append(
+            f"**Coding preflight pack:** {_coding_preflight_pack_path(active_context)}"
+        )
+    headers.extend([
+        f"**Errors log path:** {errors_log_path}",
+        f"**Errors sidecar path:** {errors_sidecar_path}",
         READ_SCOPE_HEADER,
+    ])
+    if _string_value(manifest.get("taskType")) == "improvement-discovery":
+        headers.append(
+            f"**Phase 1.5 Grilling Log:** "
+            f"{_improvement_grilling_log_path(project_root, manifest)}"
+        )
+    if _string_value(manifest.get("taskType")) == "final-verification":
+        headers.extend(_final_verification_target_headers(active_context))
+    return headers
+
+
+def _final_verification_target_headers(
+    active_context: Mapping[str, Any],
+) -> list[str]:
+    target = active_context.get("verificationTarget")
+    if not isinstance(target, Mapping):
+        return []
+    fields = (
+        ("Worktree", "worktreePath"),
+        ("Verification scope", "scope"),
+        ("Verification base ref", "baseRef"),
+        ("Verification head ref", "headRef"),
+        ("Verification target path", "path"),
+        ("Verification target digest", "digest"),
+    )
+    return [
+        f"**{label}:** {_string_value(target.get(key))}"
+        for label, key in fields
+        if _string_value(target.get(key))
     ]
 
 
-def _worker_preamble_path() -> Path:
-    return okstra_home() / "templates" / "worker-prompt-preamble.md"
+def _worker_preamble_path(
+    plan: PromptPlan,
+    active_context: Mapping[str, Any],
+) -> Path:
+    runtime_resources = active_context.get("runtimeResources")
+    if isinstance(runtime_resources, Mapping):
+        paths = runtime_resources.get("workerPreamblePathByAudience")
+        if isinstance(paths, Mapping):
+            value = _string_value(paths.get(plan.audience))
+            if value:
+                return Path(value)
+    filename = WORKER_PREAMBLE_FILENAME_BY_AUDIENCE.get(
+        plan.audience,
+        WORKER_PREAMBLE_FILENAME_BY_AUDIENCE["analysis"],
+    )
+    return okstra_home() / "templates" / filename
+
+
+def _worker_error_contract_path(active_context: Mapping[str, Any]) -> Path:
+    runtime_resources = active_context.get("runtimeResources")
+    if isinstance(runtime_resources, Mapping):
+        value = _string_value(runtime_resources.get("workerErrorContractPath"))
+        if value:
+            return Path(value)
+    return okstra_home() / "templates" / WORKER_ERROR_CONTRACT_FILENAME
 
 
 def _coding_preflight_pack_path(active_context: Mapping[str, Any]) -> Path:
@@ -70,6 +140,35 @@ def _coding_preflight_pack_path(active_context: Mapping[str, Any]) -> Path:
     return okstra_home() / "prompts" / "coding-preflight"
 
 
+def _prompt_plan(
+    manifest: Mapping[str, Any],
+    worker_id: str,
+    dispatch_kind: str,
+) -> PromptPlan:
+    try:
+        return resolve_prompt_plan_for_manifest(
+            manifest=manifest,
+            worker_id=worker_id,
+            dispatch_kind=dispatch_kind,
+        )
+    except ValueError as exc:
+        raise WorkerPromptHeaderError(str(exc)) from exc
+
+
+def _improvement_grilling_log_path(
+    project_root: Path,
+    manifest: Mapping[str, Any],
+) -> Path:
+    path = (
+        _run_directory_path(project_root, manifest)
+        / "state"
+        / "phase-1.5-grilling.md"
+    )
+    if not path.is_file():
+        raise WorkerPromptHeaderError(f"Phase 1.5 grilling log not found: {path}")
+    return path
+
+
 def _errors_log_path(
     project_root: Path,
     manifest: Mapping[str, Any],

package/runtime/python/okstra_ctl/worker_prompt_policy.py

@@ -0,0 +1,158 @@
+"""Resolve worker prompt requirements from functional audience."""
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any, Literal, Mapping
+
+
+PromptAudience = Literal[
+    "analysis",
+    "implementation-executor",
+    "implementation-verifier",
+    "report-writer",
+    "reverify",
+    "lead-only",
+]
+
+FINAL_VERIFICATION_HEADERS = (
+    "**Worktree:**",
+    "**Verification scope:**",
+    "**Verification base ref:**",
+    "**Verification head ref:**",
+    "**Verification target path:**",
+    "**Verification target digest:**",
+)
+SUPPORTED_TASK_TYPES = frozenset({
+    "requirements-discovery",
+    "error-analysis",
+    "implementation-planning",
+    "improvement-discovery",
+    "implementation",
+    "final-verification",
+    "release-handoff",
+})
+WORKER_PREAMBLE_FILENAME_BY_AUDIENCE = {
+    "analysis": "worker-prompt-preamble.md",
+    "implementation-executor": "implementation-worker-preamble.md",
+    "implementation-verifier": "implementation-worker-preamble.md",
+    "report-writer": "report-writer-prompt-preamble.md",
+}
+WORKER_ERROR_CONTRACT_FILENAME = "worker-error-contract.md"
+
+
+@dataclass(frozen=True)
+class PromptPlan:
+    audience: PromptAudience
+    equality_group: str | None
+    packet_only: bool
+    allow_coding_preflight: bool
+    required_headers: tuple[str, ...]
+    max_body_lines: int | None
+    max_directive_lines: int | None
+
+
+def resolve_prompt_plan(
+    *,
+    task_type: str,
+    worker_id: str,
+    executor_worker_id: str | None,
+    dispatch_kind: str,
+) -> PromptPlan:
+    """Resolve prompt policy without consulting provider or model identity."""
+    if task_type not in SUPPORTED_TASK_TYPES:
+        raise ValueError(f"unsupported task type: {task_type}")
+    if task_type == "release-handoff":
+        return _plan("lead-only")
+    if not worker_id.strip():
+        raise ValueError("worker ID is required")
+    if dispatch_kind.startswith("reverify-r"):
+        return _plan("reverify")
+    if task_type == "implementation" and not executor_worker_id:
+        raise ValueError("implementation executor worker ID is required")
+    if worker_id == "report-writer":
+        return _plan("report-writer")
+    if task_type == "implementation" and worker_id == executor_worker_id:
+        return _plan(
+            "implementation-executor",
+            allow_coding_preflight=True,
+            required_headers=("**Worktree:**",),
+        )
+    if task_type == "implementation":
+        return _plan(
+            "implementation-verifier",
+            equality_group="implementation-verifier-core",
+            allow_coding_preflight=True,
+            required_headers=("**Worktree:**",),
+        )
+    if task_type == "final-verification":
+        return _plan(
+            "analysis",
+            equality_group="analysis-core",
+            packet_only=True,
+            required_headers=FINAL_VERIFICATION_HEADERS,
+            max_body_lines=96,
+            max_directive_lines=40,
+        )
+    if task_type == "improvement-discovery":
+        return _plan(
+            "analysis",
+            equality_group="analysis-core",
+            packet_only=True,
+            required_headers=("**Phase 1.5 Grilling Log:**",),
+        )
+    return _plan("analysis", equality_group="analysis-core", packet_only=True)
+
+
+def resolve_prompt_plan_for_manifest(
+    *,
+    manifest: Mapping[str, Any],
+    worker_id: str,
+    dispatch_kind: str,
+) -> PromptPlan:
+    """Resolve policy from canonical task and executor manifest fields."""
+    task_type = _required_string(manifest, "taskType")
+    return resolve_prompt_plan(
+        task_type=task_type,
+        worker_id=worker_id,
+        executor_worker_id=_executor_worker_id(manifest),
+        dispatch_kind=dispatch_kind,
+    )
+
+
+def _plan(
+    audience: PromptAudience,
+    *,
+    equality_group: str | None = None,
+    packet_only: bool = False,
+    allow_coding_preflight: bool = False,
+    required_headers: tuple[str, ...] = (),
+    max_body_lines: int | None = None,
+    max_directive_lines: int | None = None,
+) -> PromptPlan:
+    return PromptPlan(
+        audience=audience,
+        equality_group=equality_group,
+        packet_only=packet_only,
+        allow_coding_preflight=allow_coding_preflight,
+        required_headers=required_headers,
+        max_body_lines=max_body_lines,
+        max_directive_lines=max_directive_lines,
+    )
+
+
+def _executor_worker_id(manifest: Mapping[str, Any]) -> str | None:
+    team_contract = manifest.get("teamContract")
+    if not isinstance(team_contract, Mapping):
+        return None
+    executor = team_contract.get("executor")
+    if not isinstance(executor, Mapping):
+        return None
+    provider = executor.get("provider")
+    return provider.strip() if isinstance(provider, str) and provider.strip() else None
+
+
+def _required_string(payload: Mapping[str, Any], key: str) -> str:
+    value = payload.get(key)
+    if not isinstance(value, str) or not value.strip():
+        raise ValueError(f"missing required string field: {key}")
+    return value.strip()

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

@@ -0,0 +1,51 @@
+# Implementation Worker Prompt Preamble (canonical)
+
+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.
+- Read `overview.md` and `clean-code.md` under `**Coding preflight pack:**`, then follow every matching language, framework, and architecture route before editing or verification.
+- Read the approved implementation deliverable and any effective design-preparation block enumerated by the prompt.
+
+## Worktree and command discipline
+
+- `**Worktree:**` is the canonical checkout. Project commands run with that directory as cwd.
+- `.okstra/**` artifacts remain anchored at `**Project Root:**`; the worktree may not contain them.
+- Only the executor may mutate source files. Verifiers remain read-only except for okstra result/audit artifacts and project-declared QA commands.
+- Execute the role sidecar's pre-write, post-write, QA, and return gates without substituting analysis Sections 1–6 or report-authoring instructions.
+
+## Anchor headers
+
+Every initial implementation prompt begins with these generated common anchors in this exact order, before its implementation-specific body:
+
+1. `**Project Root:** <absolute-path>`
+2. `**Prompt History Path:** <project-relative-path>`
+3. `**Result Path:** <project-relative-path>`
+4. `Assigned worker prompt history path: <absolute-path>`
+5. `**Worker Preamble Path:** <absolute-path>`
+6. `**Worker Error Contract Path:** <absolute-path>`
+7. `**Coding preflight pack:** <absolute-path>`
+8. `**Errors log path:** <absolute-path>`
+9. `**Errors sidecar path:** <absolute-path>`
+10. `**Read scope:** <allowlist>`
+
+The implementation body additionally carries `**Worktree:**` and its role-sidecar inputs. Do not synthesize any missing path.
+
+## Return message to the lead
+
+Begin the inline return with the exact `**Model:** <Role>, <modelExecutionValue>` line from the prompt, followed by the role-sidecar status summary. Never invent or abbreviate the model.
+
+## Writing style
+
+Use concise evidence-backed prose. Keep identifiers, paths, symbols, model names, CLI flags, and status tokens in English. Translate meaning rather than dictionary words.

package/runtime/templates/operating-standard.md

@@ -1,10 +1,10 @@
 # Operating Standard (canonical)
 
 This file is the single source of truth for the operating standard injected into
-every okstra agent. The "Common core" block below is inlined verbatim into
-`templates/worker-prompt-preamble.md` (workers) and
-`prompts/lead/okstra-lead-contract.md` (lead). A unit test asserts both inlined
-copies match this core — update all three together.
+every okstra agent. The "Common core" block below is inlined verbatim into the
+three audience preambles under `templates/` and
+`prompts/lead/okstra-lead-contract.md` (lead). A unit test asserts every inlined
+copy matches this core — update all copies together.
 
 ## Common core