okstra 0.143.0 → 0.145.0

package/runtime/validators/validate-run.py

@@ -7,6 +7,7 @@ import hashlib
 import importlib.util
 import json
 import os
+import posixpath
 import re
 import shlex
 import sys
@@ -20,6 +21,8 @@ from typing import Any
 # copy under ~/.okstra/lib. The manifests advertise the bare script path, so
 # it must self-bootstrap rather than rely on an inherited PYTHONPATH.
 _VALIDATORS_DIR = Path(__file__).resolve().parent
+if str(_VALIDATORS_DIR) not in sys.path:
+    sys.path.insert(0, str(_VALIDATORS_DIR))
 for _ssot_dir in (_VALIDATORS_DIR.parent / "scripts", _VALIDATORS_DIR.parent / "python"):
     if _ssot_dir.is_dir() and str(_ssot_dir) not in sys.path:
         sys.path.insert(0, str(_ssot_dir))
@@ -52,6 +55,11 @@ from okstra_ctl.build_tools import (  # noqa: E402
     command_invokes_build_tool,
     resolve_build_tool_tokens,
 )
+from okstra_ctl.mutation_probe import (  # noqa: E402
+    INTEGRITY_INSPECTION,
+    classify_reason,
+)
+from okstra_ctl.self_mock_signals import selfmock_path_key  # noqa: E402
 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
@@ -90,6 +98,7 @@ from okstra_ctl.worker_prompt_contract import (  # noqa: E402
     PromptRecord,
     validate_initial_prompt_records,
 )
+from validate_analysis_report import validate_analysis_report  # noqa: E402
 from okstra_ctl.convergence_engine import (  # noqa: E402
     grouped_input_digest,
     validate_final_state,
@@ -1679,6 +1688,475 @@ def _validate_conformance(
     return warnings
 
 
+_TEST_FILE_RE = re.compile(r"(\.spec\.|\.test\.|(^|/)test_|_test\.|(^|/)tests?/)")
+# okstra ships deliberately self-mocked samples as detector fixtures; gating
+# them would make okstra permanently fail its own gate when verifying itself.
+_SELFMOCK_FIXTURE_PREFIX = "tests/fixtures/self_mock/"
+
+
+_SELFMOCK_WAIVER_FILENAME = "self-mock-waivers.json"
+
+
+def _selfmock_source_is_canonical(source: object, canonical: Path) -> bool:
+    """True when `waiverSource` names the task's own waiver file.
+
+    Compared on the whole task-scoped path, never a tail: `/tmp/qa/` +
+    `self-mock-waivers.json` reproduces the canonical basename exactly, so a
+    short-suffix comparison would hand the redirect straight back. A LONGER
+    absolute prefix on the recorded source is accepted — macOS resolves a
+    `/var/...` task root to `/private/var/...` — because the task-scoped segments
+    are what carry the property, and false-blocking a legitimate run over a
+    realpath prefix costs more than that leniency does. The reverse (a source
+    SHORTER than the canonical path) is refused: a bare relative
+    `qa/self-mock-waivers.json` resolves against the worktree cwd, which is a
+    file the run can write.
+    """
+    if not isinstance(source, str) or not source.strip():
+        return False
+    key = selfmock_path_key(source)
+    want = selfmock_path_key(str(canonical))
+    return key == want or key.endswith("/" + want.lstrip("/"))
+
+
+def _selfmock_mutation_waiver_failure(mutation: object, sidecar: Path) -> str | None:
+    """The BLOCKING message for an invalid mutation waiver set, else None.
+
+    The exact mirror of `_selfmock_waiver_failure`, because gate B's escape hatch
+    carries the same risk gate A's does: it is the one input that can talk the
+    gate out of a finding about the code this run just wrote. So a waived
+    surviving mutant needs a `reason` that makes it reviewable and the
+    `acknowledgedBy` of the USER who accepted it, and the entry has to have been
+    read from the task's own `qa/self-mock-waivers.json` — the same file gate A
+    uses, so the user manages one place and the source stays singular.
+
+    `mutation_probe._apply_waivers` deliberately matches without adjudicating and
+    carries an unacknowledged entry into `waived`, so it surfaces here instead of
+    being silently dropped by the run that produced the finding.
+    """
+    if not isinstance(mutation, dict):
+        return None
+    waived = mutation.get("waived")
+    if not waived:
+        # Nothing was waived, so there is no acknowledgement to locate.
+        return None
+    problems: list[str] = []
+    if not _selfmock_source_is_canonical(
+        mutation.get("waiverSource"), sidecar.parent / _SELFMOCK_WAIVER_FILENAME
+    ):
+        problems.append(
+            f"mutation.waiverSource must be the task's own "
+            f"{sidecar.parent / _SELFMOCK_WAIVER_FILENAME}, got "
+            f"{mutation.get('waiverSource')!r}"
+        )
+    if not isinstance(waived, list):
+        problems.append("mutation.waived must be an array of waiver objects")
+    else:
+        for idx, entry in enumerate(waived):
+            if not isinstance(entry, dict):
+                problems.append(f"mutation.waived[{idx}] must be an object")
+                continue
+            for field in ("reason", "acknowledgedBy"):
+                value = entry.get(field)
+                if not isinstance(value, str) or not value.strip():
+                    problems.append(
+                        f"mutation.waived[{idx}].{field} must be a non-empty string"
+                    )
+    if not problems:
+        return None
+    return (
+        f"self-mock gate BLOCKING: {sidecar} carries invalid mutation waiver(s): "
+        + "; ".join(problems)
+        + ". A waived surviving mutant needs a `reason` and the `acknowledgedBy` of "
+        "the user who accepted it, read from the task's own "
+        "`qa/self-mock-waivers.json` — a verifier may report a suspected "
+        "false-positive mutant, but only the user waives one, and the "
+        "acknowledgement has to land in the task bundle where it can be reviewed. "
+        f"Add the entry to {sidecar.parent / _SELFMOCK_WAIVER_FILENAME} (keyed on "
+        "`file` + `line` + `mutant`, alongside any `signal` entries) and re-run the "
+        "detector with `--waivers` pointing there; never hand-edit the sidecar."
+    )
+
+
+def _selfmock_capped_note(mutation: dict, survived: list) -> str:
+    """Explain a survivor list the report cap trimmed, or `""` when it did not.
+
+    The cap makes an EMPTY `survived` reachable on a FAIL — every listed mutant
+    waived while the trimmed ones still stand — and a bare "[]" is
+    indistinguishable from a gate bug. Naming the counts and the way out keeps
+    this message actionable like every other block in this gate: the unlisted
+    mutants cannot be waived, so the only route through is killing them.
+    """
+    total = mutation.get("survivedTotal")
+    if not isinstance(total, int) or total <= len(survived):
+        return ""
+    waived = mutation.get("waived")
+    waived_count = len(waived) if isinstance(waived, list) else 0
+    unlisted = max(total - len(survived) - waived_count, 0)
+    return (
+        f" The report lists {len(survived)} of {total} surviving mutant(s) found on "
+        f"changed lines ({waived_count} waived); {unlisted} were trimmed by the "
+        "report cap and cannot be waived — the only way past them is to make the "
+        "tests kill them."
+    )
+
+
+def _selfmock_mutation_failure(mutation: object, sidecar: Path) -> str | None:
+    """Gate B's contribution to the fail-closed verdict, or `None` when it passes.
+
+    Three outcomes, and only one of them blocks:
+
+    - `FAIL` — a mutant of a changed line went undetected by the stage's own
+      suite, so nothing in it constrains that line. Blocks like a static hit.
+    - `unsupported(<reason>)` — splits by the reason's CLASS
+      (`mutation_probe.classify_reason`). A capability gap (no adapter, no tool
+      installed) or a language with nothing to verify is excluded from the
+      verdict and kept in the sidecar for audit: that is the normal case in a
+      repo without mutation tooling and must never block. An integrity or
+      inspection failure BLOCKS — a diff the verifier built wrong, or a report
+      the tool left unreadable, means nothing was checked, and passing it as
+      "excluded" is the fail-open this gate exists to prevent.
+    - `PASS` — nothing to add.
+
+    A block the gate cannot read is itself blocking: the detector writes this
+    structure unconditionally, so a missing or misshapen one means the sidecar
+    was hand-edited, and reading it as a pass is the fail-open this gate exists
+    to prevent.
+    """
+    if not isinstance(mutation, dict):
+        failure = "absent" if mutation is None else "not an object"
+        return (
+            f"self-mock gate BLOCKING: {sidecar} has a mutation block that is "
+            f"{failure}. The detector writes it on every run, so a sidecar "
+            "without one was hand-edited; re-run detect_self_mock.py."
+        )
+    status = mutation.get("status")
+    shape = _selfmock_mutation_shape_error(mutation, status)
+    if shape:
+        return (
+            f"self-mock gate BLOCKING: {sidecar} mutation block is malformed "
+            f"({shape}). Never hand-edit the sidecar — re-run "
+            "detect_self_mock.py so the probe writes it."
+        )
+    if status.startswith("unsupported("):
+        # Task 9 made every `unsupported` non-blocking so that a repo with no
+        # mutation tooling could never wedge. That is right for a boundary gate B
+        # declared in advance, and wrong for a fault in this run: a `--diff` the
+        # verifier built incorrectly, or a report the tool left unreadable, means
+        # the stage was never checked at all. The class comes from the one SSOT
+        # in `mutation_probe.py`, the same table the cross-language merge reads.
+        if classify_reason(status) != INTEGRITY_INSPECTION:
+            return None
+        return (
+            f"self-mock gate BLOCKING: {sidecar} mutation={status!r} — gate B could "
+            "not inspect this stage, so its PASS covers the static scan only. This "
+            "is a fault in the run's own inputs or output, not a missing tool. Fix "
+            "and re-run the detector: write the diff with "
+            "`git diff <base>...HEAD > <task_root>/qa/self-mock-<stage-name>.diff` "
+            "using the SAME `<base>` the `--changed-file` list came from "
+            "(`git diff --name-only <base>...HEAD`), pass every changed file — "
+            "production sources included — and confirm the mutation tool wrote a "
+            "readable report. Never hand-edit the sidecar."
+        )
+    if status != "FAIL":
+        return None
+    survived = mutation.get("survived") or []
+    listed = ", ".join(
+        f"{s.get('file')}:{s.get('line')} {s.get('mutant')} ({s.get('status')})"
+        for s in survived
+        if isinstance(s, dict)
+    )
+    return (
+        f"self-mock gate BLOCKING: {sidecar} mutation={status!r} "
+        f"tool={mutation.get('tool')!r}, undetected mutants on changed lines: "
+        f"[{listed}].{_selfmock_capped_note(mutation, survived)} A mutant that "
+        "survives means no test constrains that line — "
+        "`Survived` says the test ran the code and asserted nothing about it, "
+        "`NoCoverage` says no test reached the code at all. Assert on the real "
+        "behaviour instead of on the test's own wiring."
+    )
+
+
+def _selfmock_mutation_shape_error(mutation: dict, status: object) -> str | None:
+    """Name the first structural problem with a mutation block, or `None`."""
+    if not isinstance(status, str):
+        return "`status` is missing or not a string"
+    known = status in ("PASS", "FAIL") or (
+        status.startswith("unsupported(")
+        and status.endswith(")")
+        # An empty reason switches gate B off while naming nothing actionable.
+        and status[len("unsupported(") : -1].strip()
+    )
+    if not known:
+        return f"`status` {status!r} is outside PASS / FAIL / unsupported(<reason>)"
+    for field in ("survived", "waived"):
+        if not isinstance(mutation.get(field), list):
+            return f"`{field}` is missing or not a list"
+    if not isinstance(mutation.get("tool"), (str, type(None))):
+        return "`tool` is neither a string nor null"
+    return None
+
+
+def _selfmock_waiver_failure(static: dict, sidecar: Path) -> str | None:
+    """The BLOCKING message for an invalid self-mock waiver set, else None.
+
+    A waiver is the false-positive escape hatch, and it is the ONE place the gate
+    can be talked out of a finding — so it carries the same shape a conformance
+    waiver does (`okstra_ctl/conformance.py::_check_waiver`): a `reason` that
+    makes it reviewable and an `acknowledgedBy` that names the USER who accepted
+    it. Both are required precisely because the party the finding is about is the
+    agent: an entry with no acknowledgement is an agent excusing its own
+    self-mock, which is the review this gate exists to force. The detector
+    (`validators/detect_self_mock.py`) deliberately carries such an entry through
+    instead of dropping it, so it surfaces here rather than vanishing.
+
+    Requiring the fields is not enough on its own, because the run also chooses
+    WHERE they are read from: `--waivers /tmp/mine.json` with a forged
+    `acknowledgedBy` satisfies every field check and leaves nothing under
+    `.okstra/` to review. So a non-empty `waived` must also come from the task's
+    own `qa/self-mock-waivers.json`, which puts the acknowledgement in the task
+    bundle where it is auditable. An empty `waived` waived nothing, so the source
+    is not asked for.
+    """
+    waived = static.get("waived")
+    if waived is None:
+        return None
+    problems: list[str] = []
+    if waived and not _selfmock_source_is_canonical(
+        static.get("waiverSource"), sidecar.parent / _SELFMOCK_WAIVER_FILENAME
+    ):
+        problems.append(
+            f"staticDetect.waiverSource must be the task's own "
+            f"{sidecar.parent / _SELFMOCK_WAIVER_FILENAME}, got "
+            f"{static.get('waiverSource')!r}"
+        )
+    if not isinstance(waived, list):
+        problems.append("staticDetect.waived must be an array of waiver objects")
+    else:
+        for idx, entry in enumerate(waived):
+            if not isinstance(entry, dict):
+                problems.append(f"staticDetect.waived[{idx}] must be an object")
+                continue
+            for field in ("reason", "acknowledgedBy"):
+                value = entry.get(field)
+                if not isinstance(value, str) or not value.strip():
+                    problems.append(
+                        f"staticDetect.waived[{idx}].{field} must be a non-empty string"
+                    )
+    if not problems:
+        return None
+    return (
+        f"self-mock gate BLOCKING: {sidecar} carries invalid self-mock waiver(s): "
+        + "; ".join(problems)
+        + ". A waived detector hit needs a `reason` and the `acknowledgedBy` of the "
+        "user who accepted it, read from the task's own `qa/self-mock-waivers.json` "
+        "— a verifier may report a suspected false positive, but only the user "
+        "waives one, and the acknowledgement has to land in the task bundle where "
+        "it can be reviewed. Add the entry to "
+        f"{sidecar.parent / _SELFMOCK_WAIVER_FILENAME} and re-run the detector with "
+        "`--waivers` pointing there; never hand-edit the sidecar."
+    )
+
+
+def _selfmock_received_files(sidecar_data: dict) -> list[str] | None:
+    """Every `--test-file` the detector reports receiving; None if unreadable.
+
+    The union of `scannedFiles` and `skippedFiles`. Coverage is asked of what the
+    verifier PASSED, not of what the detector could read, because this gate's
+    trigger (`_TEST_FILE_RE`) is extension- and existence-agnostic while the
+    detector's scan set is neither: a Go test, a JSON fixture under `tests/`, and
+    a test file the stage deleted all trigger the gate and are all legitimately
+    skipped. Demanding they appear among the scanned ones would block those runs
+    with a recovery command that reproduces the block. A file the verifier never
+    passed is in neither list, so the fail-open hole stays closed.
+    """
+    received: list[str] = []
+    for field in ("scannedFiles", "skippedFiles"):
+        value = sidecar_data.get(field)
+        if not isinstance(value, list) or any(not isinstance(v, str) for v in value):
+            return None
+        received.extend(value)
+    return received
+
+
+def _selfmock_unreceived(received: list[str], changed: list[str]) -> list[str]:
+    """Return the changed test files the sidecar does NOT show the detector receiving.
+
+    An ABSOLUTE `--test-file` argument names the same file as the report's
+    repo-relative row, so it is matched on a whole-segment suffix — false-blocking
+    a legitimate run over path spelling would be worse than the hole this closes.
+    A relative entry must match exactly: in a monorepo,
+    `packages/web/src/cart/x.spec.ts` and a repo-root `src/cart/x.spec.ts` are
+    different files, and letting the tail overlap count would reopen the hole.
+    """
+    keys = {selfmock_path_key(entry) for entry in received}
+    absolute = {key for key in keys if posixpath.isabs(key)}
+    return [
+        path
+        for path in changed
+        if (key := selfmock_path_key(path)) not in keys
+        and not any(entry.endswith(f"/{key}") for entry in absolute)
+    ]
+
+
+def _validate_selfmock(report_path: Path, failures: list[str]) -> None:
+    """Fail-closed self-mock gate (implementation / final-verification).
+
+    Two gates are folded here. Gate A is the static SUT-stub scan; gate B is the
+    mutation probe, which blocks on `mutation.status == "FAIL"` and is excluded
+    from the verdict when it reports `unsupported(<reason>)` — a repo with no
+    mutation tool installed must not wedge. See `_selfmock_mutation_failure`.
+
+    A diff that changes test files without a detector sidecar means the detector
+    never ran, so absence blocks exactly like a FAIL verdict does. A PASS is not
+    taken on trust either: every changed test file must appear in the sidecar's
+    `scannedFiles` or its `skippedFiles`, because an empty hit list over an empty
+    or wrong input reads identically to a clean scan. The check is against that
+    union, not against `scannedFiles` alone — see `_selfmock_received_files`. A
+    diff whose test-file selection is empty — no test file at all, or only the
+    gate's own fixtures — is a vacuous PASS: changed test files are the trigger,
+    not the run.
+    Stage-isolated runs read their own `self-mock-stage-<N>.json`; whole-task runs
+    read the flat `self-mock.json`.
+
+    Only the implementation template renders the §5.7.3 diff summary
+    (`templates/reports/final-report.template.md:589`); a final-verification report
+    quotes the diff as a blockquote instead, so this gate is vacuous there by
+    design — self-mock is enforced at the implementation stage, and
+    final-verification is a read-only re-verify that adds no test files.
+    """
+    changed = _parse_diff_summary_files(report_path.read_text(encoding="utf-8"))
+    test_files = [
+        path
+        for path in changed
+        if _TEST_FILE_RE.search(path)
+        and _SELFMOCK_FIXTURE_PREFIX not in path.replace("\\", "/")
+    ]
+    if not test_files:
+        return
+    run_dir = report_path.parent.parent
+    stage_name = _stage_isolated_name(run_dir)
+    name = f"self-mock-{stage_name}.json" if stage_name else "self-mock.json"
+    sidecar = _task_root_from_run_dir(run_dir) / "qa" / name
+    if not sidecar.is_file():
+        failures.append(
+            f"self-mock gate BLOCKING: diff changes test file(s) {test_files} but "
+            f"the detector sidecar {sidecar} is absent. Run "
+            f"`python3 ~/.okstra/lib/validators/detect_self_mock.py "
+            f"--test-file <path>... --sidecar {sidecar}` over the changed test "
+            f"files and record the result."
+        )
+        return
+    try:
+        data = json.loads(sidecar.read_text(encoding="utf-8"))
+    except (OSError, json.JSONDecodeError) as exc:
+        failures.append(
+            f"self-mock gate BLOCKING: detector sidecar unreadable at {sidecar}: {exc}"
+        )
+        return
+    if not isinstance(data, dict):
+        failures.append(
+            f"self-mock gate BLOCKING: detector sidecar payload malformed at {sidecar}"
+        )
+        return
+    static = data.get("staticDetect")
+    static = static if isinstance(static, dict) else {}
+    # Checked ahead of the verdict: a waiver too weak to hold is BLOCKING whether
+    # or not anything survived it, and a PASS bought with one is the case the
+    # verdict check cannot see.
+    waiver_failure = _selfmock_waiver_failure(static, sidecar)
+    if waiver_failure:
+        failures.append(waiver_failure)
+        return
+    # Ahead of the `overall` check: a mutation FAIL also makes `overall` FAIL, and
+    # the generic branch below would report it as empty static hits — sending the
+    # reader to hunt for a stubbed subject that is not there.
+    # Ahead of the verdict, for the same reason gate A's waiver check is: a PASS
+    # bought with an unacknowledged waiver is exactly what the verdict cannot see.
+    mutation_waiver_failure = _selfmock_mutation_waiver_failure(
+        data.get("mutation"), sidecar
+    )
+    if mutation_waiver_failure:
+        failures.append(mutation_waiver_failure)
+        return
+    mutation_failure = _selfmock_mutation_failure(data.get("mutation"), sidecar)
+    if mutation_failure:
+        failures.append(mutation_failure)
+        return
+    if data.get("overall") != "PASS":
+        failures.append(
+            f"self-mock gate BLOCKING: {sidecar} overall={data.get('overall')!r}, "
+            f"staticDetect={static.get('status')!r}, hits={static.get('hits') or []}. "
+            "Stubbing the unit under test proves only the test's own wiring — "
+            "exercise the real method, or stub injected collaborators only."
+        )
+        return
+    received = _selfmock_received_files(data)
+    if received is None:
+        failures.append(
+            f"self-mock gate BLOCKING: {sidecar} carries no usable `scannedFiles` + "
+            "`skippedFiles` lists, so its PASS cannot be told apart from a detector "
+            "run over an empty or wrong input. Re-run "
+            f"`python3 ~/.okstra/lib/validators/detect_self_mock.py "
+            f"--test-file <path>... --sidecar {sidecar}` — the detector writes both "
+            "fields itself; never hand-edit the sidecar."
+        )
+        return
+    unreceived = _selfmock_unreceived(received, test_files)
+    if unreceived:
+        failures.append(
+            f"self-mock gate BLOCKING: changed test file(s) {unreceived} were never "
+            f"fed to the detector — {sidecar} recorded neither scanning nor skipping "
+            f"them (received={received}). A PASS over a narrower input says nothing "
+            "about the files this diff changed; re-run the detector with one "
+            "`--test-file` per changed test file. Pass every test file the diff "
+            "touched — the detector decides what it can scan, so a deleted file or "
+            "one in a language it has no signals for is recorded as skipped and "
+            "clears this check; filtering them out yourself is what trips it."
+        )
+        return
+    _check_selfmock_changed_files(data, changed, sidecar, failures)
+
+
+def _check_selfmock_changed_files(
+    data: dict, changed: list[str], sidecar: Path, failures: list[str]
+) -> None:
+    """Gate B's counterpart to the `scannedFiles` coverage check.
+
+    `--changed-file` is what the mutation adapters select their production
+    sources from. Omit it and every adapter gets an empty target set, which is
+    not a finding but reads like one had been looked for. Requiring the sidecar
+    to account for every file in the §5.7.3 diff summary keeps "gate B saw this
+    stage" apart from "gate B was handed nothing".
+
+    Coverage is asked of the WHOLE diff, not just its test files: the production
+    sources are precisely the part gate A never looks at.
+    """
+    declared = data.get("changedFiles")
+    if not isinstance(declared, list) or any(
+        not isinstance(entry, str) for entry in declared
+    ):
+        failures.append(
+            f"self-mock gate BLOCKING: {sidecar} carries no usable `changedFiles` "
+            "list, so the mutation gate cannot be told apart from one that was "
+            "handed nothing to mutate. Re-run "
+            f"`python3 ~/.okstra/lib/validators/detect_self_mock.py "
+            f"--changed-file <path>... --sidecar {sidecar}` passing every file the "
+            "diff changed; the detector writes the field itself."
+        )
+        return
+    unfed = _selfmock_unreceived(declared, changed)
+    if unfed:
+        failures.append(
+            f"self-mock gate BLOCKING: changed file(s) {unfed} were never fed to "
+            f"the mutation gate — {sidecar} records changedFiles={declared}. Each "
+            "adapter picks its production sources out of that set, so a file left "
+            "out is a file no mutant was ever generated for. Pass every path from "
+            "the §5.7.3 diff summary with `--changed-file`, production sources "
+            "included — filtering to the test files leaves gate B nothing to run "
+            "on and reports a pass it never earned."
+        )
+
+
 def _check_incremental_audit_block(
     report_path: Path,
     content: str,
@@ -2513,6 +2991,9 @@ def validate_final_report_data(
     failures: list[str],
     *,
     report_contracts: set[str] | None = None,
+    run_manifest: dict | None = None,
+    project_root: Path | None = None,
+    clarification_text: str = "",
 ) -> Mapping[str, Any] | None:
     """Validate the final-report data.json against the v1.0 schema.
 
@@ -2561,6 +3042,21 @@ def validate_final_report_data(
     errors = schema_validate(data, schema)
     for err in errors:
         failures.append(f"final-report data.json: {err}")
+    if errors:
+        return data
+
+    analysis_result = validate_analysis_report(
+        data=data,
+        report_path=report_path,
+        project_root=project_root or report_path.parent,
+        run_manifest=run_manifest or {},
+        clarification_text=clarification_text,
+    )
+    manifest_task_type = str((run_manifest or {}).get("taskType") or "")
+    task_type = manifest_task_type or str(
+        (data.get("header") or {}).get("taskType") or ""
+    )
+    failures.extend(f"{task_type}: {error}" for error in analysis_result.errors)
 
     _validate_rationale_evidence(data, failures)
     _validate_no_opaque_id_references(data, failures)
@@ -3642,6 +4138,22 @@ def _carry_in_source_for_run(run_manifest_path: Path) -> str:
     return raw.strip() if isinstance(raw, str) else ""
 
 
+def _clarification_text_for_run(
+    run_manifest_path: Path, report_path: Path
+) -> str:
+    """Read only the clarification input explicitly attached to this run."""
+    if not _carry_in_source_for_run(run_manifest_path):
+        return ""
+    task_root = _task_root_from_run_dir(report_path.parent.parent)
+    staged = task_root / "instruction-set" / "clarification-response.md"
+    if not staged.is_file():
+        return ""
+    try:
+        return staged.read_text(encoding="utf-8")
+    except OSError:
+        return ""
+
+
 def _validate_clarification_carry_in_recorded(
     data: dict,
     report_path: Path,
@@ -6591,6 +7103,11 @@ def main() -> int:
         report_path,
         failures,
         report_contracts=report_contracts,
+        run_manifest=run_manifest,
+        project_root=project_root,
+        clarification_text=_clarification_text_for_run(
+            run_manifest_path, report_path
+        ),
     )
     validation_data = report_data if isinstance(report_data, Mapping) else {}
     _validate_fix_cycle(run_manifest, validation_data, failures)
@@ -6641,6 +7158,7 @@ def main() -> int:
                 failures,
             ),
         )
+        _validate_selfmock(report_path, failures)
         for warning in conformance_warnings:
             print(f"validate-run: warning: {warning}", file=sys.stderr)
     if task_type in _BRIEF_DERIVED_PHASES: