okstra 0.150.0 → 0.151.1

package/runtime/validators/validate-run.py

@@ -61,6 +61,10 @@ from okstra_ctl.mutation_probe import (  # noqa: E402
     classify_reason,
 )
 from okstra_ctl.self_mock_signals import selfmock_path_key  # noqa: E402
+from okstra_ctl.report_translation import (  # noqa: E402
+    HANGUL_PROSE_LIMIT,
+    hangul_share,
+)
 from okstra_ctl.stage_citations import cited_stage_numbers  # noqa: E402
 from okstra_ctl.workflow import DEFAULT_NEXT_PHASE, PHASE_SEQUENCE  # noqa: E402
 from okstra_ctl.md_table import (  # noqa: E402
@@ -99,6 +103,7 @@ from okstra_ctl.worker_prompt_contract import (  # noqa: E402
     PromptRecord,
     validate_initial_prompt_records,
 )
+from okstra_ctl.worker_prompt_headers import EVIDENCE_LEDGER_HEADER  # noqa: E402
 from validate_analysis_report import validate_analysis_report  # noqa: E402
 from okstra_ctl.convergence_engine import (  # noqa: E402
     grouped_input_digest,
@@ -2374,6 +2379,16 @@ def validate_report(
 _WORKER_RESULT_BASENAME_RE = re.compile(
     r"^(?P<worker>[a-z][a-z0-9-]*-worker)-(?P<task_type>[a-z][a-z-]*?)-(?P<seq>\d{3})\.md$"
 )
+_EVIDENCE_READ_RE = re.compile(
+    r"^- Evidence read: `(?P<path>[^`\n]+)`\s*$",
+    re.MULTILINE,
+)
+_FILE_LINE_CITATION_RE = re.compile(
+    r"`(?P<path>(?!https?://)[^`\n]+?):(?P<line>\d+(?:-\d+)?)`"
+)
+_EXTENSIONLESS_SOURCE_FILENAMES = frozenset(
+    {"Dockerfile", "Justfile", "Makefile", "Procfile", "Rakefile"}
+)
 
 _REPORT_BASENAME_SEQ_RE = re.compile(r"-(?P<seq>\d{3})(?:\.data)?\.(?:md|json)$")
 
@@ -2386,6 +2401,90 @@ def _report_run_seq(report_path: Path) -> str | None:
     return match.group("seq") if match else None
 
 
+def _cited_file_paths(content: str) -> set[str]:
+    paths: set[str] = set()
+    for match in _FILE_LINE_CITATION_RE.finditer(content):
+        path = match.group("path")
+        if _looks_like_file_path(path):
+            paths.add(path)
+    return paths
+
+
+def _looks_like_file_path(path: str) -> bool:
+    if (
+        not path
+        or path.startswith(("-", "$"))
+        or any(char.isspace() for char in path)
+    ):
+        return False
+    if re.fullmatch(r"[0-9a-fA-F]{7,64}", path):
+        return False
+    return (
+        "/" in path
+        or "." in Path(path).name
+        or Path(path).name in _EXTENSIONLESS_SOURCE_FILENAMES
+    )
+
+
+def _audit_evidence_read_paths(content: str) -> set[str]:
+    return {
+        match.group("path")
+        for match in _EVIDENCE_READ_RE.finditer(content)
+    }
+
+
+def _worker_prompt_path(
+    report_path: Path,
+    worker_role: str,
+    task_type: str,
+    seq: str,
+) -> Path:
+    return (
+        report_path.parent.parent
+        / "prompts"
+        / f"{worker_role}-prompt-{task_type}-{seq}.md"
+    )
+
+
+def _validate_worker_evidence_read_ledger(
+    *,
+    report_path: Path,
+    worker_role: str,
+    task_type: str,
+    seq: str,
+    result_name: str,
+    result_content: str,
+    audit_path: Path,
+    failures: list[str],
+) -> None:
+    if worker_role == "report-writer-worker":
+        return
+    prompt_path = _worker_prompt_path(report_path, worker_role, task_type, seq)
+    try:
+        prompt_content = prompt_path.read_text(encoding="utf-8")
+    except OSError:
+        return
+    if EVIDENCE_LEDGER_HEADER not in prompt_content.splitlines():
+        return
+    try:
+        audit_content = audit_path.read_text(encoding="utf-8")
+    except OSError as exc:
+        failures.append(
+            f"worker audit sidecar unreadable: {audit_path.name} ({exc})"
+        )
+        return
+
+    missing_paths = sorted(
+        _cited_file_paths(result_content) - _audit_evidence_read_paths(audit_content)
+    )
+    for missing_path in missing_paths:
+        failures.append(
+            f"worker `{worker_role}` result `{result_name}` cites "
+            f"`{missing_path}:line` without an Evidence read row for "
+            f"`{missing_path}` in `{audit_path.name}`"
+        )
+
+
 def validate_worker_results_audit(
     report_path: Path, task_type: str, failures: list[str]
 ) -> None:
@@ -2400,6 +2499,10 @@ def validate_worker_results_audit(
     2. The matching audit sidecar exists at
        `<worker>-audit-<task-type>-<seq>.md`. Missing sidecar means the
        worker silently skipped the reading-confirmation step.
+    3. For new prompts carrying the required-v1 marker, every canonical
+       backticked `path:line` citation has a matching Evidence read row in
+       that audit sidecar. Historical prompts without the marker retain the
+       existence-only contract.
 
     Scoped to this run's seq. `worker-results/` accumulates every run's
     artifacts, so scanning the whole directory judged a run by files it did
@@ -2461,6 +2564,18 @@ def validate_worker_results_audit(
                 f"Confirmation block (one short line per input file). Workers "
                 f"write this in the same step as the main worker-results file."
             )
+            continue
+
+        _validate_worker_evidence_read_ledger(
+            report_path=report_path,
+            worker_role=worker_role,
+            task_type=task_type,
+            seq=seq,
+            result_name=rel,
+            result_content=content,
+            audit_path=audit_path,
+            failures=failures,
+        )
 
 
 def validate_team_state_usage(team_state: dict, failures: list[str]) -> None:
@@ -6316,6 +6431,32 @@ def _validate_improvement_discovery(
             failures.append(f"improvement-discovery: {err}")
 
 
+def _validate_ssot_is_english(data: dict, failures: list[str]) -> None:
+    """Enforce: the final-report data.json is authored in English.
+
+    `meta.reportLanguage` names the language the human HTML renders in, and
+    Phase 7's translator serves it from a sidecar. The data.json itself is the
+    record every later phase, validator and agent reads, so a worker that
+    authors it in the reader's language instead splits the record — and does so
+    silently, because rendering, follow-up spawning and validation all succeed
+    on it.
+
+    `report-finalize` runs the same check as its first step, before anything
+    derives from the report. This is the second gate, for a report that reached
+    validation by some other path.
+    """
+    if not data:
+        return
+    share, length = hangul_share(data)
+    if length and share >= HANGUL_PROSE_LIMIT:
+        failures.append(
+            f"final-report data.json was authored in Korean ({share:.0%} of its "
+            f"prose, limit {HANGUL_PROSE_LIMIT:.0%}). The data.json is the "
+            "English SSOT; meta.reportLanguage selects the human HTML's "
+            "language and is served by the Phase 7 translator sidecar."
+        )
+
+
 def _validate_fix_cycle(run_manifest: dict, data: dict, failures: list[str]) -> None:
     """Enforce: when the run-manifest carries a fixCycleId, the final-report
     data.json MUST contain a fixCycle block whose ``cycle`` matches it.
@@ -7206,6 +7347,7 @@ def main() -> int:
         ),
     )
     validation_data = report_data if isinstance(report_data, Mapping) else {}
+    _validate_ssot_is_english(validation_data, failures)
     _validate_fix_cycle(run_manifest, validation_data, failures)
     validate_report(
         report_path,