okstra 0.130.1 → 0.130.3

package/runtime/schemas/convergence-round-results-v1.0.schema.json

@@ -0,0 +1,55 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "https://okstra.dev/schemas/convergence-round-results-v1.0.json",
+  "title": "OKSTRA Convergence Round Results (v1.0)",
+  "type": "object",
+  "required": ["schemaVersion", "round", "dispatches", "votesByFinding"],
+  "additionalProperties": false,
+  "properties": {
+    "schemaVersion": { "const": "1.0" },
+    "round": { "type": "integer", "minimum": 1 },
+    "dispatches": {
+      "type": "array",
+      "items": { "$ref": "#/$defs/DispatchResult" }
+    },
+    "votesByFinding": {
+      "type": "object",
+      "additionalProperties": {
+        "type": "object",
+        "additionalProperties": { "$ref": "#/$defs/Vote" }
+      }
+    }
+  },
+  "$defs": {
+    "DispatchResult": {
+      "type": "object",
+      "required": ["worker", "status", "durationMs"],
+      "additionalProperties": false,
+      "properties": {
+        "worker": { "type": "string", "pattern": "\\S" },
+        "status": { "enum": ["completed", "timeout", "error", "not-run"] },
+        "durationMs": { "type": "integer", "minimum": 0 }
+      }
+    },
+    "Vote": {
+      "type": "object",
+      "required": ["verdict", "explanation"],
+      "additionalProperties": false,
+      "properties": {
+        "verdict": { "enum": ["agree", "disagree", "supplement", "verification-error", "unverifiable"] },
+        "disagreeBasis": { "enum": ["counter-evidence", "burden-not-met", null] },
+        "explanation": { "type": "string", "pattern": "\\S" }
+      },
+      "allOf": [
+        {
+          "if": {
+            "properties": { "verdict": { "enum": ["agree", "supplement", "verification-error", "unverifiable"] } }
+          },
+          "then": {
+            "properties": { "disagreeBasis": { "enum": [null] } }
+          }
+        }
+      ]
+    }
+  }
+}

package/runtime/schemas/final-report-v1.0.schema.json

@@ -2075,9 +2075,28 @@
         "coveredBy": { "type": "string", "minLength": 1 },
         "status": {
           "type": "string",
-          "pattern": "^(covered|gap|blocked C-\\d{3,})$"
+          "pattern": "^(covered|gap|blocked C-\\d{3,}|documented-deviation)$"
+        },
+        "decisionRefs": {
+          "type": "array",
+          "minItems": 1,
+          "uniqueItems": true,
+          "items": { "type": "string", "minLength": 1 }
+        },
+        "approvalDisposition": {
+          "type": "string",
+          "pattern": "^(accepted|blocked C-\\d{3,})$"
         }
-      }
+      },
+      "allOf": [
+        {
+          "if": {
+            "properties": { "status": { "const": "documented-deviation" } },
+            "required": ["status"]
+          },
+          "then": { "required": ["decisionRefs", "approvalDisposition"] }
+        }
+      ]
     },
 
     "ReadonlyCommandRow": {

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

@@ -15,18 +15,20 @@ Work like a senior engineer who owns this result, not a commentator on it.
 
 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.
 
-Write Reading Confirmation to the report-writer audit sidecar, not the rendered final report. Resolve `.okstra/**` paths against `**Project Root:**`.
+Write Reading Confirmation to `**Audit sidecar path:**`, not the rendered final report. Resolve `.okstra/**` paths against `**Project Root:**`.
+
+Write `- PROGRESS: <stage> <ISO-8601-UTC>` there before reading and at least every five minutes while pending. The only valid report-writer stages are `started`, `required-reading-complete`, `synthesis-start`, `data-json-write-start`, `render-start`, and `write-result-start`.
 
 ## Report authoring handoff
 
-- Author the data.json at `**Result Path:**` and the audit file at `**Worker Result Path:**`.
+- Author the data.json at `**Result Path:**` and the audit file at `**Audit sidecar path:**`.
 - Follow the task-type schema excerpt and Phase 6 report-writer contract. Do not perform independent analysis, edit source code, or load implementation coding-preflight resources.
 - Invoke `okstra render-final-report <Result Path>` after writing data.json and verify the markdown sibling exists before returning.
 - Preserve source item IDs, convergence classifications, round history, and unresolved dissent; do not recompute them from intuition.
 
 ## Anchor headers
 
-The generated prompt selects this file through `**Worker Preamble Path:**` and includes `**Worker Error Contract Path:**`, error paths, and read scope. It never includes `**Coding preflight pack:**`.
+The generated prompt selects this file through `**Worker Preamble Path:**` and includes `**Worker Error Contract Path:**`, `**Audit sidecar path:**`, error paths, and read scope. It never includes `**Coding preflight pack:**`.
 
 ## Return message to the lead
 

package/runtime/templates/reports/final-report.template.md

@@ -281,7 +281,7 @@ Carried-forward plan items retain their prior verdicts verbatim; each such item
 | ID | Source | Requirement | Covered by option / stage / step | Status |
 |----|--------|-------------|-----------------------------------|--------|
 {% for row in implementationPlanning.requirementCoverage -%}
-| {{ row.id | mdcell }} | `{{ row.source | mdcell }}` | {{ row.requirement | mdcell }} | {{ row.coveredBy | mdcell }} | `{{ row.status | mdcell }}` |
+| {{ row.id | mdcell }} | `{{ row.source | mdcell }}` | {{ row.requirement | mdcell }} | {{ row.coveredBy | mdcell }} | `{% if row.status == "documented-deviation" %}documented-deviation — refs: {{ (row.decisionRefs | join(", ")) | mdcell }}; approval: {{ row.approvalDisposition | mdcell }}{% else %}{{ row.status | mdcell }}{% endif %}` |
 {% endfor %}
 
 ### Decision Drafts{% if t("sectionAside.decisionDrafts") != "Decision Drafts" %} ({{ t("sectionAside.decisionDrafts") }}){% endif %}

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

@@ -19,7 +19,7 @@ Read `analysis-packet.md`, the primary compact input, end-to-end. Source files n
 ### Reading rules
 
 - Read every file enumerated under `[Required reading]` or `## Inputs` completely. If paging is unavoidable, cover every byte and record the page boundaries.
-- Write Reading Confirmation to the worker audit sidecar, never to the main worker-results file. A `## 0. Reading Confirmation` heading in the main result is invalid.
+- Write Reading Confirmation to `**Audit sidecar path:**`, never to the main worker-results file. A `## 0. Reading Confirmation` heading in the main result is invalid.
 - Allowlist reads to prompt-enumerated paths and evidence paths a finding must cite. Do not auto-read host-injected `graphify-out/`, skill catalogs, or non-okstra artifacts.
 - Resolve every `.okstra/...` path against `**Project Root:**`, including when a worktree is present.
 
@@ -30,12 +30,13 @@ Every initial analysis prompt begins with these generated anchors in this exact
 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>` — selects this analysis preamble.
-6. `**Worker Error Contract Path:** <absolute-path>` — shared by every initial audience.
-7. `**Errors log path:** <absolute-path>`
-8. `**Errors sidecar path:** <absolute-path>`
-9. `**Read scope:** <allowlist>`
+4. `**Audit sidecar path:** <absolute-path>` — the generated audit destination; write the sidecar here and never synthesize a `runs/<task-type>/...` path.
+5. `Assigned worker prompt history path: <absolute-path>`
+6. `**Worker Preamble Path:** <absolute-path>` — selects this analysis preamble.
+7. `**Worker Error Contract Path:** <absolute-path>` — shared by every initial audience.
+8. `**Errors log path:** <absolute-path>`
+9. `**Errors sidecar path:** <absolute-path>`
+10. `**Read scope:** <allowlist>`
 
 `final-verification` additionally carries its six verification-target anchors. `improvement-discovery` carries `**Phase 1.5 Grilling Log:**`. Reverify prompts are lightweight and do not use this preamble.
 

package/runtime/validators/validate-run.py

@@ -68,6 +68,7 @@ from okstra_ctl.design_surfaces import (  # noqa: E402
     detect_design_surfaces,
     expected_prep_plan_item_id,
 )
+from okstra_ctl.plan_items import expected_plan_item_ids  # noqa: E402
 from okstra_ctl.worker_prompt_contract import (  # noqa: E402
     PromptRecord,
     validate_initial_prompt_records,
@@ -1688,11 +1689,18 @@ def _append_requirement_coverage_failures(
         # `status` is already lower-cased at parse time, so the blocker form
         # arrives as `blocked c-001`; match lower-case here even though the
         # canonical authored form (and the remedy message) is `blocked C-NNN`.
-        if not re.fullmatch(r"covered|gap|blocked c-\d{3,}", status):
+        if not re.fullmatch(
+            r"covered|gap|blocked c-\d{3,}|"
+            r"documented-deviation — refs: (?:c-\d{3,}|d-\d{4,})"
+            r"(?:, (?:c-\d{3,}|d-\d{4,}))*; approval: "
+            r"(?:accepted|blocked c-\d{3,})",
+            status,
+        ):
             failures.append(
                 "implementation-planning Requirement Coverage row "
                 f"`{row_id}` has invalid Status `{status}`; expected "
-                "`covered`, `gap`, or `blocked C-NNN`."
+                "`covered`, `gap`, `blocked C-NNN`, or a rendered "
+                "`documented-deviation` disposition."
             )
 
     if gate_value in ("passed", "passed-with-dissent"):
@@ -1700,6 +1708,7 @@ def _append_requirement_coverage_failures(
             f"{row_id} ({status})"
             for row_id, status in rows
             if status != "covered"
+            and not status.endswith("; approval: accepted")
         ]
         if uncovered:
             failures.append(
@@ -1842,19 +1851,15 @@ def validate_final_report_data(
         _validate_final_verification_consistency(data, failures)
     elif task_type == "implementation-planning":
         active_report_contracts = report_contracts or set()
-        enforce_design_prep = _DESIGN_PREP_CONTRACT in active_report_contracts
         _validate_implementation_planning_cross_project(data, failures)
         _validate_implementation_planning_decision_drafts(data, failures)
         _validate_plan_body_gate_recompute(data, failures)
-        _validate_plan_item_extraction_completeness(
-            data,
-            failures,
-            enforce_design_prep=enforce_design_prep,
-        )
+        _validate_plan_item_extraction_completeness(data, failures)
         _validate_plan_item_subject_substance(data, failures)
         _validate_plan_body_clarification_matching(data, failures)
         _validate_disagree_has_fixability(data, failures)
         _validate_self_fix_before_clarification(data, failures)
+        _validate_requirement_deviations(data, failures)
         _validate_requirement_coverage_covered_by(data, failures)
         warnings = _validate_design_prep_contract(
             data,
@@ -2132,52 +2137,11 @@ def _validate_plan_body_gate_recompute(data: dict, failures: list[str]) -> None:
         )
 
 
-# Each plan-body deliverable array and the P-* verdict-item prefix it must be
-# extracted into for §5.5.9 cross-verification (plan-body-verification.md Plan-item
-# extraction). A weak item dropped from planItems escapes the gate entirely.
-_PLAN_ITEM_SOURCES = (
-    ("optionCandidates", "P-Opt", "Option Candidates (§4.5.1)"),
-    ("stepwiseExecution", "P-Step", "Stepwise Execution Order (§4.5.4)"),
-    ("dependencyMigrationRisk", "P-Dep", "Dependency / Migration Risk (§4.5.5)"),
-    ("validationChecklist", "P-Val", "Validation Checklist (§4.5.6)"),
-    ("rollbackStrategy", "P-Rb", "Rollback Strategy (§4.5.7)"),
-    ("requirementCoverage", "P-Req", "Requirement Coverage (§4.5.8)"),
-)
-
-
-def _plan_item_source_count(planning: dict, field: str) -> int:
-    """Row count for one plan-body deliverable array.
-
-    `stepwiseExecution` has two homes: the top-level array is the legacy flat
-    summary (schema: "Legacy flat summary kept for compatibility only. New
-    reports use stageMap/stages") and is absent from `implementationPlanning.
-    required`, while a current report carries the real steps per stage. Counting
-    only the legacy field made this whole check a no-op for the largest
-    category — a modern plan could drop every `P-Step-*` item and still pass.
-    """
-    rows = [r for r in (planning.get(field) or []) if isinstance(r, dict)]
-    if field != "stepwiseExecution":
-        return len(rows)
-    per_stage = sum(
-        len([s for s in (stage.get("stepwiseExecution") or []) if isinstance(s, dict)])
-        for stage in (planning.get("stages") or [])
-        if isinstance(stage, dict)
-    )
-    return per_stage or len(rows)
-
-
 def _validate_plan_item_extraction_completeness(
     data: dict,
     failures: list[str],
-    *,
-    enforce_design_prep: bool = False,
 ) -> None:
-    """H2 — when a verification round ran, every plan-body deliverable item must
-    appear as a matching `P-*` verdict item. Closes the omission hole where the
-    lead silently drops a weak item (e.g. an out-of-order rollback) from
-    planItems so no worker ever verifies it, yet the gate still reads passed.
-    Requires only that no category is *under-extracted*; over-extraction is fine.
-    """
+    """Require the exact deterministic P-* extraction when a round ran."""
     ip = data.get("implementationPlanning")
     if not isinstance(ip, dict):
         return
@@ -2187,82 +2151,45 @@ def _validate_plan_item_extraction_completeness(
     round_count = pbv.get("roundCount")
     if not isinstance(round_count, int) or round_count < 1:
         return
-    extracted_ids = [
-        str(it.get("id") or "").upper()
-        for it in (pbv.get("planItems") or [])
-        if isinstance(it, dict)
-    ]
-    for field, prefix, label in _PLAN_ITEM_SOURCES:
-        source_count = _plan_item_source_count(ip, field)
-        if source_count == 0:
-            continue
-        extracted = len(
-            [i for i in extracted_ids if i.startswith(prefix.upper() + "-")]
-        )
-        if extracted < source_count:
-            failures.append(
-                f"final-report data.json: {label} has {source_count} item(s) but "
-                f"planBodyVerification.planItems carries only {extracted} "
-                f"`{prefix}-*` verdict item(s). Every plan-body item MUST be "
-                "extracted for cross-verification — a dropped item escapes the "
-                "gate (plan-body-verification.md Plan-item extraction)."
-            )
-    if enforce_design_prep:
-        _validate_expected_prep_plan_items(ip, extracted_ids, failures)
-
-
-def _validate_expected_prep_plan_items(
-    planning: dict,
-    extracted_ids: list[str],
-    failures: list[str],
-) -> None:
     try:
-        expected_prep_ids = {}
-        for trigger in detect_design_surfaces(planning):
-            item_id = expected_prep_plan_item_id(trigger.stage, trigger.kind)
-            expected_prep_ids[item_id.upper()] = item_id
-    except DesignSurfaceError as exc:
-        failures.append(
-            f"final-report data.json: design-surface detection failed: {exc}"
-        )
-        return
+        expected_sequence = expected_plan_item_ids(ip)
     except Exception as exc:  # noqa: BLE001
         failures.append(
-            "final-report data.json: design-surface detection failed on "
-            f"malformed input: {exc}"
+            "final-report data.json: deterministic plan-item extraction failed: "
+            f"{exc}"
         )
         return
-    actual_prep_ids = [
-        item_id for item_id in extracted_ids if item_id.startswith("P-PREP-")
-    ]
-    missing_prep_ids = [
-        expected_prep_ids[item_id]
-        for item_id in sorted(set(expected_prep_ids) - set(actual_prep_ids))
+
+    actual_sequence = [
+        str(item.get("id") or "").strip()
+        for item in (pbv.get("planItems") or [])
+        if isinstance(item, dict)
     ]
-    if missing_prep_ids:
+    expected_ids = set(expected_sequence)
+    actual_ids = set(actual_sequence)
+    missing = expected_ids - actual_ids
+    unexpected = actual_ids - expected_ids
+    duplicate_ids = {
+        item_id for item_id in actual_ids if actual_sequence.count(item_id) > 1
+    }
+
+    if missing:
         failures.append(
             "final-report data.json: planBodyVerification.planItems is missing "
-            "detector-required design-prep verdict item(s): "
-            + ", ".join(missing_prep_ids)
+            "deterministically extracted verdict item ID(s): "
+            + ", ".join(sorted(missing))
         )
-    unexpected_prep_ids = sorted(set(actual_prep_ids) - set(expected_prep_ids))
-    if unexpected_prep_ids:
+    if unexpected:
         failures.append(
             "final-report data.json: planBodyVerification.planItems contains "
-            "unexpected design-prep verdict item(s) not produced by the "
-            "detector: "
-            + ", ".join(unexpected_prep_ids)
-        )
-    duplicate_prep_ids = sorted(
-        item_id
-        for item_id in set(actual_prep_ids)
-        if actual_prep_ids.count(item_id) > 1
-    )
-    if duplicate_prep_ids:
+            "unexpected verdict item ID(s): "
+            + ", ".join(sorted(unexpected))
+        )
+    if duplicate_ids:
         failures.append(
             "final-report data.json: planBodyVerification.planItems contains "
-            "duplicate detector-required design-prep verdict item(s): "
-            + ", ".join(duplicate_prep_ids)
+            "duplicate verdict item ID(s): "
+            + ", ".join(sorted(duplicate_ids))
         )
 
 
@@ -2826,6 +2753,113 @@ def _validate_disagree_has_fixability(data: dict, failures: list[str]) -> None:
 _COVERED_BY_ANCHOR_RE = re.compile(r"option|stage|step", re.IGNORECASE)
 _COVERED_BY_STAGE_REF_RE = re.compile(r"stage\s*(\d+)", re.IGNORECASE)
 _COVERED_BY_VAGUE = {"recommended option", "the recommended option", "recommended"}
+_DEVIATION_DECISION_REF_RE = re.compile(r"^(C-\d{3,}|D-\d{4,})$")
+_DEVIATION_BLOCKED_DISPOSITION_RE = re.compile(r"^blocked (C-\d{3,})$")
+
+
+def _resolved_deviation_refs(
+    row_id: str,
+    refs: object,
+    clarifications: dict,
+    decisions: dict,
+    failures: list[str],
+) -> list[str]:
+    valid_refs: list[str] = []
+    for ref in refs if isinstance(refs, list) else []:
+        if not isinstance(ref, str) or not _DEVIATION_DECISION_REF_RE.fullmatch(ref):
+            failures.append(
+                f"final-report data.json: requirementCoverage `{row_id}` has "
+                f"unsupported decisionRef `{ref}`; expected C-NNN or D-NNNN."
+            )
+            continue
+        target = (
+            clarifications.get(ref)
+            if ref.startswith("C-")
+            else decisions.get(ref)
+        )
+        if target is None:
+            failures.append(
+                f"final-report data.json: requirementCoverage `{row_id}` "
+                f"decisionRef `{ref}` does not exist in this report."
+            )
+            continue
+        valid_refs.append(ref)
+    return valid_refs
+
+
+def _validate_deviation_disposition(
+    row_id: str,
+    disposition: object,
+    refs: list[str],
+    clarifications: dict,
+    failures: list[str],
+) -> None:
+    if disposition == "accepted":
+        confirmed = any(
+            ref.startswith("C-")
+            and clarifications[ref].get("status") in {"answered", "resolved"}
+            and bool(str(clarifications[ref].get("userInput") or "").strip())
+            for ref in refs
+        )
+        if not confirmed:
+            failures.append(
+                f"final-report data.json: requirementCoverage `{row_id}` is "
+                "documented-deviation with approvalDisposition `accepted`, but "
+                "none of its decisionRefs is a user-confirmed clarification "
+                "(`status` answered/resolved with non-empty `userInput`)."
+            )
+        return
+    blocked = (
+        _DEVIATION_BLOCKED_DISPOSITION_RE.fullmatch(disposition)
+        if isinstance(disposition, str)
+        else None
+    )
+    if blocked is None:
+        return
+    clarification_id = blocked.group(1)
+    clarification = clarifications.get(clarification_id)
+    if clarification is None:
+        failures.append(
+            f"final-report data.json: requirementCoverage `{row_id}` "
+            f"approvalDisposition references `{clarification_id}`, which does "
+            "not exist in this report."
+        )
+    elif (
+        clarification.get("status") != "open"
+        or clarification.get("blocks") != "approval"
+    ):
+        failures.append(
+            f"final-report data.json: requirementCoverage `{row_id}` "
+            f"approvalDisposition `{disposition}` must point to an open "
+            "clarification with `blocks: approval`."
+        )
+
+
+def _validate_requirement_deviations(data: dict, failures: list[str]) -> None:
+    """Require documented deviations to reference real decisions and approval."""
+    planning = data.get("implementationPlanning")
+    if not isinstance(planning, dict):
+        return
+    clarifications = {
+        row.get("id"): row
+        for row in (data.get("clarificationItems") or [])
+        if isinstance(row, dict) and row.get("id")
+    }
+    decisions = {
+        f"D-{row.get('number')}": row
+        for row in (planning.get("decisionDrafts") or [])
+        if isinstance(row, dict) and row.get("number")
+    }
+    for row in planning.get("requirementCoverage") or []:
+        if not isinstance(row, dict) or row.get("status") != "documented-deviation":
+            continue
+        row_id = row.get("id") or "<row>"
+        refs = _resolved_deviation_refs(
+            row_id, row.get("decisionRefs"), clarifications, decisions, failures
+        )
+        _validate_deviation_disposition(
+            row_id, row.get("approvalDisposition"), refs, clarifications, failures
+        )
 
 
 def _validate_requirement_coverage_covered_by(data: dict, failures: list[str]) -> None:
@@ -2962,11 +2996,12 @@ def _cited_stage_numbers(covered_by: str) -> set[int]:
 
 # Statuses under which a row asserts the plan does work for the requirement.
 # `gap` is excluded: it states the plan does NOT cover the requirement, so it
-# can justify no stage. `blocked C-NNN` is included — the requirement is real
-# and the stage serving it is not invented scope, only pending a user answer,
-# and such a row already forces a non-passing gate and `approved: false`, so
-# orphaning its stage here would only push planners to delete legitimate work.
-_COVERAGE_CLAIMING_STATUS_RE = re.compile(r"^(covered|blocked C-\d{3,})$")
+# can justify no stage. `blocked C-NNN` and `documented-deviation` are included:
+# each records a real requirement with a planned treatment, even when the
+# treatment awaits approval or deliberately differs from the original request.
+_COVERAGE_CLAIMING_STATUS_RE = re.compile(
+    r"^(covered|blocked C-\d{3,}|documented-deviation)$"
+)
 
 
 def _validate_stage_has_requirement(data: dict, failures: list[str]) -> None:
@@ -3432,6 +3467,7 @@ _CONVERGENCE_INTERMEDIATE_PREFIXES = (
     "convergence-groups-",
     "convergence-work-",
     "convergence-round-",
+    "convergence-critic-",
 )
 
 

package/runtime/validators/validate_session_conformance.py

@@ -25,6 +25,7 @@ import sys
 from dataclasses import dataclass, field
 from datetime import datetime
 from pathlib import Path
+from typing import Any, Mapping
 
 # scripts/ (repo) and python/ (installed under ~/.okstra/lib) are not packages;
 # insert whichever exists so okstra_ctl is importable directly.
@@ -37,10 +38,21 @@ from okstra_ctl.worker_heartbeat import (  # noqa: E402
     HEARTBEAT_LINE_RE,
     HEARTBEAT_MAX_GAP_SECONDS,
 )
+from okstra_ctl.wrapper_status import read_wrapper_status  # noqa: E402
 
 _DISPATCHED_STATUSES = {"completed", "timeout", "error", "in-progress"}
 _WORKER_DISPATCH_MODES = {"cli-wrapper", "mixed", "tmux-pane"}
 _ATTEMPTED_STATUSES = {"completed", "timeout", "error"}
+_LIVENESS_AUDIT_HEARTBEAT = "audit-heartbeat"
+_LIVENESS_WRAPPER_STATUS = "wrapper-status"
+_REPORT_WRITER_HEARTBEAT_STAGES = {
+    "started",
+    "required-reading-complete",
+    "synthesis-start",
+    "data-json-write-start",
+    "render-start",
+    "write-result-start",
+}
 
 # lead 의 체크포인트 라인 — assistant text 블록 안에서 line-anchored 로만 인정.
 # lead 는 계약상 raw 로 emit 해야 하지만 실측(dev-9902)에서 `` `PROGRESS: ...` ``
@@ -507,18 +519,21 @@ def _parse_iso(ts: str) -> datetime | None:
         return None
 
 
-def _check_heartbeat_sidecar(path: Path, errors: list[str]) -> None:
+def _check_heartbeat_sidecar(path: Path, worker_id: str, errors: list[str]) -> None:
     rel = path.name
+    if not path.is_file():
+        errors.append(f"registered audit sidecar missing: {path}")
+        return
     try:
         content = path.read_text(encoding="utf-8")
     except OSError as exc:
-        errors.append(f"claude-worker audit sidecar unreadable: {rel} ({exc})")
+        errors.append(f"worker audit sidecar unreadable: {rel} ({exc})")
         return
     entries = [(m.group("stage"), m.group("ts")) for m in _HEARTBEAT_LINE_RE.finditer(content)]
     if not entries:
         errors.append(
             f"`{rel}` has no `- PROGRESS: <stage> <ISO-8601-UTC>` heartbeat lines — "
-            "the claude-worker MUST write `started` immediately and append one "
+            "the in-process worker MUST write `started` immediately and append one "
             "line per stage at <= 5-minute cadence (agents/workers/claude-worker.md "
             "'Heartbeat', prompts/lead/okstra-lead-contract.md Common Mistakes)."
         )
@@ -529,6 +544,12 @@ def _check_heartbeat_sidecar(path: Path, errors: list[str]) -> None:
             f"(found `{entries[0][0]}`) — the sidecar is written BEFORE the "
             "per-file reads, with a `- PROGRESS: started <ISO>` line."
         )
+    if worker_id == "report-writer":
+        for stage, _raw_ts in entries:
+            if stage not in _REPORT_WRITER_HEARTBEAT_STAGES:
+                errors.append(
+                    f"`{rel}`: heartbeat stage `{stage}` is not allowed for report-writer."
+                )
     # result 파일이 존재하면 마지막 단계 마커도 있어야 한다. timeout 으로 중단된
     # worker(result 없음)에는 요구하지 않는다 — hang 이전 구간의 cadence 만 본다.
     result_file = path.with_name(rel.replace("-audit-", "-"))
@@ -562,27 +583,49 @@ def _check_heartbeat_sidecar(path: Path, errors: list[str]) -> None:
         prev = ts
 
 
-def _check_heartbeat_sidecars(
-    run_dir: Path, task_type: str, suffix: str | None, errors: list[str]
+def _check_worker_liveness(
+    project_root: Path, team_state: Mapping[str, Any], errors: list[str]
 ) -> None:
-    """검사 2 — 사이드카 **존재** 는 validate-run.py validate_worker_results_audit 가
-    이미 강제하므로, 여기서는 존재하는 사이드카의 heartbeat 내용만 본다.
-
-    비-stage 격리 task-type(requirements-discovery / error-analysis /
-    implementation-planning)은 `runs/<task-type>/worker-results/` 를 run 끼리
-    공유한다 — seq 는 파일명에만 있다. seq 를 무시하고 glob 하면 이미 폐기된
-    직전 run 의 audit(heartbeat 위반)까지 검사해 현재 run 을 오탐 실패시킨다.
-    다른 검사(progress / sidecar-read)와 동일하게 현재 run seq(suffix)로 스코핑한다."""
-    worker_results_dir = run_dir / "worker-results"
-    if not worker_results_dir.is_dir():
+    """Validate the liveness artifact selected by each dispatch record."""
+    dispatches = team_state.get("workerDispatches")
+    if not isinstance(dispatches, list):
         return
-    pattern = (
-        f"claude-worker-audit-{suffix}.md"
-        if suffix
-        else f"claude-worker-audit-{task_type}-*.md"
-    )
-    for path in sorted(worker_results_dir.glob(pattern)):
-        _check_heartbeat_sidecar(path, errors)
+    for record in dispatches:
+        if not isinstance(record, Mapping):
+            continue
+        mode = record.get("livenessMode")
+        worker_id = record.get("workerId")
+        if not isinstance(worker_id, str) or not worker_id:
+            continue
+        if mode not in (_LIVENESS_AUDIT_HEARTBEAT, _LIVENESS_WRAPPER_STATUS):
+            errors.append(
+                f"worker `{worker_id}` dispatch has missing or unknown livenessMode: {mode!r}."
+            )
+            continue
+        if mode == _LIVENESS_AUDIT_HEARTBEAT:
+            raw_path = record.get("auditSidecarPath")
+            if not isinstance(raw_path, str) or not raw_path:
+                errors.append(
+                    f"worker `{worker_id}` audit-heartbeat dispatch has no registered audit sidecar path."
+                )
+                continue
+            path = Path(raw_path)
+            if not path.is_absolute():
+                path = project_root / path
+            _check_heartbeat_sidecar(path, worker_id, errors)
+        elif mode == _LIVENESS_WRAPPER_STATUS:
+            raw_path = record.get("statusSidecarPath")
+            if not isinstance(raw_path, str) or not raw_path:
+                errors.append(
+                    f"worker `{worker_id}` wrapper-status dispatch has no registered status sidecar path."
+                )
+                continue
+            path = Path(raw_path)
+            if not path.is_absolute():
+                path = project_root / path
+            status = read_wrapper_status(path)
+            if status is None:
+                errors.append(f"registered wrapper status sidecar unreadable: {path}")
 
 
 def _check_implementation_sidecar_reads(evidence: _LeadEvidence, errors: list[str]) -> None:
@@ -642,7 +685,7 @@ def validate_session_conformance(
 
     run_dir = report_path.parent.parent
     suffix = run_artifact_suffix(team_state_path)
-    _check_heartbeat_sidecars(run_dir, task_type, suffix, result.errors)
+    _check_worker_liveness(project_root, team_state, result.errors)
 
     evidence_source, source_error = _conformance_evidence_source(team_state)
     if source_error: