phase-loop-runtime 0.7.18__tar.gz → 0.7.19__tar.gz

{phase_loop_runtime-0.7.18 → phase_loop_runtime-0.7.19}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: phase-loop-runtime
-Version: 0.7.18
+Version: 0.7.19
 Summary: Harness-neutral phase-loop orchestration runtime and CLI
 Author-email: ViperJuice <viperjuice@users.noreply.github.com>
 License-Expression: Apache-2.0
@@ -49,7 +49,7 @@ To install just this runtime package directly:
 
 ```sh
 pip install phase-loop-runtime              # latest compatible release
-pip install phase-loop-runtime==0.7.18      # …or pin an exact version
+pip install phase-loop-runtime==0.7.19      # …or pin an exact version
 ```
 
 To pin a specific tag from source instead, substitute a tag from

{phase_loop_runtime-0.7.18 → phase_loop_runtime-0.7.19}/README.md

@@ -19,7 +19,7 @@ To install just this runtime package directly:
 
 ```sh
 pip install phase-loop-runtime              # latest compatible release
-pip install phase-loop-runtime==0.7.18      # …or pin an exact version
+pip install phase-loop-runtime==0.7.19      # …or pin an exact version
 ```
 
 To pin a specific tag from source instead, substitute a tag from

{phase_loop_runtime-0.7.18 → phase_loop_runtime-0.7.19}/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.18"
+version = "0.7.19"
 description = "Harness-neutral phase-loop orchestration runtime and CLI"
 readme = "README.md"
 requires-python = ">=3.10"

{phase_loop_runtime-0.7.18 → phase_loop_runtime-0.7.19}/src/phase_loop_runtime/__init__.py

@@ -18,4 +18,4 @@ __all__ = [
     "state_ops",
 ]
 
-__version__ = "0.7.18"
+__version__ = "0.7.19"

{phase_loop_runtime-0.7.18 → phase_loop_runtime-0.7.19}/src/phase_loop_runtime/advisor_board/CONTRACTS.md

@@ -660,8 +660,8 @@ review text and the exception in detail; sandbox facts describe actual enforceme
 
 ### Qualified Gemini extension (agent-harness#905)
 
-The Linux x64 subscription `agy` 1.2.10 entry image must match SHA256
-`aea7ed8df1e79b716c0ccd14c7d8086db75b14da535ffb7febdec9a488deff67`.
+The Linux x64 subscription `agy` 1.2.11 entry image must match SHA256
+`ec7cf797ecb0e1d91ddf3b6d9d6c1d616bb89f78a5b0e43536b72a7fce695f56`.
 The running Python/kernel must support sealed memfds, pidfds and pidfd signaling;
 Python version alone is not a capability check. Unknown images or missing
 capabilities refuse before availability/auth effects. Required bwrap mount/gate

{phase_loop_runtime-0.7.18 → phase_loop_runtime-0.7.19}/src/phase_loop_runtime/closeout_classifier.py

@@ -174,6 +174,17 @@ _TOOL_CACHE_DIR_NAMES = frozenset(
 )
 _TOOL_CACHE_DIR_SUFFIXES = (".egg-info",)
 
+def _handoff_root_relpath() -> str:
+    # Taken from the resolver itself rather than restated, so the audit cannot drift from
+    # where the skills are told to write (phase_loop_runtime.skill_paths).
+    from .skill_paths import resolve_handoff_root
+
+    anchor = Path("/")
+    return resolve_handoff_root(anchor).relative_to(anchor.resolve()).as_posix()
+
+
+_HANDOFF_ROOT = _handoff_root_relpath()
+
 
 def classify_ignored_output(repo_relpath: str) -> IgnoredOutputVerdict:
     """Grade one gitignored path by WHO produced it.
@@ -210,6 +221,15 @@ def classify_ignored_output(repo_relpath: str) -> IgnoredOutputVerdict:
                 RUNNER_OWNED, False, f"runner lifecycle state under {entry}"
             )
 
+    # agent-harness#1084: the repo-local skill handoff root is lifecycle state the skills
+    # are REQUIRED to write and to keep ignored. Only the exact root the resolver returns
+    # (repo root, directory form or a path under it) earns this; the same name nested
+    # anywhere else, or a bare file of that name, still blocks.
+    if norm == _HANDOFF_ROOT + "/" or norm.startswith(_HANDOFF_ROOT + "/"):
+        return IgnoredOutputVerdict(
+            RUNNER_OWNED, False, f"required skill handoff under {_HANDOFF_ROOT}/"
+        )
+
     # A cache name only earns trust as a DIRECTORY. Git renders a collapsed
     # directory with a trailing slash and a file without one, so a bare `.venv`
     # or `node_modules` entry is an ordinary FILE (or a symlink) that merely

{phase_loop_runtime-0.7.18 → phase_loop_runtime-0.7.19}/src/phase_loop_runtime/gemini_heartbeat.py

@@ -14,8 +14,8 @@ import time
 from .agy_canary_evidence import AgyCanaryEvidenceError, _linux_memfd_seal_abi, _sealed_tree_fd
 
 
-QUALIFIED_IMAGE_SHA256 = "aea7ed8df1e79b716c0ccd14c7d8086db75b14da535ffb7febdec9a488deff67"
-QUALIFIED_HELP_SHA256 = "5a03bf7dc9d3d7645f5853906cc117363fd8978a79c2a89521f0ff7590dbe454"
+QUALIFIED_IMAGE_SHA256 = "ec7cf797ecb0e1d91ddf3b6d9d6c1d616bb89f78a5b0e43536b72a7fce695f56"
+QUALIFIED_HELP_SHA256 = "83e3a0c36269f23972ba33d0013b9a6b2933ddb07cde268fa40e0fb1a5f33755"
 PROFILE_ID = "agy_memfd_home_deny_all_v1"
 PRIVATE_HOME = "/dev/phase-loop-agy"
 _CAPABILITY = "gemini_heartbeat_capability_unavailable"

{phase_loop_runtime-0.7.18 → phase_loop_runtime-0.7.19}/src/phase_loop_runtime/panel_invoker.py

@@ -3987,29 +3987,202 @@ def _assistant_text_from_jsonl(path: Path) -> str:
     return "\n".join(texts).strip()
 
 
-def _final_assistant_text_from_jsonl(path: Path) -> str:
-    """Return only the final structured assistant message, never TUI chrome/input."""
-    final = ""
+def _final_assistant_text_from_jsonl(path: Path, *, require_terminal: bool = False) -> str:
+    """Return the final turn's single assistant message, or "" when that cannot be proven.
+
+    The rule (agent-harness#1002): a TURN starts at the last user record that is not a replay
+    (same uuid AND same content as an earlier user record; a changed request under a reused
+    uuid is a new request). History before the turn never blocks a later answer.
+
+    Records: an exact replay of any earlier version of a record (same uuid, content and
+    completion state) is dropped, because the CLI re-journals records with changed
+    ``usage``/``parentUuid``/``promptId``; a stale open version of a stopped record is dropped
+    too. Within the turn, an explicitly open (null) stop_reason may change to a value under its
+    uuid, and the latest version wins; any other state change, or a content change after the
+    message stopped or across messages, fails closed.
+
+    The answer is the turn's last message id. It fails closed if any of its records shares a
+    uuid, a message id or its content with history (earlier messages of the turn may share a
+    history id: parallel tool calls continue one message across a tool_result), or if an
+    identity-less answer repeats any other assistant record. A message id that leaves and
+    returns, uuid and uuid-less records mixed, or a repeated uuid-less record also fails closed.
+    Blocks of one message that repeat the same text under distinct uuids are all kept, so a copy
+    of such a block under a fresh uuid is not detected.
+
+    With ``require_terminal`` (the president route, agent-harness#1016), any damaged line fails
+    closed, the answer's last record must stop with ``end_turn``, and no assistant record of the
+    final turn (superseded versions and replays included) may stop with anything else (earlier
+    blocks stay null), carry a tool call, be a ``<synthetic>`` model record, or carry
+    ``isApiErrorMessage`` on the message or the record.
+
+    Measured on real Claude Code 2.1.282 journals: every record has a uuid, 9 of 28,960 turns
+    hold more than one message id and none an A-B-A.
+    """
     try:
-        lines = path.read_text(encoding="utf-8", errors="replace").splitlines()
+        lines = path.read_text(encoding="utf-8", errors="replace").split("\n")
     except OSError:
         return ""
-    for line in lines:
+    last_line = max((i for i, text in enumerate(lines) if text.strip()), default=-1)
+    records: list[tuple[dict, dict]] = []
+    for index, line in enumerate(lines):
+        if not line.strip():
+            continue
         try:
             payload = json.loads(line)
         except json.JSONDecodeError:
-            continue
+            if index == last_line or require_terminal:
+                # A writer may still be appending the latest record. The president route owns a
+                # fresh transcript per call, so any damaged line there (for example a half-written
+                # newer request) fails closed rather than being skipped as history.
+                return ""
+            continue  # a damaged line with valid records after it is history
         message = payload.get("message") if isinstance(payload, dict) else None
-        if not isinstance(message, dict) or message.get("role") != "assistant":
+        if isinstance(message, dict) and message.get("role") in ("user", "assistant"):
+            if message.get("id") is not None and not isinstance(message.get("id"), str):
+                return ""
+            if message.get("stop_reason") is not None and not isinstance(message.get("stop_reason"), str):
+                return ""
+            records.append((payload, message))
+
+    def _uuid(payload: dict) -> str | None:
+        value = payload.get("uuid")
+        return value if isinstance(value, str) and value else None
+
+    def _said(message: dict) -> str:  # what a record SAYS; accounting and links excluded
+        return json.dumps([message.get("id"), message.get("role"), message.get("content")], sort_keys=True)
+
+    def _state(message: dict) -> tuple:
+        return ("stop_reason" in message, message.get("stop_reason"))
+
+    boundary = -1
+    seen_users: set[tuple[str, str]] = set()
+    for position, (payload, message) in enumerate(records):
+        if message.get("role") != "user":
             continue
-        text = "\n".join(
-            item["text"] for item in (message.get("content") or [])
-            if isinstance(item, dict) and item.get("type") == "text"
-            and isinstance(item.get("text"), str)
-        ).strip()
-        if text:
-            final = text
-    return final
+        user_id = _uuid(payload)
+        if user_id is not None:
+            if (user_id, _said(message)) in seen_users:
+                continue  # a re-journaled user record is not a new request
+            seen_users.add((user_id, _said(message)))
+        boundary = position
+    history = [(p, m) for p, m in records[: max(boundary, 0)] if m.get("role") == "assistant"]
+    history_ids = {m.get("id") for _, m in history} - {None}
+    history_uuids = {_uuid(p) for p, _ in history} - {None}
+    history_said = {_said(m) for _, m in history}
+
+    known: dict[str, tuple[str, tuple]] = {}  # the latest version of each uuid
+    seen_versions: dict[str, set[tuple[str, tuple]]] = {}  # every version of each uuid
+    stopped_ids: set[object] = set()  # message ids that carried any stop_reason
+    turn: list[tuple[dict, dict]] = []
+    for position, (payload, message) in enumerate(records):
+        if message.get("role") != "assistant":
+            continue
+        uid, said, state = _uuid(payload), _said(message), _state(message)
+        in_turn = position > boundary
+        if uid is not None and uid in known:
+            if (said, state) in seen_versions[uid]:
+                continue  # an exact replay of this or an earlier version of the record
+            known_said, known_state = known[uid]
+            if said == known_said and state == (True, None) and known_state[1] is not None:
+                continue  # a stale open version of a stopped record; a stop never re-opens
+            previous_id = json.loads(known_said)[0]
+            if in_turn and known_said != said and (
+                    previous_id is None or previous_id != message.get("id")
+                    or previous_id in stopped_ids):
+                # A streaming block may be revised while its message is open; after the
+                # message stopped, or across messages, a changed record fails closed.
+                return ""
+            if in_turn and known_state != state and not (known_state == (True, None) and state[0]):
+                return ""  # only an explicitly open (null) stop_reason may change, to a value
+        if uid is not None:
+            known[uid] = (said, state)
+            seen_versions.setdefault(uid, set()).add((said, state))
+        if message.get("stop_reason") is not None:
+            stopped_ids.add(message.get("id"))
+        if in_turn:
+            turn.append((payload, message))
+    if not turn:
+        return ""
+    identityless = [_said(m) for p, m in turn if _uuid(p) is None]
+    if len(identityless) != len(set(identityless)):
+        return ""  # a repeated uuid-less record may be a replay
+    sequence: list[object] = []
+    for _, message in turn:
+        if not sequence or sequence[-1] != message.get("id"):
+            sequence.append(message.get("id"))
+    if len(sequence) != len(set(sequence)):
+        return ""  # a message id left and returned within the turn
+    final_id = sequence[-1]
+    if final_id is None:
+        group = [turn[-1]]  # identity-less messages are independent, never joined
+    else:
+        group = [(p, m) for p, m in turn if m.get("id") == final_id]
+    if any(_uuid(p) in history_uuids or _said(m) in history_said
+           or (m.get("id") is not None and m.get("id") in history_ids)
+           for p, m in group):
+        # A copy or update of history cannot answer a new request. Earlier messages of the
+        # turn may share a history id: the CLI writes a parallel tool call's next tool_use
+        # block under the same message id after the previous tool_result.
+        return ""
+    if final_id is None:
+        # An identity-less answer must not repeat any other assistant record, earlier in this
+        # turn or in history: a copy stripped of its message id cannot be told from a replay.
+        final_payload, final_message = group[0]
+        spoken = json.dumps([final_message.get("role"), final_message.get("content")], sort_keys=True)
+        if any(m is not final_message and m.get("role") == "assistant"
+               and (_uuid(final_payload) is None or _uuid(p) != _uuid(final_payload))
+               and json.dumps([m.get("role"), m.get("content")], sort_keys=True) == spoken
+               for p, m in records):
+            return ""
+    with_uuid = [(p, m) for p, m in group if _uuid(p) is not None]
+    if with_uuid and len(with_uuid) != len(group):
+        return ""  # uuid and uuid-less records cannot be told apart from a replay
+    if with_uuid:
+        latest: dict[str, tuple[dict, dict]] = {}
+        order: list[str] = []
+        for payload, message in group:
+            uid = _uuid(payload)
+            if uid not in latest:
+                order.append(uid)
+            latest[uid] = (payload, message)
+        final_records = [latest[uid] for uid in order]
+    else:
+        final_records = list(group)
+    versions = [m for _, m in final_records]
+    terminal_payload, terminal = final_records[-1]
+    # The president route checks every raw assistant record of the final turn: the answer's
+    # superseded versions and exact replays included (the replay rule ignores API-error and
+    # <synthetic> markers), and earlier messages of the turn too. After the last user record
+    # (a tool_result is a user record) a genuine final answer has no tool call, marker or
+    # non-final stop anywhere in its turn, so any of them fails closed on this route.
+    answer_records = list(group) + [
+        (p, m) for p, m in records[boundary + 1:] if m.get("role") == "assistant"
+    ]
+    if require_terminal and (
+        terminal.get("stop_reason") != "end_turn"
+        or any(m.get("stop_reason") not in (None, "end_turn") or m.get("model") == "<synthetic>"
+               or m.get("isApiErrorMessage") or p.get("isApiErrorMessage")
+               or not isinstance(m.get("content"), list)
+               or any(isinstance(item, dict) and item.get("type") == "tool_use" for item in m["content"])
+               for p, m in answer_records)
+    ):
+        return ""  # the president route needs a genuine, completed end_turn
+    if "stop_reason" in terminal and terminal["stop_reason"] is None:
+        return ""  # the message has not completed
+    texts: list[str] = []
+    for message in versions:
+        content = message.get("content")
+        if not isinstance(content, list):
+            return ""
+        if message.get("stop_reason") not in (None, "end_turn", "stop_sequence"):
+            return ""  # max_tokens, tool_use or another non-final stop
+        if any(isinstance(item, dict) and item.get("type") == "tool_use" for item in content):
+            return ""
+        texts.append("\n".join(
+            item["text"] for item in content
+            if isinstance(item, dict) and item.get("type") == "text" and isinstance(item.get("text"), str)
+        ))
+    return "\n".join(text for text in texts if text).strip(" \t\r\n")
 
 
 def _cleanup_broker_claude_transcript(
@@ -4831,7 +5004,12 @@ def _run_claude_tui_session(
     def _broker_final() -> str:
         if not allow_transcript_final or broker_transcript_path is None:
             return ""
-        return _final_assistant_text_from_jsonl(broker_transcript_path)
+        # A president may need a format re-ask. Hand its completed API turn to
+        # invoke_president even when the text lacks the required ruling grammar;
+        # never treat a streaming or partial transcript as that completed turn.
+        return _final_assistant_text_from_jsonl(
+            broker_transcript_path, require_terminal=mode == "president",
+        )
 
     def _pending_tool_uses() -> tuple[str, ...]:
         # Brokered Claude has an empty tool surface, so only the exact assistant
@@ -4969,8 +5147,15 @@ def _run_claude_tui_session(
                             return _finish(0, review_text, "claude_tui_file_output")
                         transcript_text = transcript_salvage or _transcript_text()
                         broker_final = _broker_final()
+                        if broker_final and review_monitor is not None and review_monitor.cancel.is_set():
+                            review_monitor.observe(terminal="user_cancel")
+                            return _finish(1, "", "review_operation_cancelled")
                         if broker_final and _completion_ok(broker_final, mode):
                             return _finish(0, broker_final, "claude_tui_broker_final_assistant")
+                        if broker_final and mode == "president":
+                            # Same completed-journal evidence as the conforming return above,
+                            # after the same cancellation re-check: hand it to the re-ask.
+                            return _finish(0, broker_final, "claude_tui_broker_terminal_nonconforming")
                         return _finish(
                             proc.poll() or 1,
                             review_text or transcript_text,
@@ -5090,16 +5275,26 @@ def _run_claude_tui_session(
                 if _completion_ok(transcript_text, mode):
                     transcript_salvage = transcript_text
                 broker_final = _broker_final()
+                if broker_final and review_monitor is not None and review_monitor.cancel.is_set():
+                    review_monitor.observe(terminal="user_cancel")
+                    return _finish(1, "", "review_operation_cancelled")
                 if broker_final and _completion_ok(broker_final, mode):
                     return _finish(0, broker_final, "claude_tui_broker_final_assistant")
+                if broker_final and mode == "president":
+                    return _finish(0, broker_final, "claude_tui_broker_terminal_nonconforming")
             if proc.poll() is not None:
                 review_text = _current_output()
                 transcript_text = transcript_salvage or _transcript_text()
                 if _completion_ok(review_text, mode):
                     return _finish(0, review_text, "claude_tui_file_output")
                 broker_final = _broker_final()
+                if broker_final and review_monitor is not None and review_monitor.cancel.is_set():
+                    review_monitor.observe(terminal="user_cancel")
+                    return _finish(1, "", "review_operation_cancelled")
                 if broker_final and _completion_ok(broker_final, mode):
                     return _finish(0, broker_final, "claude_tui_broker_final_assistant")
+                if broker_final and mode == "president":
+                    return _finish(0, broker_final, "claude_tui_broker_terminal_nonconforming")
                 detail = "claude_tui_missing_canonical_output"
                 return _finish(
                     proc.returncode or 1, review_text or transcript_text, detail

{phase_loop_runtime-0.7.18 → phase_loop_runtime-0.7.19}/src/phase_loop_runtime/roadmap_assumptions.py

@@ -28,8 +28,8 @@ from typing import Any, Mapping, Sequence
 PROBE_SIDECAR_REL = "specs/roadmap-assumption-probes-v10.json"
 PROBE_SCHEMA = "roadmap_assumption_probe.v1"
 CANONICAL_ROADMAP_REL = "specs/phase-plans-v10.md"
-CANONICAL_ROADMAP_SHA256 = "ae5b814a9be561ca78fdcf976e77bcc582a4e0a09c775563a8bbaf4daf740ff4"
-CANONICAL_PROBES_SHA256 = "42d473e2396df4c9dd2a9f98f9c330fa0362bfc51d3e1c99580ed48e3619ebf1"
+CANONICAL_ROADMAP_SHA256 = "124554d1ce4232b60c71e8fc71d3f4e334c6d63080f8d62f498cbed68d08eeae"
+CANONICAL_PROBES_SHA256 = "f8f6fd3f4e61b2e7f1c49260f6cec07a6cdb2b8cfb82ac145306f6cebd5d08c3"
 CANONICAL_PROBE_IDS = (
     "LEGIBLE-A1-CONFORM-UNGATED", "LEGIBLE-A1-I118", "LEGIBLE-A1-PIN-SHA",
     "LEGIBLE-A1-PIN-TAG", "LEGIBLE-A1-PR102", "LEGIBLE-A1-PR377",

{phase_loop_runtime-0.7.18 → phase_loop_runtime-0.7.19}/src/phase_loop_runtime/train_runner.py

@@ -2458,9 +2458,11 @@ def _append_blocked_keeping_admission(ledger_path: Path, node_id: str, *, branch
     except (OSError, ValueError):
         # Unreadable now: append NOTHING. A branch-only row would win the last-wins fold
         # once reads recover and erase the admission (agent-harness#978 round 11, codex).
-        # The binding stays the fold because no caller has appended over it: P4 callers
-        # append nothing before refusing, and P3 halts before its breadcrumb when its
-        # capture fails (round 12).
+        # For an ADMITTED node the binding stays the fold because no caller has appended
+        # over it: P4 callers append nothing before refusing, and P3 halts before its
+        # breadcrumb when its capture fails (round 12). This branch is also reachable for a
+        # fresh P3 node, whose breadcrumb is then the fold -- harmless, as a fresh node has
+        # no binding to lose (agent-harness#1064).
         return
     if latest is None:
         append_record(ledger_path, LedgerRecord(node_id=node_id, status="blocked", branch=branch))
@@ -2593,6 +2595,10 @@ def _run_train_unfenced(
     review_material: "Path | str | None" = None,
     # run-train --monitoring-policy: how the DEFAULT train review watches its seats.
     # "heartbeat_only" = no model deadline, frozen four-vendor board, no native seat.
+    # Scope (agent-harness#1065): only the default train-level review honours it. An
+    # injected ``_train_review_fn`` owns its own monitoring, and the FAB delta-shortcut
+    # review (``fab_delta_shortcut``; not exposed by the CLI) and per-node governed
+    # reviews keep theirs.
     review_monitoring_policy: str = "bounded",
     # P4 seams — unused when _merge_phase_enabled is False.
     _merge_pr_fn: Optional[Callable] = None,       # (workspace, branch, base, head_sha) → merged_sha

{phase_loop_runtime-0.7.18 → phase_loop_runtime-0.7.19}/src/phase_loop_runtime.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: phase-loop-runtime
-Version: 0.7.18
+Version: 0.7.19
 Summary: Harness-neutral phase-loop orchestration runtime and CLI
 Author-email: ViperJuice <viperjuice@users.noreply.github.com>
 License-Expression: Apache-2.0
@@ -49,7 +49,7 @@ To install just this runtime package directly:
 
 ```sh
 pip install phase-loop-runtime              # latest compatible release
-pip install phase-loop-runtime==0.7.18      # …or pin an exact version
+pip install phase-loop-runtime==0.7.19      # …or pin an exact version
 ```
 
 To pin a specific tag from source instead, substitute a tag from

{phase_loop_runtime-0.7.18 → phase_loop_runtime-0.7.19}/src/phase_loop_runtime.egg-info/SOURCES.txt

@@ -680,6 +680,7 @@ tests/test_outside_agent_vectors.py
 tests/test_owned_command_procfs_1003.py
 tests/test_packaged_vector_manifest_pin.py
 tests/test_panel_advisory_mode_63.py
+tests/test_panel_claude_review_output.py
 tests/test_panel_codex_auth_signature_body_252.py
 tests/test_panel_context_refs_114.py
 tests/test_panel_gemini_no_command_preamble.py

{phase_loop_runtime-0.7.18 → phase_loop_runtime-0.7.19}/tests/test_closeout_classifier.py

@@ -409,6 +409,40 @@ class TestIgnoredOutputAudit(unittest.TestCase):
                             f"spoofed runner dir must block: {result}")
             self.assertTrue(result[UNKNOWN_IGNORED])
 
+    def test_the_required_skill_handoff_root_does_not_block(self):
+        """agent-harness#1084: the handoff the skills must write, at the exact root the
+        resolver returns, passes the audit end to end; the ignore entry is the one the
+        skills direct.
+        """
+        from phase_loop_runtime.skill_paths import resolve_handoff_root
+
+        with TemporaryDirectory() as tmp:
+            repo = self._repo(tmp)
+            (repo / ".gitignore").write_text(
+                ".phase-loop/\n.ruff_cache/\n__pycache__/\n.venv/\nscratch/\n.dev-skills/handoffs/\n")
+            root = resolve_handoff_root(repo)
+            self.assertEqual(root, repo.resolve() / ".dev-skills" / "handoffs")
+            (root / "codex-execute-phase").mkdir(parents=True)
+            (root / "codex-execute-phase" / "latest.md").write_text("from: codex-execute-phase\n")
+            result = audit_ignored_outputs(repo)
+            self.assertFalse(result["blocks"], result)
+            self.assertEqual(result[UNKNOWN_IGNORED], [])
+
+    def test_only_the_exact_handoff_root_is_recognised(self):
+        for path in (".dev-skills/handoffs/", ".dev-skills/handoffs/claude-plan-phase/latest.md"):
+            verdict = classify_ignored_output(path)
+            self.assertEqual(verdict.provenance, RUNNER_OWNED, path)
+            self.assertFalse(verdict.blocks, path)
+        for path in (
+            ".dev-skills/handoffs",           # a FILE of that name
+            ".dev-skills/",                   # the parent, not the handoff root
+            ".dev-skills/other/x.md",
+            "nested/.dev-skills/handoffs/x",  # the name elsewhere in the tree
+            " .dev-skills/handoffs/x",        # leading whitespace
+            ".dev-skills/handoffs2/x",
+        ):
+            self.assertEqual(classify_ignored_output(path).provenance, UNKNOWN_IGNORED, path)
+
     def test_an_unknown_ignored_output_makes_the_audit_block(self):
         with TemporaryDirectory() as tmp:
             repo = self._repo(tmp)

{phase_loop_runtime-0.7.18 → phase_loop_runtime-0.7.19}/tests/test_legible_roadmap_contract.py

@@ -195,10 +195,10 @@ _FROZEN_ROADMAP_EXCERPT = """\
    / `verdict_schema_sha256`. CONFORM's pin work is therefore NO LONGER externally gated and is
    satisfiable against merged sources; EC-CONFORM-5/6/7 are re-derived accordingly below. (Swept
    the other four assumptions against current `main`: #2 subsequently reconciled — `governed-pipeline#128`
-   CLOSED, we still ship `0.7.18`; #3 holds — `tui_adapter_required` still present in
+   CLOSED, we still ship `0.7.19`; #3 holds — `tui_adapter_required` still present in
 
    stale; #2's later drift is reconciled below.)
-2. `governed-pipeline` pins agent-harness 0.7.14 while we ship 0.7.18; it has acted on
+2. `governed-pipeline` pins agent-harness 0.7.14 while we ship 0.7.19; it has acted on
    `governed-pipeline#128`, which is CLOSED. No phase here depends on that being resolved.
 3. The claude/fable board seat is structurally unavailable when the runtime drives the board from
 
@@ -1448,7 +1448,7 @@ ASSUMPTION_PROBES: tuple[dict[str, object], ...] = (
         "id": "LEGIBLE-A2-LOCAL-VERSION",
         "assumption": 2,
         "kind": "repo_constant",
-        "anchor": "we ship 0.7.18",
+        "anchor": "we ship 0.7.19",
         "mutation_id": "change-either-surface-alone",
         "positive_control_id": "current-equal-pair",
         "subject": {
@@ -1457,9 +1457,9 @@ ASSUMPTION_PROBES: tuple[dict[str, object], ...] = (
                 {"module": "phase_loop_runtime", "attribute": "__version__"},
             ]
         },
-        "expected": {"must_agree": True, "agreed_value": "0.7.18"},
-        "observation": {"values": ["0.7.18", "0.7.18"]},
-        "mutation": {"values": ["0.7.19", "0.7.18"]},
+        "expected": {"must_agree": True, "agreed_value": "0.7.19"},
+        "observation": {"values": ["0.7.19", "0.7.19"]},
+        "mutation": {"values": ["0.7.20", "0.7.19"]},
     },
     {
         "id": "LEGIBLE-A2-NO-DEPENDENCY",