okstra 0.52.0 → 0.53.0

package/runtime/validators/validate-run.py

@@ -313,6 +313,18 @@ def extract_contract(
     }
 
 
+def effective_run_task_type(run_manifest: dict, task_manifest: dict) -> str:
+    """Return the task type for the specific run being validated.
+
+    `task-manifest.json` is mutable lifecycle state and may point at a later
+    phase after the user has continued the task. A final-report belongs to the
+    immutable run-manifest, so run-manifest wins here.
+    """
+    return str(
+        run_manifest.get("taskType") or task_manifest.get("taskType") or ""
+    ).strip()
+
+
 def validate_team_state(
     team_state: dict, project_root: Path, contract: dict, failures: list[str]
 ) -> None:
@@ -857,6 +869,7 @@ PLANNING_REQUIRED_SECTIONS = (
     "Dependency",
     "Validation Checklist",
     "Rollback",
+    "Requirement Coverage",
     "Plan Body Verification",
 )
 
@@ -951,6 +964,11 @@ _APPROVED_FRONTMATTER_RE = re.compile(
     re.IGNORECASE | re.MULTILINE,
 )
 _FRONTMATTER_BLOCK_RE = re.compile(r"\A---\n(.*?)\n---\n", re.DOTALL)
+_REQUIREMENT_COVERAGE_HEADING_RE = re.compile(
+    r"^###[ \t]+(?:5\.5\.8[ \t]+)?Requirement Coverage\b",
+    re.IGNORECASE | re.MULTILINE,
+)
+_NEXT_THIRD_LEVEL_HEADING_RE = re.compile(r"^###[ \t]+", re.MULTILINE)
 
 
 def _extract_final_verdict_token(content: str) -> str | None:
@@ -968,6 +986,115 @@ def _extract_final_verdict_token(content: str) -> str | None:
     return match.group("value")
 
 
+def _split_markdown_row(line: str) -> list[str]:
+    stripped = line.strip()
+    if stripped.startswith("|"):
+        stripped = stripped[1:]
+    if stripped.endswith("|"):
+        stripped = stripped[:-1]
+    return [cell.strip().strip("`").strip() for cell in stripped.split("|")]
+
+
+def _is_markdown_separator(line: str) -> bool:
+    stripped = line.strip()
+    if not stripped.startswith("|"):
+        return False
+    for cell in stripped.strip("|").split("|"):
+        if not re.fullmatch(r"\s*:?-{2,}:?\s*", cell):
+            return False
+    return True
+
+
+def _append_requirement_coverage_failures(
+    content: str,
+    gate_value: str,
+    failures: list[str],
+) -> None:
+    """Validate implementation-planning §5.5.8 requirement coverage.
+
+    The table is intentionally lightweight: it cannot prove semantic truth, but
+    it makes requirement-to-plan mapping explicit and blocks publishable plans
+    that admit uncovered requirements.
+    """
+    heading = _REQUIREMENT_COVERAGE_HEADING_RE.search(content)
+    if heading is None:
+        failures.append(
+            "implementation-planning report is missing `Requirement Coverage` "
+            "section — every task-brief requirement must map to option/stage/step."
+        )
+        return
+
+    rest = content[heading.end():]
+    next_heading = _NEXT_THIRD_LEVEL_HEADING_RE.search(rest)
+    section = rest[: next_heading.start()] if next_heading else rest
+    lines = section.splitlines()
+
+    header_idx = -1
+    headers: list[str] = []
+    for idx, line in enumerate(lines):
+        if not line.lstrip().startswith("|"):
+            continue
+        cells = [c.lower() for c in _split_markdown_row(line)]
+        if "id" in cells and "requirement" in cells and "status" in cells:
+            header_idx = idx
+            headers = cells
+            break
+    if header_idx < 0:
+        failures.append(
+            "implementation-planning Requirement Coverage section has no table "
+            "with `ID`, `Requirement`, and `Status` columns."
+        )
+        return
+
+    id_col = headers.index("id")
+    status_col = headers.index("status")
+    rows: list[tuple[str, str]] = []
+    body_started = False
+    for line in lines[header_idx + 1:]:
+        if not line.lstrip().startswith("|"):
+            if body_started:
+                break
+            continue
+        if _is_markdown_separator(line):
+            body_started = True
+            continue
+        if not body_started:
+            continue
+        cells = _split_markdown_row(line)
+        if max(id_col, status_col) >= len(cells):
+            failures.append(
+                "implementation-planning Requirement Coverage table has a "
+                f"malformed row: `{line.strip()}`"
+            )
+            continue
+        rows.append((cells[id_col], cells[status_col].lower()))
+
+    if not rows:
+        failures.append(
+            "implementation-planning Requirement Coverage table has no data rows."
+        )
+        return
+
+    for row_id, status in rows:
+        if not re.fullmatch(r"covered|gap|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`."
+            )
+
+    if gate_value in ("passed", "passed-with-dissent"):
+        uncovered = [
+            f"{row_id} ({status})"
+            for row_id, status in rows
+            if status != "covered"
+        ]
+        if uncovered:
+            failures.append(
+                "implementation-planning Gate result is publishable but "
+                "Requirement Coverage has uncovered row(s): "
+                + ", ".join(uncovered)
+            )
 def _extract_verdict_card_token(content: str) -> str | None:
     """Return the `Verdict Token` cell from the Verdict Card block."""
     block = _VERDICT_CARD_BLOCK_RE.search(content)
@@ -1101,6 +1228,19 @@ def _validate_final_verification_consistency(data: dict, failures: list[str]) ->
             "when the verdict is `accepted`."
         )
 
+    scope = data.get("verificationScope", "whole-task")
+    if scope not in ("whole-task", "single-stage"):
+        failures.append(
+            f"final-verification: verificationScope must be `whole-task` or "
+            f"`single-stage`, got {scope!r}."
+        )
+    if scope == "single-stage" and "release-handoff" in routing:
+        failures.append(
+            "final-verification: verificationScope `single-stage` cannot recommend "
+            "release-handoff routing — single-stage is a partial verification and "
+            "release-handoff requires whole-task verification."
+        )
+
 
 def validate_report_views(report_path: Path, failures: list[str]) -> None:
     """Enforce Phase 7 step 1.5 (BLOCKING) — the self-contained HTML
@@ -1292,6 +1432,8 @@ def validate_phase_boundary(
             "must NOT publish a pre-approved plan when verification did not pass."
         )
 
+    _append_requirement_coverage_failures(content, gate_value, failures)
+
     # Only a publishable plan (gate passed) can be flipped to `approved: true`
     # and reach the `implementation` entry, so the Stage Map structure is
     # enforced only here — a blocked/aborted plan may legitimately be incomplete.
@@ -1732,7 +1874,7 @@ def main() -> int:
     validate_report(report_path, contract["required_agent_status_entries"], failures)
     validate_team_state_usage(team_state, failures)
 
-    task_type = str(task_manifest.get("taskType") or run_manifest.get("taskType") or "").strip()
+    task_type = effective_run_task_type(run_manifest, task_manifest)
     validate_phase_boundary(task_type, report_path, failures)
     if task_type:
         validate_worker_results_audit(report_path, task_type, failures)

package/runtime/validators/validate-workflow.sh

@@ -17,7 +17,12 @@ WORKSPACE_APP_PATH="$PROJECT_ROOT"
 OKSTRA_SCRIPT="$WORKSPACE_ROOT/scripts/okstra.sh"
 RUN_VALIDATOR_PATH="$WORKSPACE_ROOT/validators/validate-run.py"
 SOURCE_ASSET_ROOT="$WORKSPACE_ROOT/agents"
-TASK_TYPE="final-verification"
+# Arbitrary sample task-type used only to exercise the bundle-prep /
+# discovery-pointer / task-catalog / asset-seeding machinery via render-only
+# run_okstra. Must NOT require --approved-plan (excludes implementation and
+# final-verification) and must have a tests/fixtures/final-report-data/
+# <task-type>-001.data.json sample (used by prepare_run_validator_fixture).
+TASK_TYPE="requirements-discovery"
 PRIMARY_TASK_GROUP="validation"
 PRIMARY_TASK_ID="asset-refresh-and-reference-expectations"
 PRIMARY_BRIEF_FILENAME="validation-brief-primary.md"