phase-loop-runtime 0.7.8__tar.gz → 0.7.9__tar.gz

{phase_loop_runtime-0.7.8 → phase_loop_runtime-0.7.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: phase-loop-runtime
-Version: 0.7.8
+Version: 0.7.9
 Summary: Harness-neutral phase-loop orchestration runtime and CLI
 Author: ViperJuice
 License-Expression: Apache-2.0

{phase_loop_runtime-0.7.8 → phase_loop_runtime-0.7.9}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "phase-loop-runtime"  # PyPI dist name; NOT "agent-harness" (an unrelated third-party PyPI project)
-version = "0.7.8"
+version = "0.7.9"
 description = "Harness-neutral phase-loop orchestration runtime and CLI"
 readme = "README.md"
 requires-python = ">=3.10"

{phase_loop_runtime-0.7.8 → phase_loop_runtime-0.7.9}/src/phase_loop_runtime/__init__.py

@@ -18,4 +18,4 @@ __all__ = [
     "state_ops",
 ]
 
-__version__ = "0.7.8"
+__version__ = "0.7.9"

{phase_loop_runtime-0.7.8/src/phase_loop_runtime/skills_bundle/gemini-execute-phase → phase_loop_runtime-0.7.9/src/phase_loop_runtime/skills_bundle/claude-execute-phase}/scripts/validate_plan_doc.py

@@ -477,6 +477,36 @@ def _check_f_interfaces_trace(
     return out
 
 
+def _check_o_producer_dependency(plan_path: Path) -> Findings:
+    """(O) A lane consuming an interface PROVIDED by another in-plan lane must depend on
+    that lane directly. Rather than REIMPLEMENT the parse + interface identity (which
+    reintroduces the very validator-vs-runtime divergence this closes — different lane
+    parsers and a normalized vs exact-string interface identity), DELEGATE to the runtime
+    lane IR (`phase_loop_runtime.plan_ir`) — the single source of truth the scheduler
+    fails closed on with `missing_producer_dependency`. Parity is then true by
+    construction. If the runtime is not importable at plan time, skip: the execute-time
+    lane IR still enforces the contract (no regression, and no divergent pre-warn).
+    agent-harness#182."""
+    try:
+        from phase_loop_runtime.plan_ir import parse_phase_plan_ir
+    except Exception:
+        return []
+    try:
+        ir = parse_phase_plan_ir(Path(plan_path))
+    except Exception:
+        # Parse/format errors are other checks' domain (A/B/C); (O) only speaks to the
+        # producer-dependency edge and stays silent when the plan cannot be parsed.
+        return []
+    out: Findings = []
+    for diag in getattr(ir, "diagnostics", ()):  # LaneIRDiagnostic
+        if getattr(diag, "kind", "") == "missing_producer_dependency":
+            out.append(
+                f"(O) {diag.message} — add the producer to the consumer's `Depends on` "
+                f"(the lane IR fails closed with missing_producer_dependency at execute time)"
+            )
+    return out
+
+
 def _check_g_grep_paired_with_tests(src: str) -> Findings:
     """Every acceptance criterion that uses `rg`/`grep` as its sole assertion
     must cite a test file in the same bullet. A bare grep is defeatable by
@@ -613,6 +643,7 @@ def main(argv: List[str]) -> int:
     findings.extend(_check_d_owned_files_disjoint(lane_sections_parsed, repo_root))
     findings.extend(_check_e_test_before_impl(lane_sections_parsed))
     findings.extend(_check_f_interfaces_trace(lane_sections_parsed, lane_sections_raw))
+    findings.extend(_check_o_producer_dependency(path))
     findings.extend(_check_g_grep_paired_with_tests(src))
     findings.extend(_check_h_eager_reexport(src))
 

{phase_loop_runtime-0.7.8/src/phase_loop_runtime/skills_bundle/gemini-plan-phase → phase_loop_runtime-0.7.9/src/phase_loop_runtime/skills_bundle/claude-plan-phase}/scripts/validate_plan_doc.py

@@ -560,6 +560,36 @@ def _check_f_interfaces_trace(
     return out
 
 
+def _check_o_producer_dependency(plan_path: Path) -> Findings:
+    """(O) A lane consuming an interface PROVIDED by another in-plan lane must depend on
+    that lane directly. Rather than REIMPLEMENT the parse + interface identity (which
+    reintroduces the very validator-vs-runtime divergence this closes — different lane
+    parsers and a normalized vs exact-string interface identity), DELEGATE to the runtime
+    lane IR (`phase_loop_runtime.plan_ir`) — the single source of truth the scheduler
+    fails closed on with `missing_producer_dependency`. Parity is then true by
+    construction. If the runtime is not importable at plan time, skip: the execute-time
+    lane IR still enforces the contract (no regression, and no divergent pre-warn).
+    agent-harness#182."""
+    try:
+        from phase_loop_runtime.plan_ir import parse_phase_plan_ir
+    except Exception:
+        return []
+    try:
+        ir = parse_phase_plan_ir(Path(plan_path))
+    except Exception:
+        # Parse/format errors are other checks' domain (A/B/C); (O) only speaks to the
+        # producer-dependency edge and stays silent when the plan cannot be parsed.
+        return []
+    out: Findings = []
+    for diag in getattr(ir, "diagnostics", ()):  # LaneIRDiagnostic
+        if getattr(diag, "kind", "") == "missing_producer_dependency":
+            out.append(
+                f"(O) {diag.message} — add the producer to the consumer's `Depends on` "
+                f"(the lane IR fails closed with missing_producer_dependency at execute time)"
+            )
+    return out
+
+
 def _check_g_grep_paired_with_tests(src: str) -> Findings:
     """Every acceptance criterion that uses `rg`/`grep` as its sole assertion
     must cite a test file in the same bullet. A bare grep is defeatable by
@@ -1057,6 +1087,7 @@ def main(argv: List[str]) -> int:
     findings.extend(_check_d_owned_files_disjoint(lane_sections_parsed, repo_root))
     findings.extend(_check_e_test_before_impl(lane_sections_parsed))
     findings.extend(_check_f_interfaces_trace(lane_sections_parsed, lane_sections_raw))
+    findings.extend(_check_o_producer_dependency(path))
     findings.extend(_check_g_grep_paired_with_tests(src))
     findings.extend(_check_h_eager_reexport(src))
     findings.extend(_check_i_spec_closeout_plan(src))

{phase_loop_runtime-0.7.8 → phase_loop_runtime-0.7.9}/src/phase_loop_runtime/skills_bundle/codex-execute-phase/scripts/validate_plan_doc.py

@@ -477,6 +477,36 @@ def _check_f_interfaces_trace(
     return out
 
 
+def _check_o_producer_dependency(plan_path: Path) -> Findings:
+    """(O) A lane consuming an interface PROVIDED by another in-plan lane must depend on
+    that lane directly. Rather than REIMPLEMENT the parse + interface identity (which
+    reintroduces the very validator-vs-runtime divergence this closes — different lane
+    parsers and a normalized vs exact-string interface identity), DELEGATE to the runtime
+    lane IR (`phase_loop_runtime.plan_ir`) — the single source of truth the scheduler
+    fails closed on with `missing_producer_dependency`. Parity is then true by
+    construction. If the runtime is not importable at plan time, skip: the execute-time
+    lane IR still enforces the contract (no regression, and no divergent pre-warn).
+    agent-harness#182."""
+    try:
+        from phase_loop_runtime.plan_ir import parse_phase_plan_ir
+    except Exception:
+        return []
+    try:
+        ir = parse_phase_plan_ir(Path(plan_path))
+    except Exception:
+        # Parse/format errors are other checks' domain (A/B/C); (O) only speaks to the
+        # producer-dependency edge and stays silent when the plan cannot be parsed.
+        return []
+    out: Findings = []
+    for diag in getattr(ir, "diagnostics", ()):  # LaneIRDiagnostic
+        if getattr(diag, "kind", "") == "missing_producer_dependency":
+            out.append(
+                f"(O) {diag.message} — add the producer to the consumer's `Depends on` "
+                f"(the lane IR fails closed with missing_producer_dependency at execute time)"
+            )
+    return out
+
+
 def _check_g_grep_paired_with_tests(src: str) -> Findings:
     """Every acceptance criterion that uses `rg`/`grep` as its sole assertion
     must cite a test file in the same bullet. A bare grep is defeatable by
@@ -613,6 +643,7 @@ def main(argv: List[str]) -> int:
     findings.extend(_check_d_owned_files_disjoint(lane_sections_parsed, repo_root))
     findings.extend(_check_e_test_before_impl(lane_sections_parsed))
     findings.extend(_check_f_interfaces_trace(lane_sections_parsed, lane_sections_raw))
+    findings.extend(_check_o_producer_dependency(path))
     findings.extend(_check_g_grep_paired_with_tests(src))
     findings.extend(_check_h_eager_reexport(src))
 

{phase_loop_runtime-0.7.8/src/phase_loop_runtime/skills_bundle/opencode-plan-phase → phase_loop_runtime-0.7.9/src/phase_loop_runtime/skills_bundle/codex-plan-phase}/scripts/validate_plan_doc.py

@@ -560,6 +560,36 @@ def _check_f_interfaces_trace(
     return out
 
 
+def _check_o_producer_dependency(plan_path: Path) -> Findings:
+    """(O) A lane consuming an interface PROVIDED by another in-plan lane must depend on
+    that lane directly. Rather than REIMPLEMENT the parse + interface identity (which
+    reintroduces the very validator-vs-runtime divergence this closes — different lane
+    parsers and a normalized vs exact-string interface identity), DELEGATE to the runtime
+    lane IR (`phase_loop_runtime.plan_ir`) — the single source of truth the scheduler
+    fails closed on with `missing_producer_dependency`. Parity is then true by
+    construction. If the runtime is not importable at plan time, skip: the execute-time
+    lane IR still enforces the contract (no regression, and no divergent pre-warn).
+    agent-harness#182."""
+    try:
+        from phase_loop_runtime.plan_ir import parse_phase_plan_ir
+    except Exception:
+        return []
+    try:
+        ir = parse_phase_plan_ir(Path(plan_path))
+    except Exception:
+        # Parse/format errors are other checks' domain (A/B/C); (O) only speaks to the
+        # producer-dependency edge and stays silent when the plan cannot be parsed.
+        return []
+    out: Findings = []
+    for diag in getattr(ir, "diagnostics", ()):  # LaneIRDiagnostic
+        if getattr(diag, "kind", "") == "missing_producer_dependency":
+            out.append(
+                f"(O) {diag.message} — add the producer to the consumer's `Depends on` "
+                f"(the lane IR fails closed with missing_producer_dependency at execute time)"
+            )
+    return out
+
+
 def _check_g_grep_paired_with_tests(src: str) -> Findings:
     """Every acceptance criterion that uses `rg`/`grep` as its sole assertion
     must cite a test file in the same bullet. A bare grep is defeatable by
@@ -1057,6 +1087,7 @@ def main(argv: List[str]) -> int:
     findings.extend(_check_d_owned_files_disjoint(lane_sections_parsed, repo_root))
     findings.extend(_check_e_test_before_impl(lane_sections_parsed))
     findings.extend(_check_f_interfaces_trace(lane_sections_parsed, lane_sections_raw))
+    findings.extend(_check_o_producer_dependency(path))
     findings.extend(_check_g_grep_paired_with_tests(src))
     findings.extend(_check_h_eager_reexport(src))
     findings.extend(_check_i_spec_closeout_plan(src))

{phase_loop_runtime-0.7.8/src/phase_loop_runtime/skills_bundle/opencode-execute-phase → phase_loop_runtime-0.7.9/src/phase_loop_runtime/skills_bundle/gemini-execute-phase}/scripts/validate_plan_doc.py

@@ -477,6 +477,36 @@ def _check_f_interfaces_trace(
     return out
 
 
+def _check_o_producer_dependency(plan_path: Path) -> Findings:
+    """(O) A lane consuming an interface PROVIDED by another in-plan lane must depend on
+    that lane directly. Rather than REIMPLEMENT the parse + interface identity (which
+    reintroduces the very validator-vs-runtime divergence this closes — different lane
+    parsers and a normalized vs exact-string interface identity), DELEGATE to the runtime
+    lane IR (`phase_loop_runtime.plan_ir`) — the single source of truth the scheduler
+    fails closed on with `missing_producer_dependency`. Parity is then true by
+    construction. If the runtime is not importable at plan time, skip: the execute-time
+    lane IR still enforces the contract (no regression, and no divergent pre-warn).
+    agent-harness#182."""
+    try:
+        from phase_loop_runtime.plan_ir import parse_phase_plan_ir
+    except Exception:
+        return []
+    try:
+        ir = parse_phase_plan_ir(Path(plan_path))
+    except Exception:
+        # Parse/format errors are other checks' domain (A/B/C); (O) only speaks to the
+        # producer-dependency edge and stays silent when the plan cannot be parsed.
+        return []
+    out: Findings = []
+    for diag in getattr(ir, "diagnostics", ()):  # LaneIRDiagnostic
+        if getattr(diag, "kind", "") == "missing_producer_dependency":
+            out.append(
+                f"(O) {diag.message} — add the producer to the consumer's `Depends on` "
+                f"(the lane IR fails closed with missing_producer_dependency at execute time)"
+            )
+    return out
+
+
 def _check_g_grep_paired_with_tests(src: str) -> Findings:
     """Every acceptance criterion that uses `rg`/`grep` as its sole assertion
     must cite a test file in the same bullet. A bare grep is defeatable by
@@ -613,6 +643,7 @@ def main(argv: List[str]) -> int:
     findings.extend(_check_d_owned_files_disjoint(lane_sections_parsed, repo_root))
     findings.extend(_check_e_test_before_impl(lane_sections_parsed))
     findings.extend(_check_f_interfaces_trace(lane_sections_parsed, lane_sections_raw))
+    findings.extend(_check_o_producer_dependency(path))
     findings.extend(_check_g_grep_paired_with_tests(src))
     findings.extend(_check_h_eager_reexport(src))
 

{phase_loop_runtime-0.7.8/src/phase_loop_runtime/skills_bundle/codex-plan-phase → phase_loop_runtime-0.7.9/src/phase_loop_runtime/skills_bundle/gemini-plan-phase}/scripts/validate_plan_doc.py

@@ -560,6 +560,36 @@ def _check_f_interfaces_trace(
     return out
 
 
+def _check_o_producer_dependency(plan_path: Path) -> Findings:
+    """(O) A lane consuming an interface PROVIDED by another in-plan lane must depend on
+    that lane directly. Rather than REIMPLEMENT the parse + interface identity (which
+    reintroduces the very validator-vs-runtime divergence this closes — different lane
+    parsers and a normalized vs exact-string interface identity), DELEGATE to the runtime
+    lane IR (`phase_loop_runtime.plan_ir`) — the single source of truth the scheduler
+    fails closed on with `missing_producer_dependency`. Parity is then true by
+    construction. If the runtime is not importable at plan time, skip: the execute-time
+    lane IR still enforces the contract (no regression, and no divergent pre-warn).
+    agent-harness#182."""
+    try:
+        from phase_loop_runtime.plan_ir import parse_phase_plan_ir
+    except Exception:
+        return []
+    try:
+        ir = parse_phase_plan_ir(Path(plan_path))
+    except Exception:
+        # Parse/format errors are other checks' domain (A/B/C); (O) only speaks to the
+        # producer-dependency edge and stays silent when the plan cannot be parsed.
+        return []
+    out: Findings = []
+    for diag in getattr(ir, "diagnostics", ()):  # LaneIRDiagnostic
+        if getattr(diag, "kind", "") == "missing_producer_dependency":
+            out.append(
+                f"(O) {diag.message} — add the producer to the consumer's `Depends on` "
+                f"(the lane IR fails closed with missing_producer_dependency at execute time)"
+            )
+    return out
+
+
 def _check_g_grep_paired_with_tests(src: str) -> Findings:
     """Every acceptance criterion that uses `rg`/`grep` as its sole assertion
     must cite a test file in the same bullet. A bare grep is defeatable by
@@ -1057,6 +1087,7 @@ def main(argv: List[str]) -> int:
     findings.extend(_check_d_owned_files_disjoint(lane_sections_parsed, repo_root))
     findings.extend(_check_e_test_before_impl(lane_sections_parsed))
     findings.extend(_check_f_interfaces_trace(lane_sections_parsed, lane_sections_raw))
+    findings.extend(_check_o_producer_dependency(path))
     findings.extend(_check_g_grep_paired_with_tests(src))
     findings.extend(_check_h_eager_reexport(src))
     findings.extend(_check_i_spec_closeout_plan(src))

{phase_loop_runtime-0.7.8/src/phase_loop_runtime/skills_bundle/claude-execute-phase → phase_loop_runtime-0.7.9/src/phase_loop_runtime/skills_bundle/opencode-execute-phase}/scripts/validate_plan_doc.py

@@ -477,6 +477,36 @@ def _check_f_interfaces_trace(
     return out
 
 
+def _check_o_producer_dependency(plan_path: Path) -> Findings:
+    """(O) A lane consuming an interface PROVIDED by another in-plan lane must depend on
+    that lane directly. Rather than REIMPLEMENT the parse + interface identity (which
+    reintroduces the very validator-vs-runtime divergence this closes — different lane
+    parsers and a normalized vs exact-string interface identity), DELEGATE to the runtime
+    lane IR (`phase_loop_runtime.plan_ir`) — the single source of truth the scheduler
+    fails closed on with `missing_producer_dependency`. Parity is then true by
+    construction. If the runtime is not importable at plan time, skip: the execute-time
+    lane IR still enforces the contract (no regression, and no divergent pre-warn).
+    agent-harness#182."""
+    try:
+        from phase_loop_runtime.plan_ir import parse_phase_plan_ir
+    except Exception:
+        return []
+    try:
+        ir = parse_phase_plan_ir(Path(plan_path))
+    except Exception:
+        # Parse/format errors are other checks' domain (A/B/C); (O) only speaks to the
+        # producer-dependency edge and stays silent when the plan cannot be parsed.
+        return []
+    out: Findings = []
+    for diag in getattr(ir, "diagnostics", ()):  # LaneIRDiagnostic
+        if getattr(diag, "kind", "") == "missing_producer_dependency":
+            out.append(
+                f"(O) {diag.message} — add the producer to the consumer's `Depends on` "
+                f"(the lane IR fails closed with missing_producer_dependency at execute time)"
+            )
+    return out
+
+
 def _check_g_grep_paired_with_tests(src: str) -> Findings:
     """Every acceptance criterion that uses `rg`/`grep` as its sole assertion
     must cite a test file in the same bullet. A bare grep is defeatable by
@@ -613,6 +643,7 @@ def main(argv: List[str]) -> int:
     findings.extend(_check_d_owned_files_disjoint(lane_sections_parsed, repo_root))
     findings.extend(_check_e_test_before_impl(lane_sections_parsed))
     findings.extend(_check_f_interfaces_trace(lane_sections_parsed, lane_sections_raw))
+    findings.extend(_check_o_producer_dependency(path))
     findings.extend(_check_g_grep_paired_with_tests(src))
     findings.extend(_check_h_eager_reexport(src))
 

{phase_loop_runtime-0.7.8/src/phase_loop_runtime/skills_bundle/claude-plan-phase → phase_loop_runtime-0.7.9/src/phase_loop_runtime/skills_bundle/opencode-plan-phase}/scripts/validate_plan_doc.py

@@ -560,6 +560,36 @@ def _check_f_interfaces_trace(
     return out
 
 
+def _check_o_producer_dependency(plan_path: Path) -> Findings:
+    """(O) A lane consuming an interface PROVIDED by another in-plan lane must depend on
+    that lane directly. Rather than REIMPLEMENT the parse + interface identity (which
+    reintroduces the very validator-vs-runtime divergence this closes — different lane
+    parsers and a normalized vs exact-string interface identity), DELEGATE to the runtime
+    lane IR (`phase_loop_runtime.plan_ir`) — the single source of truth the scheduler
+    fails closed on with `missing_producer_dependency`. Parity is then true by
+    construction. If the runtime is not importable at plan time, skip: the execute-time
+    lane IR still enforces the contract (no regression, and no divergent pre-warn).
+    agent-harness#182."""
+    try:
+        from phase_loop_runtime.plan_ir import parse_phase_plan_ir
+    except Exception:
+        return []
+    try:
+        ir = parse_phase_plan_ir(Path(plan_path))
+    except Exception:
+        # Parse/format errors are other checks' domain (A/B/C); (O) only speaks to the
+        # producer-dependency edge and stays silent when the plan cannot be parsed.
+        return []
+    out: Findings = []
+    for diag in getattr(ir, "diagnostics", ()):  # LaneIRDiagnostic
+        if getattr(diag, "kind", "") == "missing_producer_dependency":
+            out.append(
+                f"(O) {diag.message} — add the producer to the consumer's `Depends on` "
+                f"(the lane IR fails closed with missing_producer_dependency at execute time)"
+            )
+    return out
+
+
 def _check_g_grep_paired_with_tests(src: str) -> Findings:
     """Every acceptance criterion that uses `rg`/`grep` as its sole assertion
     must cite a test file in the same bullet. A bare grep is defeatable by
@@ -1057,6 +1087,7 @@ def main(argv: List[str]) -> int:
     findings.extend(_check_d_owned_files_disjoint(lane_sections_parsed, repo_root))
     findings.extend(_check_e_test_before_impl(lane_sections_parsed))
     findings.extend(_check_f_interfaces_trace(lane_sections_parsed, lane_sections_raw))
+    findings.extend(_check_o_producer_dependency(path))
     findings.extend(_check_g_grep_paired_with_tests(src))
     findings.extend(_check_h_eager_reexport(src))
     findings.extend(_check_i_spec_closeout_plan(src))

{phase_loop_runtime-0.7.8 → phase_loop_runtime-0.7.9}/src/phase_loop_runtime.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: phase-loop-runtime
-Version: 0.7.8
+Version: 0.7.9
 Summary: Harness-neutral phase-loop orchestration runtime and CLI
 Author: ViperJuice
 License-Expression: Apache-2.0

{phase_loop_runtime-0.7.8 → phase_loop_runtime-0.7.9}/src/phase_loop_runtime.egg-info/SOURCES.txt

@@ -759,6 +759,7 @@ tests/test_train_runner.py
 tests/test_unattended_release.py
 tests/test_v34_parallel_dispatch_soak.py
 tests/test_validate_plan_doc_docs_lane.py
+tests/test_validate_plan_doc_producer_dependency.py
 tests/test_verification_evidence.py
 tests/test_verification_evidence_validator.py
 tests/test_visual_evidence_validator.py

phase_loop_runtime-0.7.9/tests/test_validate_plan_doc_producer_dependency.py

@@ -0,0 +1,128 @@
+"""agent-harness#182 — validate_plan_doc.py (O) producer-dependency check == runtime.
+
+The runtime lane IR (`phase_loop_runtime.plan_ir`) fails closed with
+`missing_producer_dependency` at execute time when a lane consumes an interface provided
+by another in-plan lane it does not depend on directly. The plan validator's `(O)` check
+must enforce the SAME contract at plan time. To guarantee that — and to avoid re-creating
+the very validator-vs-runtime divergence #182 is about — `(O)` DELEGATES to `plan_ir`.
+These tests pin the behaviour AND the parity, including the exact-string interface
+identity (so `IFoo` vs `IFoo (v2)` does NOT false-positive the way a normalized
+reimplementation would).
+"""
+import importlib.util
+import sys
+import textwrap
+import unittest
+from pathlib import Path
+
+import pytest
+
+from _dotfiles_tree import skills_bundle_present
+from phase_loop_runtime.plan_ir import parse_phase_plan_ir
+
+if not skills_bundle_present():
+    pytest.skip(
+        "requires the sibling phase-loop-skills bundle (absent in the standalone-from-wheel clean-room)",
+        allow_module_level=True,
+    )
+
+ROOT = Path(__file__).resolve().parents[2]
+SCRIPT = ROOT / "phase-loop-skills" / "plan-phase" / "scripts" / "validate_plan_doc.py"
+
+
+def _load():
+    spec = importlib.util.spec_from_file_location("validate_plan_doc_prod_dep_under_test", SCRIPT)
+    mod = importlib.util.module_from_spec(spec)
+    sys.modules[spec.name] = mod  # dataclasses resolve annotations via sys.modules
+    spec.loader.exec_module(mod)
+    return mod
+
+
+def _plan(consumed: str, sl2_depends: str) -> str:
+    """A 3-lane plan: SL-0 provides `IFoo`; SL-2 consumes `consumed` and depends on
+    `sl2_depends`. Empty interface lists are OMITTED (the runtime parses a literal
+    `(none)` as an interface token). The runtime tolerates the ASCII hyphen in the
+    SL heading."""
+    return textwrap.dedent(
+        f"""\
+        ## Lane Index
+
+        - SL-0 — Provider; Depends on: (none)
+        - SL-1 — Middle; Depends on: SL-0
+        - SL-2 — Consumer; Depends on: {sl2_depends}
+
+        ## Lanes
+
+        ### SL-0 - Provider
+
+        - **Owned files**: `src/foo.py`
+        - **Interfaces provided**: `IFoo`
+
+        ### SL-1 - Middle
+
+        - **Owned files**: `src/mid.py`
+
+        ### SL-2 - Consumer
+
+        - **Owned files**: `src/consumer.py`
+        - **Interfaces consumed**: {consumed}
+        """
+    )
+
+
+def _runtime_missing(path: Path):
+    return [d for d in parse_phase_plan_ir(path).diagnostics if d.kind == "missing_producer_dependency"]
+
+
+class ProducerDependencyParityTest(unittest.TestCase):
+    @classmethod
+    def setUpClass(cls):
+        cls.mod = _load()
+
+    def _write(self, tmp: Path, text: str) -> Path:
+        p = tmp / "plan.md"
+        p.write_text(text, encoding="utf-8")
+        return p
+
+    def test_flags_missing_direct_producer_edge_matching_runtime(self):
+        import tempfile
+        with tempfile.TemporaryDirectory() as d:
+            path = self._write(Path(d), _plan(consumed="`IFoo`", sl2_depends="SL-1"))
+            runtime = _runtime_missing(path)
+            self.assertTrue(runtime, "fixture must trigger the runtime diagnostic (self-check)")
+            findings = self.mod._check_o_producer_dependency(path)
+            self.assertEqual(len(findings), len(runtime), findings)
+            self.assertTrue(any("SL-2" in f for f in findings), findings)
+            self.assertTrue(all("WARN" not in f for f in findings))  # ERROR, not advice
+
+    def test_clean_when_direct_edge_present_matching_runtime(self):
+        import tempfile
+        with tempfile.TemporaryDirectory() as d:
+            path = self._write(Path(d), _plan(consumed="`IFoo`", sl2_depends="SL-0"))
+            self.assertEqual(_runtime_missing(path), [], "runtime should accept the direct edge")
+            self.assertEqual(self.mod._check_o_producer_dependency(path), [])
+
+    def test_annotated_interface_is_exact_string_not_normalized(self):
+        # The CR's false-positive case: provide `IFoo`, consume `IFoo (v2)` with NO direct
+        # edge. The runtime matches interfaces by EXACT string, so `IFoo` != `IFoo (v2)` →
+        # no in-plan producer → runtime ACCEPTS. A normalized reimplementation would strip
+        # `(v2)` and wrongly ERROR. (O) must match the runtime: no finding.
+        import tempfile
+        with tempfile.TemporaryDirectory() as d:
+            path = self._write(Path(d), _plan(consumed="`IFoo (v2)`", sl2_depends="SL-1"))
+            self.assertEqual(_runtime_missing(path), [], "runtime treats IFoo and IFoo (v2) as distinct")
+            self.assertEqual(
+                self.mod._check_o_producer_dependency(path), [],
+                "(O) must not false-positive on an annotated interface (exact-string identity)",
+            )
+
+    def test_skips_gracefully_when_plan_unparseable(self):
+        import tempfile
+        with tempfile.TemporaryDirectory() as d:
+            path = self._write(Path(d), "not a plan\n")
+            # No lanes → no producer edges → no (O) findings (A/B own the parse errors).
+            self.assertEqual(self.mod._check_o_producer_dependency(path), [])
+
+
+if __name__ == "__main__":
+    unittest.main()