okstra 0.169.0 → 0.169.1

package/runtime/python/okstra_ctl/worker_audit_ledger.py

@@ -11,6 +11,7 @@ so the rules live here rather than inside either one — the same split
 from __future__ import annotations
 
 import re
+from dataclasses import dataclass
 from pathlib import Path
 
 from okstra_ctl.worker_prompt_headers import EVIDENCE_LEDGER_HEADER
@@ -148,26 +149,75 @@ def _ledger_path_hint(cited_path: str, read_paths: set[str]) -> str:
     )
 
 
-def _result_files(run_dir: Path, task_type: str, seq: str | None, worker: str | None):
+@dataclass(frozen=True)
+class WorkerResultName:
+    """The three fields a canonical worker-result basename carries."""
+
+    worker_role: str
+    task_type: str
+    seq: str
+
+
+def parse_worker_result_name(basename: str) -> WorkerResultName | None:
+    """Split `<role>-worker-<task-type>-<seq>.md`, or None when non-canonical.
+
+    Callers that already hold one worker's result path — the dispatcher settling
+    that worker — read the audit check's arguments from here instead of
+    re-deriving them from the manifest. The `worker_role` this returns carries
+    the `-worker` suffix, which is what `check_worker_results_audit(worker=...)`
+    matches on; a bare provider id like `claude` matches nothing.
+    """
+    if "-audit-" in basename:
+        return None
+    match = _WORKER_RESULT_BASENAME_RE.match(basename)
+    if match is None:
+        return None
+    return WorkerResultName(
+        worker_role=match.group("worker"),
+        task_type=match.group("task_type"),
+        seq=match.group("seq"),
+    )
+
+
+def normalize_worker_filter(worker: str | None) -> str | None:
+    """Accept a worker id the way every other okstra surface spells it.
+
+    Result files are named `<role>-worker-...`, so the filter matches
+    `claude-worker`. But `claude` is what a worker is called everywhere a lead
+    reads or types one — `--workers claude,codex`, `workerId`, the roster in the
+    profile — so `--worker claude` was the natural thing to pass, and it matched
+    nothing. A zero-match filter produces no failures, which the CLI reports as
+    `{"ok": true}` with exit 0: indistinguishable from a real pass, at exactly
+    the point `team-contract` tells the lead to run this check before deciding
+    whether to re-dispatch. Accepting both spellings removes the trap rather
+    than documenting it.
+    """
+    if worker is None or worker.endswith("-worker"):
+        return worker
+    return f"{worker}-worker"
+
+
+def worker_result_files(
+    run_dir: Path, task_type: str, seq: str | None, worker: str | None
+):
     """Every worker-results file in *run_dir* this check owns, in name order."""
+    worker = normalize_worker_filter(worker)
     for path in sorted((run_dir / "worker-results").glob("*.md")):
-        if "-audit-" in path.name:
-            continue
-        match = _WORKER_RESULT_BASENAME_RE.match(path.name)
+        match = parse_worker_result_name(path.name)
         if match is None:
             # Files that don't match the canonical pattern (e.g. ad-hoc notes
             # left by the operator) are out of contract scope.
             continue
-        if match.group("task_type") != task_type:
+        if match.task_type != task_type:
             # Cross-phase artifacts shouldn't appear here; skip rather than
             # fail to keep the check focused on the current phase.
             continue
-        if seq is not None and match.group("seq") != seq:
+        if seq is not None and match.seq != seq:
             # A prior run's artifact. Its contract was judged when it ran.
             continue
-        if worker is not None and match.group("worker") != worker:
+        if worker is not None and match.worker_role != worker:
             continue
-        yield path, match.group("worker"), match.group("seq")
+        yield path, match.worker_role, match.seq
 
 
 def check_worker_results_audit(
@@ -196,7 +246,7 @@ def check_worker_results_audit(
         # `release-handoff`, which is single-lead). Nothing to enforce.
         return failures
 
-    for path, worker_role, result_seq in _result_files(run_dir, task_type, seq, worker):
+    for path, worker_role, result_seq in worker_result_files(run_dir, task_type, seq, worker):
         rel = path.name
         try:
             content = path.read_text()

package/runtime/python/okstra_ctl/worker_prompt_contract.py

@@ -230,7 +230,9 @@ def validate_reverify_prompt(
         read_scope_position < 0 or read_scope_position > boundary_position
     ):
         errors.append("phase boundary block must follow the reverify anchor headers")
-    first_heading = re.search(r"(?m)^##\s+", normalized)
+    first_heading = re.compile(r"(?m)^##\s+").search(
+        normalized, _task_instructions_offset(normalized)
+    )
     if (
         boundary_position >= 0
         and first_heading is not None
@@ -240,6 +242,27 @@ def validate_reverify_prompt(
     return errors
 
 
+def _task_instructions_offset(text: str) -> int:
+    """Where the lead's own instruction body starts.
+
+    The `agent-prompt` materializer composes every prompt as anchors →
+    `## Duty Contract` → `## Task Instructions`, and convergence's
+    materialization gate makes that the only body a reverify dispatch may send.
+    The duty section's heading is therefore always the document's first `##`,
+    which left the check below with no satisfiable input: the composer writes a
+    heading above anything the lead can author, so a whole-document "first
+    heading" test failed every materialized prompt regardless of where the lead
+    put the phase boundary.
+
+    These rules judge what the lead wrote, so they start where the lead's text
+    starts — the same region `_validate_model_header` already reads. A prompt
+    without the marker is judged whole.
+    """
+    marker = "\n\n## Task Instructions\n\n"
+    index = text.find(marker)
+    return 0 if index < 0 else index + len(marker)
+
+
 def _section_values(text: str, header: str) -> list[str]:
     lines = text.splitlines()
     values: list[str] = []

package/runtime/python/okstra_ctl/worker_prompt_headers.py

@@ -91,7 +91,7 @@ def worker_prompt_headers(
         project_root,
         audit_source_rel or result_rel,
     )
-    errors_log_path = _errors_log_path(project_root, manifest, active_context)
+    errors_log_path = resolve_errors_log_path(project_root, manifest, active_context)
     errors_sidecar_path = _worker_errors_sidecar_path(
         project_root,
         manifest,
@@ -224,7 +224,7 @@ def _improvement_grilling_log_path(
     return path
 
 
-def _errors_log_path(
+def resolve_errors_log_path(
     project_root: Path,
     manifest: Mapping[str, Any],
     active_context: Mapping[str, Any],