@opengsd/gsd-path 1.4.0 → 1.6.0

package/skills/gsd-path-build/scripts/dispatch_driver.py

@@ -16,21 +16,24 @@ from __future__ import annotations
 import argparse
 import errno
 import hashlib
+import importlib
 import json
 import os
 import re
+import shlex
 import subprocess
 import sys
 import tempfile
 import time
 from datetime import datetime, timezone
 from pathlib import Path
-from typing import BinaryIO, Callable, Dict, List, Optional
+from typing import BinaryIO, Callable, Dict, List, Optional, Tuple
 
 try:
     from scripts import (_common, archive_milestone, build_state, discussion_validate, isolation,
                          pipeline_state, review_findings, review_panel, workflow_run, task_context, model_policy)
     from scripts import check_handoffs as contracts
+    from scripts.pipeline_git import is_bound_branch
 except ImportError:  # bundled copy inside a skill's scripts directory
     import _common
     import archive_milestone
@@ -44,6 +47,7 @@ except ImportError:  # bundled copy inside a skill's scripts directory
     import review_panel
     import workflow_run
     import model_policy
+    from pipeline_git import is_bound_branch
 
 if os.name == "nt":
     import msvcrt
@@ -71,12 +75,99 @@ class DriverStop(RuntimeError):
 STOP_ERRORS = (DriverStop, isolation.IsolationError, build_state.BuildStateError,
                contracts.HandoffError, review_findings.ReviewFindingsError,
                pipeline_state.PipelineStateError, archive_milestone.ArchiveError, model_policy.PolicyError)
+_RUNTIME_ACTIVATION_ORDER = (
+    "_common",
+    "roadmap",
+    "review_panel",
+    "loop_run",
+    "pipeline_git",
+    "worktree_paths",
+    "build_recovery",
+    "isolation",
+    "pipeline_state",
+    "state_checkpoint",
+    "check_task_briefs",
+    "build_state",
+    "check_handoffs",
+    "task_context",
+    # discussion_validate and archive_milestone import each other: the second
+    # reload binds the reloaded ArchiveError that STOP_ERRORS catches.
+    "discussion_validate",
+    "archive_milestone",
+    "discussion_validate",
+    "review_findings",
+    "model_policy",
+)
 RECOVERY_BLOCKED = "recovery blocked"
+LEFTOVER_ISOLATE = "task {} is landed; remove its leftover isolate: {}"
 # The stops the build contract answers with build/blocked when the round raises them (steps 1 and 2);
 # the same stops from review, panel, or skeptics stay with the parent.
 BLOCKING_STOPS = {"dependency-deadlock": "dependency deadlock", RECOVERY_BLOCKED: "blocked recovery"}
 
 
+def _bundled_helpers() -> bool:
+    return "scripts.isolation" not in sys.modules
+
+
+def _refresh_stop_errors() -> None:
+    global STOP_ERRORS
+    STOP_ERRORS = (DriverStop, isolation.IsolationError, build_state.BuildStateError,
+                   contracts.HandoffError, review_findings.ReviewFindingsError,
+                   pipeline_state.PipelineStateError, archive_milestone.ArchiveError,
+                   model_policy.PolicyError)
+
+
+def _reload_pinned_modules(runtime_root: Path) -> None:
+    global isolation, build_state, task_context, contracts, pipeline_state
+    global archive_milestone, review_findings, model_policy
+    if _bundled_helpers():
+        path = str(runtime_root)
+        if path not in sys.path:
+            sys.path.insert(0, path)
+        for name in _RUNTIME_ACTIVATION_ORDER:
+            module = sys.modules.get(name)
+            if module is not None:
+                importlib.reload(module)
+        isolation = sys.modules["isolation"]
+        build_state = sys.modules["build_state"]
+        task_context = sys.modules["task_context"]
+        contracts = sys.modules["check_handoffs"]
+        pipeline_state = sys.modules["pipeline_state"]
+        archive_milestone = sys.modules["archive_milestone"]
+        review_findings = sys.modules["review_findings"]
+        model_policy = sys.modules["model_policy"]
+    else:
+        import scripts
+        path = str(runtime_root)
+        if path not in scripts.__path__:
+            scripts.__path__ = [path, *[entry for entry in scripts.__path__ if entry != path]]
+        for name in _RUNTIME_ACTIVATION_ORDER:
+            module = sys.modules.get(f"scripts.{name}")
+            if module is not None:
+                importlib.reload(module)
+        isolation = scripts.isolation
+        build_state = scripts.build_state
+        task_context = scripts.task_context
+        contracts = scripts.check_handoffs
+        pipeline_state = scripts.pipeline_state
+        archive_milestone = scripts.archive_milestone
+        review_findings = scripts.review_findings
+        model_policy = scripts.model_policy
+    _refresh_stop_errors()
+
+
+def _activate_pinned_runtime(repo: Path) -> None:
+    if not os.path.lexists(repo / ".gsd-path/runtime.json"):
+        return
+    resolved = subprocess.run(
+        [sys.executable, "-B", str(repo / ".gsd-path/status_runtime.py"),
+         "--repo", str(repo), "--runtime-path"],
+        cwd=repo, capture_output=True, encoding="utf-8", errors="replace")
+    if resolved.returncode:
+        raise DriverStop(resolved.stderr.strip() or "pinned runtime resolution failed")
+    _reload_pinned_modules(Path(resolved.stdout.strip()))
+
+
 def now() -> str:
     return datetime.now(timezone.utc).isoformat(timespec="seconds")
 
@@ -107,6 +198,169 @@ def attempts_used(root: Path, task_id: str) -> int:
                if load_state(path).get("origin") == "dispatch")
 
 
+def dispatch_primary(worktree: Path) -> Path:
+    """The bound-branch primary that owns dispatch records for a task checkout."""
+    worktree = worktree.resolve()
+    if is_bound_branch(isolation.require_attached(worktree)):
+        return worktree
+    matches = [
+        path.resolve()
+        for path, branch in isolation._registered_worktrees(worktree).items()
+        if branch and is_bound_branch(branch.removeprefix("refs/heads/"))
+    ]
+    if len(matches) != 1:
+        raise isolation.IsolationError(
+            "dispatch records require exactly one primary worktree for the bound branch")
+    return matches[0]
+
+
+def should_open_native_shell(root: Path, task_id: str, base: str) -> bool:
+    """Whether activate-task should append a native dispatch attempt record."""
+    task_dir = root / task_id
+    if not task_dir.is_dir():
+        return True
+    attempts = sorted(task_dir.glob("attempt-*/state.json"),
+                      key=lambda path: attempt_number(path.parent))
+    if not attempts:
+        return True
+    latest = read_attempt(attempts[-1])
+    if latest.get("outcome") is None and not latest.get("command"):
+        return False
+    if latest.get("outcome") == "blocked" and str(latest.get("base")) == base:
+        return False
+    return True
+
+
+def open_native_shell(primary: Path, *, task_id: str, base: str, worktree: str, task_file: str,
+                      task_branch: Optional[str], mode: str, wave: Optional[int] = None,
+                      title: Optional[str] = None, files: Optional[List[str]] = None,
+                      sidecar: Optional[object] = None, member: Optional[str] = None,
+                      member_base: Optional[str] = None, contract_file: Optional[str] = None) -> None:
+    """Open a dispatch attempt record for a host-spawned coder before it runs."""
+    root = records_root(primary)
+    root.mkdir(parents=True, exist_ok=True)
+    record: Dict[str, object] = {
+        "task_id": task_id,
+        "base": base,
+        "worktree": worktree,
+        "task_file": task_file,
+        "task_branch": task_branch,
+        "mode": mode,
+        "origin": "dispatch",
+        "outcome": None,
+        "dispatched_at": now(),
+        "native": True,
+    }
+    if wave is not None:
+        record["wave"] = wave
+    if title is not None:
+        record["title"] = title
+    if files is not None:
+        record["files"] = files
+    if sidecar is not None:
+        record["sidecar"] = sidecar
+    if member is not None:
+        record["member"] = member
+    if member_base is not None:
+        record["member_base"] = member_base
+    if contract_file is not None:
+        record["contract_file"] = contract_file
+    task_dir = root / task_id
+    if not should_open_native_shell(root, task_id, base):
+        attempts = sorted(task_dir.glob("attempt-*/state.json"),
+                          key=lambda path: attempt_number(path.parent))
+        if not attempts:
+            return
+        state_path = attempts[-1]
+        state = load_state(state_path)
+        if state.get("outcome") is not None or state.get("command"):
+            return
+        attempt = state.get("attempt")
+        state.update(record)
+        if attempt is not None:
+            state["attempt"] = attempt
+        state["outcome"] = None
+        for key in ("pid", "finished_at", "exit_code", "timed_out", "reason", "question", "commit",
+                    "answer", "command", "usage_recorded"):
+            state.pop(key, None)
+        save_state(state_path, state)
+        exit_path = state_path.with_name("exit.json")
+        if exit_path.is_file():
+            exit_path.unlink()
+        return
+    attempt = max((attempt_number(path) for path in task_dir.glob("attempt-*")), default=0) + 1
+    attempt_dir = task_dir / f"attempt-{attempt}"
+    attempt_dir.mkdir(parents=True)
+    record["attempt"] = attempt
+    save_state(attempt_dir / "state.json", record)
+
+
+def record_native_activation(worktree: Path, activation: Dict[str, object]) -> None:
+    """Record a native task activation in the milestone dispatch ledger."""
+    primary = dispatch_primary(worktree)
+    task_file = str(activation["task_file"])
+    task_path = worktree / task_file
+    fields, _ = isolation.task_frontmatter(task_path.read_text(encoding="utf-8"))
+    task_id = str(activation.get("task_id") or (fields or {}).get("id"))
+    wave = None
+    if fields and fields.get("wave") is not None:
+        wave = int(fields["wave"])
+    open_native_shell(
+        primary,
+        task_id=task_id,
+        base=str(activation["base"]),
+        worktree=str(activation["worktree"]),
+        task_file=task_file,
+        task_branch=activation.get("task_branch"),
+        mode="parallel" if activation.get("task_branch") else "serial",
+        wave=wave,
+        title=str(fields.get("title")) if fields else None,
+        files=list(fields.get("files") or []) if fields else None,
+    )
+
+
+def record_native_member_activation(coordinator: Path, activation: Dict[str, object]) -> None:
+    """Record a native member-task activation in the coordinator dispatch ledger."""
+    task_file = str(activation["task_file"])
+    sidecar = Path(str(activation["worktree"]))
+    copy = Path(str(activation["copy"]))
+    fields, _ = isolation.task_frontmatter(copy.read_text(encoding="utf-8"))
+    task_id = str(activation.get("task_id") or (fields or {}).get("id"))
+    wave = None
+    if fields and fields.get("wave") is not None:
+        wave = int(fields["wave"])
+    open_native_shell(
+        coordinator,
+        task_id=task_id,
+        base=str(activation["base"]),
+        worktree=str(sidecar),
+        task_file=copy.relative_to(sidecar).as_posix(),
+        task_branch=str(activation["task_branch"]),
+        mode="member",
+        wave=wave,
+        title=str(fields.get("title")) if fields else None,
+        files=list(fields.get("files") or []) if fields else None,
+        member=str(activation["member"]),
+        member_base=str(activation["member_base"]),
+        contract_file=task_file,
+    )
+
+
+def reusable_shell_attempt(root: Path, state: Dict[str, object]) -> Optional[Path]:
+    """A native activation shell the driver can attach its child wrapper to."""
+    task_dir = root / str(state["task_id"])
+    attempts = sorted(task_dir.glob("attempt-*/state.json"),
+                      key=lambda path: attempt_number(path.parent))
+    if not attempts:
+        return None
+    prior = read_attempt(attempts[-1])
+    if prior.get("outcome") is not None or prior.get("command") or prior.get("pid"):
+        return None
+    if str(prior.get("base")) != str(state.get("base")):
+        return None
+    return attempts[-1].parent
+
+
 def acquire_lock(primary: Path) -> BinaryIO:
     root = records_root(primary)
     root.mkdir(parents=True, exist_ok=True)
@@ -307,7 +561,7 @@ def retain_selection(root: Path, state: Dict[str, object]) -> Dict[str, object]:
                 raise DriverStop('cannot redispatch while the previous child is active')
             if prior.get('model_selection'):
                 state['model_selection'] = prior['model_selection']
-            else:
+            elif prior.get('command'):
                 state['command'] = prior['command']
     reassignment = task_dir / 'model-reassignment.json'
     if reassignment.exists():
@@ -323,13 +577,23 @@ def spawn(root: Path, state: Dict[str, object], options: argparse.Namespace,
     state = retain_selection(root, state)
     task_dir = root / str(state["task_id"])
     argv, selection = selected_command(state, options, command or options.child_command)
-    attempt = max((attempt_number(path) for path in task_dir.glob("attempt-*")), default=0) + 1
-    attempt_dir = task_dir / f"attempt-{attempt}"
-    attempt_dir.mkdir(parents=True)
+    attempt_dir = reusable_shell_attempt(root, state)
+    if attempt_dir is None:
+        attempt = max((attempt_number(path) for path in task_dir.glob("attempt-*")), default=0) + 1
+        attempt_dir = task_dir / f"attempt-{attempt}"
+        attempt_dir.mkdir(parents=True)
+    else:
+        attempt = attempt_number(attempt_dir)
     stale = ("pid", "finished_at", "exit_code", "timed_out", "reason", "question", "commit", "answer",
              "usage_recorded")
-    state = {key: value for key, value in state.items()
-             if not key.startswith("_") and key not in stale}
+    incoming = {key: value for key, value in state.items()
+                if not key.startswith("_") and key not in stale}
+    if (attempt_dir / "state.json").is_file():
+        preserved = {key: value for key, value in read_attempt(attempt_dir / "state.json").items()
+                     if not key.startswith("_") and key not in stale}
+        state = {**preserved, **incoming}
+    else:
+        state = incoming
     if selection is not None:
         state['model_selection'] = selection
     state.update({"attempt": attempt, "command": argv,
@@ -384,6 +648,15 @@ def run_verify(command: str, cwd: Path) -> Dict[str, object]:
     return {"exit_code": completed.returncode, "stdout": completed.stdout, "stderr": completed.stderr}
 
 
+def landing_verify(command: str, regressions: List[Dict[str, object]],
+                   cwd: Path) -> Tuple[Dict[str, object], List[Dict[str, object]]]:
+    """The task's own Verify, then every regression Verify when the own one passes."""
+    execution = run_verify(command, cwd)
+    if execution["exit_code"]:
+        return execution, []
+    return execution, [{**item, **run_verify(str(item["command"]), cwd)} for item in regressions]
+
+
 def state_from_task(primary: Path, task_id: str) -> Dict[str, object]:
     """A finish-able state derived from the task frontmatter alone, for coders dispatched by hand."""
     tasks_dir = primary / ".project/tasks"
@@ -437,6 +710,22 @@ def state_from_task(primary: Path, task_id: str) -> Dict[str, object]:
 
 def finish_task(primary: Path, state: Dict[str, object]) -> Dict[str, object]:
     """Verify in the isolate, land, record the ledger, retire. Returns the landing receipt."""
+    landing = land_task(primary, state)
+    try:
+        if state["mode"] == "member":
+            isolation.retire_member_task(primary, str(state["member"]), str(state["task_id"]))
+        else:
+            isolation.retire(primary, Path(str(state["worktree"])), state.get("task_branch") or None, False)
+    except isolation.IsolationError as error:
+        # The landing is proven, so a failed removal is a warning; Round.recover checks the isolate again.
+        landing["cleanup_warning"] = (f"{error}; the task is landed, but its isolate was not removed. The next "
+                                      "round or finish checks the isolate again and stops if the isolate is "
+                                      "still there")
+    return landing
+
+
+def land_task(primary: Path, state: Dict[str, object]) -> Dict[str, object]:
+    """Verify in the isolate, land, record the ledger. Returns the landing receipt."""
     worktree = Path(str(state["worktree"]))
     task_id = str(state["task_id"])
     task_file = str(state["task_file"])
@@ -445,39 +734,59 @@ def finish_task(primary: Path, state: Dict[str, object]) -> Dict[str, object]:
     command = _common.task_verify_command(task_path.read_text(encoding="utf-8"))
     if not command:
         raise DriverStop("task has no Verify command", task=task_id)
+    # A later task can break an earlier task that shares a file; that task's Verify also decides this landing.
+    regressions = build_state.regression_verifies(primary, task_id, command)
+    # A plan-approved `supersedes` retires an earlier Verify; the receipt and the Log show each one.
+    retired = build_state.retired_verifies(primary, task_id)
+    superseded = {"retired": retired} if retired else {}
     if state["mode"] == "serial":
-        # ponytail: sidecar reproduction is git plumbing that belongs in isolation.py as the
-        # inverse of clean_verify; lift it there when a second caller appears.
         sidecar = state["sidecar"]
-        sidecar_path = Path(str(sidecar["worktree"]))
+        ensured = isolation.ensure_verify_sidecar(primary, base, str(sidecar["branch"]))
+        sidecar_path = Path(str(ensured["worktree"]))
         tree = snapshot_tree(primary)
-        isolation.git_output(sidecar_path, "read-tree", "-u", "--reset", tree)
-        if isolation.git_output(sidecar_path, "write-tree") != tree:
-            raise DriverStop("sidecar reproduction differs from the primary task diff", task=task_id)
-        execution = run_verify(command, sidecar_path)
+        try:
+            isolation.reproduce_verify_sidecar(sidecar_path, tree)
+        except isolation.IsolationError as error:
+            raise DriverStop(str(error), task=task_id) from error
+        execution, reruns = landing_verify(command, regressions, sidecar_path)
         location = f"sidecar {sidecar['branch']}"
         isolation.clean_verify(primary, sidecar_path, base, str(sidecar["branch"]))
         isolation.retire(primary, sidecar_path, str(sidecar["branch"]), False)
     else:
-        execution = run_verify(command, worktree)
+        execution, reruns = landing_verify(command, regressions, worktree)
         location = f"isolate {state['task_branch']}"
     passed = execution["exit_code"] == 0
+    broken = [item for item in reruns if item["exit_code"]]
     execution.update({"worktree": str(worktree), "location": location})
     evidence_dir = (Path(str(state["_path"])).parent if state.get("_path")
                     else records_root(primary) / task_id / f"manual-{now().replace(':', '')}")
     evidence_dir.mkdir(parents=True, exist_ok=True)
     _common.atomic_write(evidence_dir / "verify.json",
-                         json.dumps(execution, indent=2, sort_keys=True) + "\n")
+                         json.dumps({**execution, "regressions": reruns, **superseded},
+                                    indent=2, sort_keys=True) + "\n")
     execution["evidence"] = str(evidence_dir / "verify.json")
-    output = "\n".join(f"  {line}" for line in tail(execution["stdout"] + execution["stderr"]).splitlines())
-    append_log(task_path, f"- {now()[:10]} — orchestrator Verify ({location}): "
-                          f"{'pass' if passed else 'fail'}, exit {execution['exit_code']}"
-                          + (f"; output tail:\n  ```\n{output}\n  ```" if output else ""))
-    if not passed:
+    # The Verify of a superseding task runs in the place of the retired Verify: the label names both.
+    for label, run in [("Verify", execution),
+                       *((f"regression Verify of {', '.join(item['tasks'])}"
+                          + (f" (supersedes {', '.join(item['supersedes'])})" if item.get("supersedes") else ""),
+                          item) for item in reruns)]:
+        output = "\n".join(f"  {line}" for line in tail(run["stdout"] + run["stderr"]).splitlines())
+        append_log(task_path, f"- {now()[:10]} — orchestrator {label} ({location}): "
+                              f"{'fail' if run['exit_code'] else 'pass'}, exit {run['exit_code']}"
+                              + (f"; output tail:\n  ```\n{output}\n  ```" if output else ""))
+    for item in retired:
+        part = f": part of {item['part']}" if item.get("part") else ""
+        append_log(task_path, f"- {now()[:10]} — orchestrator regression Verify of {item['task']}{part} retired: "
+                              f"superseded by {item['superseded_by']}")
+    if not passed or broken:
         if state["mode"] == "parallel":
             isolation.deactivate_task(worktree, task_id, str(state["task_branch"]))
         elif state["mode"] == "member":
             isolation.deactivate_member_task(primary, str(state["member"]), task_id)
+        if passed:
+            names = ", ".join(name for item in broken for name in item["tasks"])
+            raise DriverStop(f"regression Verify of {names} failed in the isolate", task=task_id,
+                             execution=execution, regressions=broken)
         raise DriverStop("Verify failed in the isolate", task=task_id, execution=execution)
     if state["mode"] == "member":
         member = str(state["member"])
@@ -488,9 +797,9 @@ def finish_task(primary: Path, state: Dict[str, object]) -> Dict[str, object]:
         ledger = isolation.git_output(worktree, "rev-parse", f"{landing}^") == str(state["member_base"])
         if ledger:
             build_state.verify_record(str(primary), command, landing, "pass", execution=execution, member=member)
-        isolation.retire_member_task(primary, member, task_id)
         return {"task": task_id, "commit": str(landed["commit"]), "mode": "member",
-                "landing": landing, "verify": execution, "ledger": ledger}
+                "landing": landing, "verify": execution, "regressions": reruns, **superseded,
+                "ledger": ledger}
     landed = isolation.land(primary, worktree, base, task_id, str(state["title"]), task_file,
                             list(state["files"]))
     commit = str(landed["commit"])
@@ -498,9 +807,8 @@ def finish_task(primary: Path, state: Dict[str, object]) -> Dict[str, object]:
     ledger = isolation.git_output(primary, "rev-parse", f"{commit}^") == base
     if ledger:
         build_state.verify_record(str(primary), command, commit, "pass", execution=execution)
-    isolation.retire(primary, worktree, state.get("task_branch") or None, False)
     return {"task": task_id, "commit": commit, "mode": landed["mode"], "verify": execution,
-            "ledger": ledger}
+            "regressions": reruns, **superseded, "ledger": ledger}
 
 
 # --- shared by round and review --------------------------------------------
@@ -516,6 +824,11 @@ def recover_report(primary: Path, project_dir: str, receipt: Dict[str, object])
     report = isolation.recover(primary, Path(project_dir) / "tasks")
     receipt["steps"].append({"script": "isolation.py recover", "result": report})
     if report["verdict"] == "block":
+        blocked = [task for task in report["tasks"] if task["verdict"] == "block"]
+        if blocked and all(task.get("leftover") for task in blocked):
+            # Every blocked task is landed: the stop names only the isolates to remove, and the build stays active.
+            raise DriverStop("; ".join(LEFTOVER_ISOLATE.format(task["task_id"], task["leftover"])
+                                       for task in blocked), recover=blocked)
         raise DriverStop(RECOVERY_BLOCKED, recover=report)
     return report
 
@@ -651,7 +964,7 @@ class Round:
             self.receipt["steps"].append({"script": "isolation.recover_member_landing", "task": journal.stem,
                                           "result": result})
             if result["state"] == "landed":
-                isolation.retire_member_task(self.primary, str(result["member"]), journal.stem)
+                self.retire_member(str(result["member"]), journal.stem, str(result["landing"]))
                 retired_members.add(journal.stem)
         report = recover_report(self.primary, self.project_dir, self.receipt)
         for task in report["tasks"]:
@@ -659,26 +972,76 @@ class Round:
             verdict = task["verdict"]
             if verdict in ("recovered", "attested"):
                 self.proven[str(task.get("task_id"))] = str(task.get("commit"))
+            if (verdict == "reconcile" and task.get("status") == "in-progress"
+                    and task.get("task_branch") is None):
+                task_id = str(task.get("task_id"))
+                verify_name = f"task-{task_id.lower()}-verify"
+                verify_path = isolation.sidecar_root(self.primary, "verify", verify_name)
+                verify_branch = isolation.verify_branch_name(verify_name)
+                diagnose = shlex.join([
+                    sys.executable,
+                    "-B",
+                    str(Path(__file__).with_name("pipeline_diagnose.py")),
+                    "diagnose",
+                    "--repo",
+                    str(self.primary),
+                ])
+                raise DriverStop(
+                    f"task {task_id} needs recovery: {task.get('reason')}; inspect Verify "
+                    f"sidecar {verify_path} ({verify_branch}) before resetting it to pending; "
+                    f"inventory it with `{diagnose}`",
+                    recover=task,
+                )
             if verdict == "recovered" and task.get("member") and task.get("task_id") not in retired_members:
-                isolation.retire_member_task(self.primary, str(task["member"]), str(task["task_id"]))
+                self.retire_member(str(task["member"]), str(task["task_id"]), str(task["landing"]))
             if verdict == "recovered" and worktree and worktree["clean"] and task.get("task_branch"):
                 isolation.retire(self.primary, Path(str(worktree["path"])),
                                  str(task["task_branch"]), False)
-            elif (verdict == "recovered" and worktree is None and task.get("task_branch")) or (
-                    verdict == "resume" and (task.get("landing_retry") or task.get("dispatch_retry"))):
-                # ponytail: interrupted retirements and retries stay with the parent's documented
+            elif verdict == "recovered" and worktree is None and task.get("task_branch"):
+                # The isolate is gone and the landing is proven: retire proves the branch, then deletes it.
+                isolation.retire(self.primary, None, str(task["task_branch"]), True, str(task["commit"]))
+            elif verdict == "resume" and (task.get("landing_retry") or task.get("dispatch_retry")):
+                # ponytail: interrupted retries stay with the parent's documented
                 # procedure; failed/blocked reconciliation surfaces through ready's typed error.
                 raise DriverStop(f"task {task.get('task_id')} needs recovery: {verdict}", recover=task)
 
+    def retire_member(self, member: str, task_id: str, landing: str) -> None:
+        """Retire a landed member task's sidecar; a proven leftover of it is a stop that names only its path."""
+        checkout, project, _ = isolation._member_context(self.primary, member)
+        sidecar = isolation.sidecar_root(checkout, "task", f"{project}-{task_id}")
+        branch = f"refs/heads/{isolation.TASK_BRANCH_PREFIX}{project}-{task_id}"
+        tip = isolation.run_git(checkout, "rev-parse", "--verify", "--quiet", branch)
+        commits = [landing, *tip.stdout.split()]
+        try:
+            isolation.retire_member_task(self.primary, member, task_id)
+        except isolation.RemovalError as error:
+            # Missing files are a removal that stopped part way; every other state keeps the refusal.
+            if not (isolation.only_missing_files(sidecar)
+                    or isolation.holds_only_landed_files(checkout, sidecar, commits)):
+                raise
+            raise DriverStop(LEFTOVER_ISOLATE.format(task_id, sidecar), cleanup_error=str(error))
+        if isolation.holds_only_landed_files(checkout, sidecar, commits):
+            raise DriverStop(LEFTOVER_ISOLATE.format(task_id, sidecar))
+
     # settle exited children ---------------------------------------------
 
     def isolate_live(self, state: Dict[str, object]) -> bool:
-        """True while the isolate still holds the task as in-progress; the parent's recovery clears it."""
+        """Keep blocked attempts reportable until the corresponding task is reset."""
         task_path = Path(str(state["worktree"])) / str(state["task_file"])
         if not task_path.is_file():
             return False
         fields, _ = isolation.task_frontmatter(task_path.read_text(encoding="utf-8"))
-        return fields is not None and fields.get("status") == "in-progress"
+        if fields is None:
+            return False
+        if fields.get("status") == "in-progress":
+            return True
+        return (
+            state.get("mode") == "serial"
+            and fields.get("status") == "blocked"
+            and fields.get("id") == state.get("task_id")
+            and fields.get("base") == state.get("base")
+            and fields.get("task_branch") == "null"
+        )
 
     def settle(self) -> bool:
         """Classify every exited child. Returns True when a landing or redispatch changed the round."""
@@ -717,8 +1080,15 @@ class Round:
                 elif state.get("finished_at") is None:
                     if child_running(state):
                         self.receipt["in_flight"].append(self.summary(state))
+                    elif (state.get("native") and not state.get("command") and not state.get("pid")
+                          and self.isolate_live(state)):
+                        continue
                     else:
-                        self.fail(state, ORPHANED)
+                        state.update(read_attempt(Path(str(state["_path"]))))
+                        if state.get("finished_at") is not None:
+                            changed = self.classify(state) or changed
+                        else:
+                            self.fail(state, ORPHANED)
                 else:
                     changed = self.classify(state) or changed
         return changed
@@ -729,6 +1099,35 @@ class Round:
         update_state(state, outcome="blocked", reason=reason)
         self.receipt["blocked"].append({**self.summary(state), "reason": reason, **details})
 
+    def blocked_result(self, state: Dict[str, object], **diagnostics: object) -> bool:
+        """Record an explicit serial block and retire only its untouched Verify sidecar."""
+        reason = "child returned blocked"
+        details: Dict[str, object] = dict(diagnostics)
+        if state.get("mode") == "serial":
+            try:
+                task = isolation.block_serial_task(
+                    self.primary,
+                    str(state["task_file"]),
+                    str(state["task_id"]),
+                    str(state["base"]),
+                )
+            except STOP_ERRORS as error:
+                self.fail(state, f"{reason}; could not record blocked task: {error}")
+                return False
+            details["task"] = task
+            sidecar = state.get("sidecar")
+            if isinstance(sidecar, dict):
+                worktree = Path(str(sidecar["worktree"]))
+                branch = str(sidecar["branch"])
+                try:
+                    details["verify_cleanup"] = isolation.retire_unused_verify(
+                        self.primary, worktree, str(state["base"]), branch
+                    )
+                except STOP_ERRORS as error:
+                    reason += f"; Verify sidecar retained at {worktree}: {error}"
+        self.fail(state, reason, **details)
+        return False
+
     def classify(self, state: Dict[str, object]) -> bool:
         attempt_dir = Path(str(state["_path"])).parent
         if self.budgeted and not state.get("usage_recorded"):
@@ -756,6 +1155,10 @@ class Round:
             update_state(state, outcome="question", question=unanswered[0], answered=False)
             self.receipt["questions"].append({**self.summary(state), "question": unanswered[0],
                                               "log_delta": delta.strip()})
+        elif verdict == "blocked" and named == str(state["task_id"]).lower():
+            return self.blocked_result(
+                state, stdout_tail=tail(message), log_delta=delta.strip()
+            )
         elif verdict != "ready" or named != str(state["task_id"]).lower():
             self.fail(state, "child returned blocked" if verdict == "blocked"
                       else "child returned no RESULT line", stdout_tail=tail(message),
@@ -790,8 +1193,14 @@ class Round:
     # dispatch -------------------------------------------------------------
 
     def in_flight_states(self) -> List[Dict[str, object]]:
-        return [state for state in latest_states(self.root)
-                if state.get("outcome") is None and state.get("wave") == self.receipt["wave"]]
+        states = []
+        for state in latest_states(self.root):
+            if state.get("outcome") is not None or state.get("wave") != self.receipt["wave"]:
+                continue
+            if state.get("native") and not state.get("command") and not state.get("pid"):
+                continue
+            states.append(state)
+        return states
 
     def checkpoint_bookkeeping(self) -> None:
         open_ids = {state["task_id"] for state in latest_states(self.root)
@@ -815,6 +1224,24 @@ class Round:
         ready = build_state.ready(str(self.primary), self.project_dir)
         self.receipt["steps"].append({"script": "build_state.py ready", "result": ready})
         wave = ready["current_wave"]
+        blocked_review = ready.get("blocked_review")
+        if blocked_review:
+            waiting_waves = blocked_review["waiting_waves"]
+            if self.receipt["wave"] in waiting_waves:
+                raise DriverStop(
+                    f"wave {self.receipt['wave']} has unfinished tasks but wave "
+                    f"{blocked_review['wave']} review cycle {blocked_review['cycle']} "
+                    "is blocked; it must pass before dispatch")
+            self.checkpoint_bookkeeping()
+            return not in_flight
+        repair_for_wave = ready.get("repair_for_wave")
+        if repair_for_wave is not None and self.receipt["wave"] != wave:
+            if self.receipt["wave"] > repair_for_wave:
+                raise DriverStop(
+                    f"wave {self.receipt['wave']} is waiting on blocked wave {repair_for_wave}; "
+                    f"dispatch repair wave {wave} first")
+            self.checkpoint_bookkeeping()
+            return not in_flight
         if wave is not None and wave < self.receipt["wave"]:
             raise DriverStop(f"wave {wave} is still unfinished; run round --wave {wave} first")
         self.checkpoint_bookkeeping()
@@ -881,7 +1308,7 @@ class Round:
                 continue
             prepared = self.runner("prepare-task", head, task["id"], round_size)
             isolate = prepared[0]["result"]
-            sidecar = prepared[1]["result"] if len(prepared) > 1 else None
+            sidecar = prepared[-1]["result"] if len(prepared) > 1 else None  # the isolate-verify step is last
             worktree = Path(str(isolate["worktree"]))
             isolation.activate_task(worktree, head, task["id"], f"build_{task['id'].lower()}",
                                     task["task_file"], isolate["task_branch"])
@@ -1657,6 +2084,23 @@ def next_task_id(tasks_dir: Path) -> str:
     return f"T{max(numbers, default=0) + 1:03d}"
 
 
+def replaced_review_base(primary: Path, project_dir: str, wave: int, cycle: int) -> Optional[str]:
+    """The recovery base when this cycle's review replaces the one a build recovery set aside, else None."""
+    recovery = pipeline_state._build_recovery().context(primary)
+    if not recovery:
+        return None
+    relative = f"{project_dir}/review/wave-{wave}.cycle{cycle}.md"
+    before = isolation.run_git(primary, "show", f"{recovery['base']}:{relative}")
+    current = primary / relative
+    # Plan approval restores the review of an unchanged wave before its checkpoint, so no commit
+    # since the base touches that file. A set-aside review is deleted by that checkpoint.
+    rewritten = isolation.run_git(primary, "log", "-1", "--format=%H", f"{recovery['base']}..HEAD", "--", relative)
+    if (not rewritten.stdout.strip() and before.returncode == 0 and current.is_file()
+            and current.read_text(encoding="utf-8") == before.stdout):
+        return None  # the restored review keeps its repairs
+    return recovery["base"]
+
+
 def fix_tasks(primary: Path, options: argparse.Namespace) -> Dict[str, object]:
     """Step 7: one fix task per findings batch, carrying failed criteria and observations verbatim."""
     receipt: Dict[str, object] = {"status": None, "wave": options.wave, "cycle": options.cycle,
@@ -1665,14 +2109,32 @@ def fix_tasks(primary: Path, options: argparse.Namespace) -> Dict[str, object]:
         project = primary / options.project_dir
         tasks_dir = project / "tasks"
         repairs = []
+        pending = []
         for path in sorted(tasks_dir.glob("*-fix-wave-*-cycle-*.md")):
             text = path.read_text(encoding="utf-8")
             fields, _ = isolation.task_frontmatter(text)
             repairs.append({"task": fields["id"], "path": path.relative_to(primary).as_posix(),
-                            "wave": int(fields["wave"]), "locators": re.findall(r"(?m)^### (.+)$", _common.section_body(text, "Review findings") or "")})
+                            "wave": int(fields["wave"]), "locators": re.findall(r"(?m)^### (.+)$", _common.section_body(text, "Review findings") or ""),
+                            **({"repo": fields["repo"]} if fields.get("repo") else {})})
+            if fields["status"] != "done":
+                pending.append(repairs[-1])
         suffix = f"-fix-wave-{options.wave}-cycle-{options.cycle}.md"
-        existing = [item for item in repairs if item["path"].endswith(suffix)]
-        carried = {locator for item in repairs if item not in existing for locator in item["locators"]}
+        # A build recovery restarts a changed wave at cycle 1, so the repairs and the PLAN heading
+        # of the review it set aside carry the same names. They belong to that review, not this one.
+        replaced = replaced_review_base(primary, options.project_dir, options.wave, options.cycle)
+
+        def of_replaced_review(relative: str) -> bool:
+            if not replaced or isolation.run_git(primary, "show", f"{replaced}:{relative}").returncode != 0:
+                return False
+            return not isolation.run_git(primary, "log", "--diff-filter=AD", "--format=%H",
+                                         f"{replaced}..HEAD", "--", relative).stdout.strip()
+
+        stale = [item for item in repairs if item["path"].endswith(suffix) and of_replaced_review(item["path"])]
+        existing = [item for item in repairs if item["path"].endswith(suffix) and item not in stale]
+        # A landed repair no longer carries its finding: a repeat proves that fix failed and needs the next one.
+        # Two repos can carry the same locator, so a repair carries a finding only in its own repo.
+        carried = {(item.get("repo"), locator) for item in pending if not item["path"].endswith(suffix)
+                   for locator in item["locators"]}
         findings = review_findings.compute(primary, options.project_dir, options.wave, options.cycle)
         receipt["findings"] = findings
         escalation = [key for key in ("structural_blockers", "skeptic_groups", "cap_reached", "all_refuted")
@@ -1686,15 +2148,17 @@ def fix_tasks(primary: Path, options: argparse.Namespace) -> Dict[str, object]:
         texts = contracts._task_texts(primary, options.project_dir)
         groups = {group["locator"]: group for group in findings["groups"]}
         today = now()[:10]
-        # Same-wave file overlap is forbidden, so repairs land in a newly appended wave.
+        # Unordered same-wave file overlap is rejected, so repairs land in a newly appended wave.
         plan_path = project / "plan/PLAN.md"
         plan_text = plan_path.read_text(encoding="utf-8")
         depths, waves = contracts._plan_waves(plan_text)
         repair_waves = {item["wave"] for item in existing}
         if len(repair_waves) > 1:
             raise DriverStop("repair tasks for this cycle disagree on their wave")
-        repair_heading = re.search(
+        stale_waves = {item["wave"] for item in stale}
+        repair_heading = next((heading for heading in re.finditer(
             rf"(?m)^## Wave (\d+) — fix wave {options.wave} cycle {options.cycle} review findings$", plan_text)
+            if int(heading.group(1)) not in stale_waves), None)
         if repair_waves:
             fix_wave = next(iter(repair_waves))
         elif repair_heading:
@@ -1705,9 +2169,10 @@ def fix_tasks(primary: Path, options: argparse.Namespace) -> Dict[str, object]:
             raise DriverStop("repair tasks disagree with the PLAN repair wave")
         receipt["existing"] = existing
         for batch in findings["fix_batches"]:
-            if any(set(batch["locators"]) <= set(item["locators"]) for item in existing):
+            repo = batch.get("repo")  # a member name, or None for the coordinator
+            if any(item.get("repo") == repo and set(batch["locators"]) <= set(item["locators"]) for item in existing):
                 continue
-            if all(locator in carried for locator in batch["locators"]):
+            if all((repo, locator) in carried for locator in batch["locators"]):
                 receipt["carried"].append(batch)
                 continue
             batch_groups = [groups[locator] for locator in batch["locators"]]
@@ -1715,9 +2180,15 @@ def fix_tasks(primary: Path, options: argparse.Namespace) -> Dict[str, object]:
             for source in sources:
                 if source not in texts:
                     raise DriverStop(f"fix batch names unknown task {source}")
+            # One task changes one repo: the fix depends on, and runs the Verify of, the source tasks of its repo.
+            sources = [source for source in sources if isolation.task_frontmatter(texts[source])[0].get("repo") == repo]
+            # A repeat builds on the landed repairs of its finding: repair-evidence links them by this dependency.
+            deps = sources + [item["task"] for item in repairs
+                              if item not in pending and item.get("repo") == repo
+                              and f"-fix-wave-{options.wave}-cycle-" in item["path"] and not item["path"].endswith(suffix)
+                              and set(item["locators"]) & set(batch["locators"])]
             task_id = next_task_id(tasks_dir)
-            verify = "set -e\n" + "\n".join(  # each source Verify in its own subshell
-                f"(\n{command}\n)" for command in dict.fromkeys(_common.task_verify_command(texts[source]) for source in sources))
+            verify = _common.fix_verify(_common.task_verify_command(texts[source]) for source in sources)
             heavy = any(re.search(r"(?m)^Heavy:\s*yes", texts[source]) for source in sources)
             criteria = "\n".join(f"{index}. {criterion}" for index, criterion in
                                  enumerate(dict.fromkeys(group["criterion"] for group in batch_groups), 1))
@@ -1725,18 +2196,19 @@ def fix_tasks(primary: Path, options: argparse.Namespace) -> Dict[str, object]:
                 f"### {group['locator']}\nCriterion: {group['criterion']}\n"
                 + "\n".join(f"- {item['text']}" for item in group["observations"]) for group in batch_groups)
             files = "\n".join(f"  - {path}" for path in batch["files"])
+            member = f"repo: {repo}\n" if repo else ""  # the task template puts `repo:` before `files:`
             title = f"Fix wave {options.wave} cycle {options.cycle} review findings in {', '.join(sources)}"
             text = f"""---
 id: {task_id}
 title: {title}
 wave: {fix_wave}
-deps: [{', '.join(sources)}]
+deps: [{', '.join(deps)}]
 status: pending
 agent: null
 base: null
 worktree: null
 task_branch: null
-files:
+{member}files:
 {files}
 ---
 
@@ -1785,8 +2257,8 @@ Heavy: {'yes' if heavy else 'no'}
             path = tasks_dir / f"{task_id}-fix-wave-{options.wave}-cycle-{options.cycle}.md"
             _common.atomic_write(path, text)
             receipt["created"].append({"task": task_id, "path": path.relative_to(primary).as_posix(),
-                                       "wave": fix_wave, "deps": sources, "files": batch["files"],
-                                       "locators": batch["locators"]})
+                                       "wave": fix_wave, "deps": deps, "files": batch["files"],
+                                       "locators": batch["locators"], **({"repo": repo} if repo else {})})
         rows = []
         for item in [*existing, *receipt["created"]]:
             fields, _ = isolation.task_frontmatter((primary / item["path"]).read_text(encoding="utf-8"))
@@ -1820,7 +2292,8 @@ Heavy: {'yes' if heavy else 'no'}
         receipt["plan_wave"] = fix_wave
         lint = subprocess.run([sys.executable, "-B", str(Path(__file__).resolve().parent / "check_task_briefs.py"),
                                "--repo", str(primary), "--base", isolation.current_sha(primary),
-                               "--tasks-dir", f"{options.project_dir}/tasks"], capture_output=True, encoding="utf-8", errors="replace")
+                               "--tasks-dir", f"{options.project_dir}/tasks",
+                               "--project-dir", options.project_dir], capture_output=True, encoding="utf-8", errors="replace")
         receipt["steps"].append({"script": "check_task_briefs.py", "exit_code": lint.returncode,
                                  "stdout": lint.stdout, "stderr": lint.stderr})
         if lint.returncode:
@@ -1935,7 +2408,11 @@ def positive_int(value: str) -> int:
 
 
 def default_resource(name: str) -> Optional[Path]:
-    candidate = Path(__file__).resolve().parent.parent / name
+    script_root = Path(__file__).resolve().parent.parent
+    candidate = script_root / name
+    if candidate.is_file():
+        return candidate
+    candidate = script_root / "skills" / "gsd-path" / name
     return candidate if candidate.is_file() else None
 
 
@@ -2026,6 +2503,7 @@ def main(argv=None) -> int:
     if arguments.action == "_child":
         return child_main(arguments.state)
     primary = arguments.repo.resolve()
+    _activate_pinned_runtime(primary)
     lock = None
     try:
         if arguments.action != "status":
@@ -2065,6 +2543,10 @@ def main(argv=None) -> int:
                 if native and native["base"] != records[0].get("base"):
                     records = []
                 else:
+                    if (native and records[0]["outcome"] == "blocked" and records[0].get("native")
+                            and not records[0].get("command")):
+                        # A failed finish leaves a host-dispatched task active at its base: finish may run again.
+                        update_state(records[0], outcome=None, reason=None)
                     native = None
             if arguments.task_id in current.proven:
                 commit = current.proven[arguments.task_id]
@@ -2078,8 +2560,22 @@ def main(argv=None) -> int:
                     raise DriverStop(f"task {arguments.task_id} dispatch record is {record['outcome']}; "
                                      "use round")
                 if record.get("finished_at") is None:
-                    raise DriverStop(f"task {arguments.task_id} still has a running child")
-                current.classify(record)
+                    if child_running(record):
+                        raise DriverStop(f"task {arguments.task_id} still has a running child")
+                    if record.get("command"):
+                        raise DriverStop(f"task {arguments.task_id} still has a running child")
+                    live = state_from_task(primary, arguments.task_id)
+                    merged = dict(record, **live)
+                    merged["_path"] = record["_path"]
+                    try:
+                        landing = finish_task(primary, merged)
+                    except STOP_ERRORS as error:
+                        update_state(record, outcome="blocked", reason=str(error))
+                        raise
+                    update_state(record, outcome="landed", commit=landing["commit"])
+                    current.receipt["landed"].append(landing)
+                else:
+                    current.classify(record)
             else:  # a coder dispatched by hand: derive the isolate from the task frontmatter
                 current.receipt["landed"].append(
                     finish_task(primary, native or state_from_task(primary, arguments.task_id)))