@opengsd/gsd-path 1.3.1 → 1.5.0

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

@@ -16,11 +16,11 @@ from __future__ import annotations
 import argparse
 import errno
 import hashlib
+import importlib
 import json
 import os
 import re
 import shlex
-import signal
 import subprocess
 import sys
 import tempfile
@@ -33,6 +33,7 @@ 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
@@ -46,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
@@ -73,12 +75,91 @@ 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",
+    "pipeline_git",
+    "worktree_paths",
+    "build_recovery",
+    "isolation",
+    "pipeline_state",
+    "state_checkpoint",
+    "check_task_briefs",
+    "build_state",
+    "check_handoffs",
+    "task_context",
+    "archive_milestone",
+    "review_findings",
+    "model_policy",
+)
 RECOVERY_BLOCKED = "recovery blocked"
 # 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")
 
@@ -109,6 +190,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)
@@ -170,12 +414,7 @@ def child_running(state: Dict[str, object]) -> bool:
     return state.get("finished_at") is None and bool(state.get("pid")) and process_alive(int(state["pid"]))
 
 
-def process_alive(pid: int) -> bool:
-    try:
-        os.kill(pid, 0)
-    except ProcessLookupError:
-        return False
-    return True
+process_alive = _common.process_alive
 
 
 # --- child process ---------------------------------------------------------
@@ -208,13 +447,13 @@ def child_main(state_path: Path) -> int:
     attempt_dir = state_path.parent
     with open(attempt_dir / "brief.md", "rb") as brief, \
             open(attempt_dir / "stdout", "wb") as out, open(attempt_dir / "stderr", "wb") as err:
-        process = subprocess.Popen(state["command"], cwd=state["worktree"], stdin=brief,
-                                   stdout=out, stderr=err, start_new_session=True)
+        process = _common.popen_group(_common.resolve_argv(state["command"]), cwd=state["worktree"],
+                                      stdin=brief, stdout=out, stderr=err)
         try:
             exit_code: Optional[int] = process.wait(timeout=state.get("child_timeout"))
             timed_out = False
         except subprocess.TimeoutExpired:
-            os.killpg(process.pid, signal.SIGKILL)
+            _common.kill_tree(process)
             process.wait()
             exit_code, timed_out = None, True
     save_state(attempt_dir / "exit.json",
@@ -224,6 +463,7 @@ def child_main(state_path: Path) -> int:
 
 def brief_text(state: Dict[str, object], role_brief: Path, task_template: Path) -> str:
     worktree = Path(str(state["worktree"]))
+    project_root = Path(str(state.get("project_root") or worktree))
     task_id = state["task_id"]
     agents = worktree / "AGENTS.md"
     workflow = worktree / "WORKFLOW.md"
@@ -234,12 +474,14 @@ def brief_text(state: Dict[str, object], role_brief: Path, task_template: Path)
         f"Work only in this worktree root: {worktree}",
         f"Task file: {worktree / str(state['task_file'])}",
         f"Task template: {task_template}",
-        f"INTENT.md: {worktree / '.project/intent/INTENT.md'}",
+        f"INTENT.md: {project_root / '.project/intent/INTENT.md'}",
         f"AGENTS.md: {agents if agents.exists() else 'absent'}",
         f"WORKFLOW.md: {workflow if workflow.exists() else 'absent'}",
         f"Recorded base: {state['base']}",
         f"Dispatch mode: {state['mode']} ("
         + ("the primary worktree on the bound branch" if state["mode"] == "serial"
+           else f"an isolated worktree of member {state['member']}; never touch the member team's "
+                "checkout or the coordinator" if state["mode"] == "member"
            else "an isolated task worktree; never touch the primary") + ").",
         "Next consumer: the build orchestrator reruns Verify in an isolated checkout and lands "
         "the task. Gate: Verify passes and only the task's declared files plus its Log changed.",
@@ -248,7 +490,7 @@ def brief_text(state: Dict[str, object], role_brief: Path, task_template: Path)
     if state.get("answered"):
         lines.append(f"The task Log now records an `{ANSWER_MARK}` to your earlier question; "
                      "continue from it.")
-    lines.append(task_context.render(worktree, worktree / str(state['task_file'])))
+    lines.append(task_context.render(project_root, worktree / str(state['task_file'])))
     return "\n".join(lines) + "\n"
 
 
@@ -282,7 +524,7 @@ def selected_command(state: Dict[str, object], options: argparse.Namespace, comm
     if caps_path is None:
         if overrides or previous or model_policy.policy_path(primary, project_dir).exists():
             raise model_policy.PolicyError('model policy requires --model-capabilities for this dispatch')
-        return shlex.split(command), None
+        return _common.split_command(command), None
     caps = model_policy.read_json(caps_path)
     action = getattr(options, 'action', 'round')
     role = {'round': 'coder', 'review': 'reviewer', 'panel': 'review_panel',
@@ -297,7 +539,7 @@ def selected_command(state: Dict[str, object], options: argparse.Namespace, comm
                                               dict(overrides, model=state['slug']), previous)
         model_policy.validate_panel(selection, state['family'], state.get('excluded_families', []))
         state['slug'] = selection['selected']['model']
-    return model_policy.command_args(shlex.split(command), selection), selection
+    return model_policy.command_args(_common.split_command(command), selection), selection
 
 
 def retain_selection(root: Path, state: Dict[str, object]) -> Dict[str, object]:
@@ -311,7 +553,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():
@@ -327,25 +569,35 @@ 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,
                   "child_timeout": options.child_timeout, "outcome": None,
                   "dispatched_at": now(), "origin": "question" if state.get("answered") else "dispatch"})
     state_path = attempt_dir / "state.json"
-    (attempt_dir / "brief.md").write_text(brief(state), encoding="utf-8")
+    (attempt_dir / "brief.md").write_bytes(brief(state).encode("utf-8"))
     save_state(state_path, state)
-    wrapper = subprocess.Popen(
+    wrapper = _common.popen_detached(
         [sys.executable, "-B", str(Path(__file__).resolve()), "_child", "--state", str(state_path)],
         cwd=state["worktree"], stdin=subprocess.DEVNULL, stdout=subprocess.DEVNULL,
-        stderr=subprocess.DEVNULL, start_new_session=True,
+        stderr=subprocess.DEVNULL,
     )
     state["_path"] = str(state_path)
     update_state(state, pid=wrapper.pid)
@@ -356,8 +608,11 @@ def spawn(root: Path, state: Dict[str, object], options: argparse.Namespace,
 
 
 def log_delta(primary: Path, state: Dict[str, object]) -> str:
-    base_text = isolation.git_text(primary, "show", f"{state['base']}:{state['task_file']}")
+    contract_file = state.get("contract_file") or state["task_file"]
+    base_text = isolation.git_text(primary, "show", f"{state['base']}:{contract_file}")
     text = (Path(str(state["worktree"])) / str(state["task_file"])).read_text(encoding="utf-8")
+    if state["mode"] == "member":
+        return isolation.member_log_delta(base_text, text)
     return isolation.task_log_delta(base_text, text)
 
 
@@ -374,14 +629,14 @@ def snapshot_tree(primary: Path) -> str:
         env = dict(os.environ, GIT_INDEX_FILE=str(Path(temporary) / "index"))
         for arguments in (("read-tree", "HEAD"), ("add", "-A"), ("write-tree",)):
             completed = subprocess.run(("git", "-C", str(primary), *arguments), env=env,
-                                       text=True, capture_output=True)
+                                       encoding="utf-8", errors="replace", capture_output=True)
             if completed.returncode:
                 raise DriverStop(f"git {' '.join(arguments)} failed: {completed.stderr.strip()}")
         return completed.stdout.strip()
 
 
 def run_verify(command: str, cwd: Path) -> Dict[str, object]:
-    completed = _common.run_command("bash", "-c", command, cwd=cwd)
+    completed = _common.run_command(*_common.bash_argv(command), cwd=cwd)
     return {"exit_code": completed.returncode, "stdout": completed.stdout, "stderr": completed.stderr}
 
 
@@ -394,6 +649,30 @@ def state_from_task(primary: Path, task_id: str) -> Dict[str, object]:
             break
     else:
         raise DriverStop(f"task {task_id} has no task file")
+    member = fields.get("repo")
+    if member:
+        # A member activation lives in the live copy inside its member sidecar.
+        try:
+            checkout, project, _ = isolation._member_context(primary, str(member))
+        except isolation.IsolationError as error:
+            raise DriverStop(str(error), task=task_id) from error
+        task_file = task_path.relative_to(primary).as_posix()
+        sidecar = isolation.sidecar_root(checkout, "task", f"{project}-{task_id}").resolve()
+        copy = isolation.member_task_copy(sidecar, task_file)
+        live, _ = isolation.task_frontmatter(copy.read_text(encoding="utf-8")) if copy.is_file() else ({}, None)
+        if not live or live.get("status") != "in-progress" or not live.get("base") or not live.get("member_base"):
+            raise DriverStop(f"member task {task_id} has no activated live copy in {sidecar}", task=task_id)
+        return {"task_id": task_id, "title": str(live.get("title")), "task_file": copy.relative_to(sidecar).as_posix(),
+                "contract_file": task_file, "files": list(live.get("files") or []), "base": str(live["base"]),
+                "worktree": str(sidecar), "task_branch": f"{isolation.TASK_BRANCH_PREFIX}{project}-{task_id}",
+                "mode": "member", "member": str(member), "member_base": str(live["member_base"]),
+                "project_root": str(primary), "sidecar": None}
+    if fields.get("status") != "in-progress" or not fields.get("base"):
+        # A parallel activation lives only in its isolate; the primary copy stays pending.
+        isolate = isolation.sidecar_root(primary, "task", task_id).resolve()
+        if isolation.authorized_task_worktree(isolate, isolation.require_bound(primary)):
+            fields, _ = isolation.task_frontmatter(
+                (isolate / task_path.relative_to(primary)).read_text(encoding="utf-8"))
     if fields.get("status") != "in-progress" or not fields.get("base"):
         raise DriverStop(f"task {task_id} is not an in-progress task with a recorded base")
     def value(key: str) -> Optional[str]:
@@ -423,14 +702,14 @@ def finish_task(primary: Path, state: Dict[str, object]) -> Dict[str, object]:
     if not command:
         raise DriverStop("task has no Verify command", task=task_id)
     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)
+        try:
+            isolation.reproduce_verify_sidecar(sidecar_path, tree)
+        except isolation.IsolationError as error:
+            raise DriverStop(str(error), task=task_id) from error
         execution = run_verify(command, sidecar_path)
         location = f"sidecar {sidecar['branch']}"
         isolation.clean_verify(primary, sidecar_path, base, str(sidecar["branch"]))
@@ -453,7 +732,21 @@ def finish_task(primary: Path, state: Dict[str, object]) -> Dict[str, object]:
     if not passed:
         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)
         raise DriverStop("Verify failed in the isolate", task=task_id, execution=execution)
+    if state["mode"] == "member":
+        member = str(state["member"])
+        landed = isolation.land_member(primary, member, task_id, str(state["title"]),
+                                       str(state["contract_file"]), base, str(state["member_base"]))
+        landing = str(landed["landing"])
+        # Only a landing whose parent is the member base proves the verified member tree.
+        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}
     landed = isolation.land(primary, worktree, base, task_id, str(state["title"]), task_file,
                             list(state["files"]))
     commit = str(landed["commit"])
@@ -485,7 +778,8 @@ def recover_report(primary: Path, project_dir: str, receipt: Dict[str, object])
 
 def checkpoint_project(primary: Path, receipt: Dict[str, object], subject: str, body: str) -> Optional[str]:
     """Commit .project bookkeeping through the canonical checkpoint; None when nothing is dirty."""
-    if not any(path.startswith(".project/") for path in isolation.uncommitted_paths(primary)):
+    if not any(path.startswith(".project/") for path in isolation.uncommitted_paths(primary)) \
+            and not isolation.ignored_legacy_ledger(primary):
         return None
     result = isolation.checkpoint(primary, isolation.current_sha(primary), subject, body, [".project"])
     receipt["steps"].append({"script": "isolation.py checkpoint", "result": result})
@@ -582,7 +876,7 @@ class Round:
         """Run the bundled token_budget.py against this milestone's ledger; blocked is a stop."""
         command = [sys.executable, "-B", str(Path(__file__).resolve().parent / "token_budget.py"),
                    action, "--ledger", str(budget_ledger(self.primary)), *arguments]
-        completed = subprocess.run(command, cwd=self.primary, capture_output=True, text=True)
+        completed = subprocess.run(command, cwd=self.primary, capture_output=True, encoding="utf-8", errors="replace")
         result = json.loads(completed.stdout) if completed.stdout.strip() else {}
         self.receipt["steps"].append({"script": f"token_budget.py {action}", "command": command,
                                       "exit_code": completed.returncode, "result": result,
@@ -605,12 +899,44 @@ class Round:
     # recovery -------------------------------------------------------------
 
     def recover(self) -> None:
+        # A journaled member landing is safe to finish; it never lands the same work twice.
+        journals = isolation.common_git_dir(self.primary).joinpath(*isolation.MEMBER_LANDING_DIR)
+        retired_members = set()
+        for journal in sorted(journals.glob("*.json")) if journals.is_dir() else []:
+            result = isolation.recover_member_landing(self.primary, journal.stem)
+            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)
+                retired_members.add(journal.stem)
         report = recover_report(self.primary, self.project_dir, self.receipt)
         for task in report["tasks"]:
             worktree = task.get("worktree")
             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"]))
             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)
@@ -623,12 +949,22 @@ class Round:
     # 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."""
@@ -667,8 +1003,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
@@ -679,6 +1022,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"):
@@ -706,6 +1078,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),
@@ -730,6 +1106,8 @@ class Round:
         if state.get("wave") != self.receipt["wave"]:
             raise DriverStop("task is outside the requested wave", task=state["task_id"],
                              wave=state.get("wave"), requested_wave=self.receipt["wave"])
+        if state.get("mode") == "member":
+            isolation.ensure_member_hooks(self.primary, str(state["member"]), str(state["task_id"]))
         fresh = spawn(self.root, state, self.options,
                       lambda fresh: brief_text(fresh, self.options.role_brief, self.options.task_template))
         self.receipt["dispatched"].append(self.summary(fresh))
@@ -738,8 +1116,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)
@@ -763,6 +1147,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()
@@ -805,6 +1207,28 @@ class Round:
         self.runner("lint-round", head)
         round_size = len(selected) + len(in_flight)
         for task in selected:
+            if task.get("repo"):
+                member = str(task["repo"])
+                retained = isolation.retained_member_task(self.primary, member, task["id"],
+                                                          task["task_file"], head)
+                if retained and retained["state"] == "unused":
+                    isolation.retire_member_task(self.primary, member, task["id"])
+                    retained = None
+                if retained:
+                    isolate, active = retained["isolate"], retained["active"]
+                else:
+                    isolate = isolation.isolate_member_task(self.primary, member, task["id"])
+                    active = isolation.activate_member_task(self.primary, member, task["id"],
+                                                            f"build_{task['id'].lower()}", task["task_file"], head)
+                sidecar_path = Path(str(active["worktree"]))
+                self.launch({"task_id": task["id"], "title": task["title"],
+                             "task_file": Path(str(active["copy"])).relative_to(sidecar_path).as_posix(),
+                             "contract_file": task["task_file"], "files": task["files"], "wave": task["wave"],
+                             "verify_heavy": task["verify_heavy"], "base": head, "worktree": str(sidecar_path),
+                             "task_branch": isolate["task_branch"], "mode": "member", "member": member,
+                             "member_base": isolate["member_base"], "project_root": str(self.primary),
+                             "sidecar": None, "answered": False, "model_selection": task['model_selection']})
+                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
@@ -1178,7 +1602,7 @@ class Review:
 def helper_json(receipt: Dict[str, object], script: str, *arguments: str, cwd: Path) -> Dict[str, object]:
     """Run a bundled helper and return its JSON stdout; a non-zero exit is a typed stop."""
     command = [sys.executable, "-B", str(Path(__file__).resolve().parent / script), *arguments]
-    completed = subprocess.run(command, cwd=cwd, capture_output=True, text=True)
+    completed = subprocess.run(command, cwd=cwd, capture_output=True, encoding="utf-8", errors="replace")
     step = {"script": script, "command": command, "exit_code": completed.returncode,
             "stdout": completed.stdout, "stderr": completed.stderr}
     receipt["steps"].append(step)
@@ -1612,7 +2036,7 @@ 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)
@@ -1746,7 +2170,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, text=True)
+                               "--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:
@@ -1861,7 +2286,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
 
 
@@ -1952,6 +2381,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":
@@ -1981,6 +2411,17 @@ def main(argv=None) -> int:
             current.recover()
             records = [state for state in latest_states(current.root)
                        if state["task_id"] == arguments.task_id]
+            native = None
+            if records and records[0].get("outcome") is not None:
+                # A settled driver record at an older base is superseded by a native retry.
+                try:
+                    native = state_from_task(primary, arguments.task_id)
+                except DriverStop:
+                    pass
+                if native and native["base"] != records[0].get("base"):
+                    records = []
+                else:
+                    native = None
             if arguments.task_id in current.proven:
                 commit = current.proven[arguments.task_id]
                 if records and records[0].get("outcome") is None:
@@ -1993,11 +2434,25 @@ 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, state_from_task(primary, arguments.task_id)))
+                    finish_task(primary, native or state_from_task(primary, arguments.task_id)))
             result = {**current.receipt, "status": "landed" if current.receipt["landed"] else "blocked"}
         elif arguments.action == "answer":
             result = answer(primary, arguments.task_id, arguments.answer)