@opengsd/gsd-path 1.3.1 → 1.5.0

package/scripts/isolation.py

@@ -10,9 +10,12 @@ it never detaches HEAD.
 from __future__ import annotations
 
 import argparse
+import contextlib
 import hashlib
 import io
 import json
+import shlex
+import shutil
 import os
 import re
 import stat
@@ -23,10 +26,10 @@ import sys
 sys.dont_write_bytecode = True
 import tempfile
 from pathlib import Path, PurePosixPath
-from typing import Dict, Optional, Sequence, Set
+from typing import Dict, Iterator, Optional, Sequence, Set, Tuple
 
-try:
-    from pipeline_git import (
+if __package__:
+    from .pipeline_git import (
         attest_commit_body,
         attest_commit_subject,
         is_bound_branch,
@@ -35,20 +38,33 @@ try:
         task_commit_body,
         task_commit_subject,
     )
-    import _common
-    import worktree_paths
-except ImportError:  # pragma: no cover - package import used by tests
-    from scripts.pipeline_git import (
-        attest_commit_body,
-        attest_commit_subject,
-        is_bound_branch,
-        ship_commit_body,
-        ship_subject,
-        task_commit_body,
-        task_commit_subject,
-    )
-    from scripts import _common
-    from scripts import worktree_paths
+    from . import _common
+    from . import worktree_paths
+else:
+    try:
+        from pipeline_git import (
+            attest_commit_body,
+            attest_commit_subject,
+            is_bound_branch,
+            ship_commit_body,
+            ship_subject,
+            task_commit_body,
+            task_commit_subject,
+        )
+        import _common
+        import worktree_paths
+    except ImportError:  # pragma: no cover - package import used by tests
+        from scripts.pipeline_git import (
+            attest_commit_body,
+            attest_commit_subject,
+            is_bound_branch,
+            ship_commit_body,
+            ship_subject,
+            task_commit_body,
+            task_commit_subject,
+        )
+        from scripts import _common
+        from scripts import worktree_paths
 
 
 TASK_BRANCH_PREFIX = "gsd-path-task/"
@@ -156,6 +172,12 @@ def sidecar_root(primary: Path, kind: str, name: str, *, pin: bool = False) -> P
         raise IsolationError(str(error)) from error
 
 
+def release_workspace_quietly(primary: Path) -> None:
+    """Best-effort placement hygiene after a sidecar retires; never blocks landing."""
+    with contextlib.suppress(ValueError, OSError):
+        worktree_paths.release_workspace(primary)
+
+
 def validate_task_id(task_id: str) -> str:
     if not TASK_ID_RE.fullmatch(task_id):
         raise IsolationError(f"invalid task id: {task_id}")
@@ -247,6 +269,9 @@ def verify_branch_name(name: str) -> str:
 
 
 def relative_posix(path: str) -> str:
+    if os.name == "nt":
+        # A native Windows relative path; backslash cannot occur in a name there.
+        path = path.replace("\\", "/")
     parsed = PurePosixPath(path)
     if parsed.is_absolute() or ".." in parsed.parts:
         raise IsolationError(f"path must be relative without '..': {path}")
@@ -416,8 +441,9 @@ def collect_artifact_recoveries(primary: Path) -> list[Dict[str, object]]:
 
 
 def _git_file(repo: Path, revision: str, path: str) -> bytes:
+    git_path = PurePosixPath(path.replace("\\", "/")).as_posix()
     result = subprocess.run(
-        ("git", "-C", str(repo), "show", f"{revision}:{path}"),
+        ("git", "-C", str(repo), "show", f"{revision}:{git_path}"),
         capture_output=True,
         check=False,
     )
@@ -458,6 +484,70 @@ def _same_directory(path: Path, expected: os.stat_result) -> bool:
     return stat.S_ISDIR(current.st_mode) and os.path.samestat(current, expected)
 
 
+def _long_path(absolute: str) -> str:
+    if absolute.startswith("\\\\?\\"):
+        return absolute
+    if absolute.startswith("\\\\"):
+        return "\\\\?\\UNC\\" + absolute[2:]
+    return "\\\\?\\" + absolute
+
+
+def _force_rmtree(path: Path) -> None:
+    """Delete a sidecar tree directly, tolerating read-only files and long paths."""
+    def _writable(function, target, _error):
+        os.chmod(target, stat.S_IWRITE)
+        function(target)
+
+    # The \\?\ prefix sidesteps Windows MAX_PATH on deep sidecar trees.
+    target = Path(_long_path(os.path.abspath(path))) if os.name == "nt" else path
+    try:
+        shutil.rmtree(target, onerror=_writable)
+    except OSError as error:
+        raise IsolationError(f"could not delete {path}: {error}") from error
+
+
+def _remove_worktree(primary: Path, destination: Path, force: bool) -> None:
+    """Remove a sidecar worktree, tolerating populated submodules and locked trees.
+
+    git refuses to remove worktrees whose submodules were ever initialized, and
+    forced removal can still fail deleting deep trees (Windows "Directory not
+    empty"). A dirty sidecar keeps git's refusal unless `force`, so forced
+    retries only run for a provably clean tree. The direct-delete fallback runs
+    only for git's tree-deletion failures, so any other git error leaves the
+    sidecar intact for diagnosis.
+    """
+    tree_delete_failure = ("failed to delete", "directory not empty", "permission denied")
+
+    def failure(*flags: str) -> str:
+        result = run_git(primary, "worktree", "remove", *flags, str(destination))
+        return (result.stderr or result.stdout).strip() if result.returncode else ""
+
+    detail = failure("--force") if force else failure()
+    if not detail:
+        return
+    if not force and destination.is_dir():
+        status = run_git(
+            destination, "status", "--porcelain", "--untracked-files=all"
+        )
+        if status.returncode != 0 or status.stdout.strip():
+            raise IsolationError(detail or "git worktree remove failed")
+        run_git(destination, "submodule", "deinit", "--all", "--force")
+        detail = failure("--force")
+        if not detail:
+            return
+    if destination.is_dir() and any(
+        marker in detail.lower() for marker in tree_delete_failure
+    ):
+        _force_rmtree(destination)
+        detail = failure("--force")
+    if detail and not destination.is_dir():
+        pruned = run_git(primary, "worktree", "prune")
+        if pruned.returncode == 0:
+            detail = ""
+    if detail or destination.is_dir() or destination.resolve() in _registered_worktrees(primary):
+        raise IsolationError(detail or "git worktree remove failed")
+
+
 def _cleanup_reserved_worktree(
     primary: Path,
     branch: str,
@@ -480,8 +570,11 @@ def _cleanup_reserved_worktree(
         run_git(primary, "update-ref", "-d", ref, base)
 
 
-def create_named_worktree(primary: Path, branch: str, destination: Path, base: str) -> None:
-    bound = require_bound(primary)
+def create_named_worktree(
+    primary: Path, branch: str, destination: Path, base: str, bound: Optional[str] = None
+) -> None:
+    # A member names its bound branch; the member team's checkout is never on it.
+    bound = bound or require_bound(primary)
     if branch == bound:
         raise IsolationError(
             f"refusing to check out the bound branch {bound} in a second worktree"
@@ -576,6 +669,714 @@ def isolate_task(
     }
 
 
+def _member_context(
+    coordinator: Path, member: str, lock_at: Optional[str] = None
+) -> Tuple[Path, str, Dict[str, str]]:
+    """The checkout, coordinator project, and lock entry of a locked, verified member."""
+    try:
+        import members
+    except ImportError:  # pragma: no cover - package import used by tests
+        from scripts import members
+    coordinator = require_directory(coordinator, "coordinator")
+    if lock_at is None:
+        lock = coordinator / members.LOCK_PATH
+        entries = json.loads(lock.read_text(encoding="utf-8"))["members"] if lock.is_file() else []
+    else:
+        shown = run_git(coordinator, "show", f"{lock_at}:{members.LOCK_PATH}")
+        if shown.returncode != 0:
+            raise IsolationError(f"member lock is missing at {lock_at}: {members.LOCK_PATH}")
+        entries = json.loads(shown.stdout)["members"]
+    entry = next((item for item in entries if item["name"] == member), None)
+    if entry is None:
+        raise IsolationError(f"member {member} is not locked for this build because no task named it at build start")
+    checkout, project = member_checkout(coordinator, member)
+    return checkout, project, entry
+
+
+def member_checkout(coordinator: Path, member: str) -> Tuple[Path, str]:
+    """A MEMBERS.md member's checkout and coordinator project, after checking its marker."""
+    try:
+        import members
+    except ImportError:  # pragma: no cover - package import used by tests
+        from scripts import members
+    coordinator = require_directory(coordinator, "coordinator")
+    repair = f"run members.py repair --repo {coordinator}"
+    try:
+        listed = {item["name"]: item for item in members.read_members(coordinator)}
+        if member not in listed:
+            raise IsolationError(f"member {member} is not in MEMBERS.md; {repair}")
+        checkout = Path(listed[member]["checkout"]).resolve()
+        role = members.member_role(checkout)
+    except members.MembersError as error:
+        raise IsolationError(f"{error}; {repair}") from error
+    if role is None or role["coordinator"] != coordinator or role["name"] != member:
+        raise IsolationError(f"member marker for {member} is missing or stale; {repair}")
+    return checkout, str(role["project"])
+
+
+def member_bound_checkout(coordinator: Path, member: str) -> Dict[str, object]:
+    """Path's own checkout of a locked member's bound branch, outside the team's checkout."""
+    checkout, _, entry = _member_context(coordinator, member)
+    branch = entry["branch"]
+    destination = sidecar_root(checkout, "bound", branch.removeprefix("gsd-path/"), pin=True)
+    holders = [path for path, ref in _registered_worktrees(checkout).items() if ref == f"refs/heads/{branch}"]
+    if holders and holders != [destination.resolve()]:
+        raise IsolationError(f"{branch} is checked out outside Path's workspace: {holders[0]}")
+    if holders:
+        root = run_git(destination, "rev-parse", "--show-toplevel")
+        common = run_git(destination, "rev-parse", "--path-format=absolute", "--git-common-dir")
+        head = run_git(destination, "symbolic-ref", "-q", "HEAD")
+        if (root.returncode != 0 or Path(root.stdout.strip()).resolve() != destination.resolve()
+                or common.returncode != 0 or Path(common.stdout.strip()).resolve() != common_git_dir(checkout)
+                or head.returncode != 0 or head.stdout.strip() != f"refs/heads/{branch}"):
+            raise IsolationError(f"bound checkout is missing or invalid: {destination}")
+    if not holders:
+        if os.path.lexists(destination):
+            raise IsolationError(f"worktree path already exists: {destination}")
+        destination.parent.mkdir(parents=True, exist_ok=True)
+        added = run_git(checkout, "worktree", "add", str(destination), branch)
+        if added.returncode != 0:
+            raise IsolationError((added.stderr or added.stdout).strip() or "git worktree add failed")
+    return {"branch": branch, "checkout": str(destination.resolve()), "member": member}
+
+
+def isolate_member_task(coordinator: Path, member: str, task_id: str) -> Dict[str, object]:
+    """Member tasks always run in a sidecar at the member bound branch tip."""
+    validate_task_id(task_id)
+    bound = member_bound_checkout(coordinator, member)
+    bound_checkout = Path(bound["checkout"])
+    dirty = uncommitted_paths(bound_checkout)
+    if dirty:
+        raise IsolationError(
+            "member task isolation requires a clean member bound checkout: " + ", ".join(sorted(dirty))
+        )
+    checkout, project, _ = _member_context(coordinator, member)
+    member_base = current_sha(bound_checkout)
+    name = f"{project}-{task_id}"
+    branch = f"{TASK_BRANCH_PREFIX}{name}"
+    destination = sidecar_root(checkout, "task", name, pin=True)
+    create_named_worktree(checkout, branch, destination, member_base, bound=str(bound["branch"]))
+    return {
+        "bound_branch": bound["branch"],
+        "bound_checkout": bound["checkout"],
+        "kind": "task",
+        "member": member,
+        "member_base": member_base,
+        "mode": "member",
+        "task_branch": branch,
+        "worktree": str(destination),
+    }
+
+
+def _rejected_member_attempt_error(
+    coordinator: Path, member: str, task_id: str, task_file: Optional[str], sidecar: Path
+) -> tuple[Optional[str], Optional[str]]:
+    """A forced retire discards a rejected attempt only after the parent kept its evidence.
+
+    Returns (refusal, copy_rejected); an invalid live copy holds no trusted Log delta,
+    so the parent's own rejection record stands in for it.
+    """
+    if not task_file:
+        return "forced member task retirement requires --task-file", None
+    task_file = relative_posix(task_file)
+    shown = run_git(coordinator, "show", f"HEAD:{task_file}")
+    fields, error = task_frontmatter(shown.stdout) if shown.returncode == 0 else (None, "task file is not committed")
+    if error or fields is None:
+        return error or "unreadable task file", None
+    if str(fields.get("id")) != task_id or fields.get("repo") != member:
+        return f"{task_file} does not own member task {task_id} in {member}", None
+    # A member task never leaves pending in the coordinator until its landing record.
+    if fields.get("status") != "pending":
+        return "forced member task retirement requires the coordinator task at pending", None
+    if os.path.lexists(_member_journal_path(coordinator, task_id)):
+        return "member task has a landing journal; recover it instead", None
+    if sidecar.is_dir():
+        copy = _safe_member_task_copy(sidecar, task_file)
+        if copy.is_file():
+            try:
+                text = copy.read_text(encoding="utf-8")
+                base = str((task_frontmatter(text)[0] or {}).get("base", ""))
+                contract = git_text(coordinator, "show", f"{require_full_sha(base)}:{task_file}")
+                delta = member_log_delta(contract, text).strip()
+            except (IsolationError, UnicodeDecodeError) as copy_error:
+                return None, str(copy_error)
+            if delta and delta not in _normalize_newlines(shown.stdout):
+                return ("copy the rejected attempt's Log delta into the coordinator task file "
+                        "and checkpoint it before forced retirement"), None
+    return None, None
+
+
+def retire_member_task(
+    coordinator: Path, member: str, task_id: str, force: bool = False, task_file: Optional[str] = None
+) -> Optional[str]:
+    """Remove an unused member task sidecar; landed work needs the landing proof.
+
+    `force` discards a rejected (dirty) attempt so a retry starts from a fresh sidecar,
+    and returns why its live task copy was rejected, if it was.
+    """
+    checkout, project, entry = _member_context(coordinator, member)
+    name = f"{project}-{validate_task_id(task_id)}"
+    ref = f"refs/heads/{TASK_BRANCH_PREFIX}{name}"
+    tip = run_git(checkout, "rev-parse", "--verify", "--quiet", ref)
+    # Landed commits arrive on the bound branch by cherry-pick, so compare patches.
+    cherry = run_git(checkout, "cherry", f"refs/heads/{entry['branch']}", ref) if tip.returncode == 0 else None
+    if cherry is not None and (cherry.returncode != 0 or any(
+            not line.startswith("- ") for line in cherry.stdout.splitlines())):
+        raise IsolationError(f"member task branch {ref} has unlanded commits")
+    destination = sidecar_root(checkout, "task", name)
+    copy_rejected = None
+    if force and task_file:
+        rejected, copy_rejected = _rejected_member_attempt_error(coordinator, member, task_id, task_file, destination)
+        if rejected:
+            raise IsolationError(rejected)
+    registered = _registered_worktrees(checkout)
+    if destination.resolve() in registered:
+        if registered[destination.resolve()] != ref:
+            raise IsolationError(f"member task sidecar is on another branch: {destination}")
+        _remove_worktree(checkout, destination, force)
+    authorization = run_git(checkout, "update-ref", "-d", member_task_authorization_ref(project, task_id))
+    if authorization.returncode != 0:
+        raise IsolationError((authorization.stderr or authorization.stdout).strip() or "git update-ref failed")
+    if tip.returncode == 0:
+        deleted = run_git(checkout, "update-ref", "-d", ref, tip.stdout.strip())
+        if deleted.returncode != 0:
+            raise IsolationError((deleted.stderr or deleted.stdout).strip() or "git update-ref failed")
+    release_workspace_quietly(checkout)
+    return copy_rejected
+
+
+MEMBER_LANDING_DIR = ("gsd-path", "member-landings")
+# A running member task's live task file sits in its member sidecar, untracked
+# and excluded, so the coordinator stays clean while member work runs.
+MEMBER_TASK_COPY_DIR = ".gsd-path-coordinator"
+MEMBER_IMMUTABLE_FIELDS = ("id", "title", "repo", "files", "deps", "wave")
+MEMBER_ACTIVATION_FIELDS = {"status", "agent", "base", "member_base", "worktree", "task_branch"}
+
+
+def _member_hook_configs(coordinator: Path) -> Dict[str, str]:
+    """Host configs for a member sidecar that call the coordinator guard by absolute path.
+
+    Only hosts whose managed config is installed in the coordinator get one; inside
+    a member sidecar the Git top level and project dir name the member, not the
+    coordinator, so the installed relative commands would miss the guard.
+    """
+    guard = coordinator / ".gsd-path" / "guard_hook.py"
+    command = f"{shlex.quote(sys.executable)} {shlex.quote(str(guard))}"
+    windows_interpreter = sys.executable.replace("'", "''")
+    windows_guard = str(guard).replace("'", "''")
+    command_windows = ("powershell.exe -NoProfile -NonInteractive -Command "
+                       f'"& \'{windows_interpreter}\' \'{windows_guard}\'"')
+    formats = {
+        ".claude/settings.json": {"hooks": {"PreToolUse": [
+            {"matcher": ".*", "hooks": [{"type": "command", "command": command}]}]}},
+        ".codex/hooks.json": {"hooks": {"PreToolUse": [
+            {"matcher": ".*", "hooks": [{"type": "command", "command": command,
+                                            "commandWindows": command_windows}]}]}},
+        ".cursor/hooks.json": {"version": 1, "hooks": {"preToolUse": [
+            {"command": command, "matcher": ".*", "failClosed": True}]}},
+    }
+    configs = {}
+    for relative, content in formats.items():
+        installed = coordinator / relative
+        if installed.is_file() and not installed.is_symlink() and "guard_hook.py" in installed.read_text(encoding="utf-8"):
+            configs[relative] = json.dumps(content, indent=2) + "\n"
+    return configs
+
+
+def _check_member_hook_collisions(configs: Dict[str, str], sidecar: Path) -> None:
+    for relative, content in configs.items():
+        # A member's own config (tracked or local) would run instead of the guard; never replace it.
+        target = sidecar / relative
+        if target.parent.is_symlink() or target.is_symlink() or (
+                target.exists() and target.read_bytes() != content.encode("utf-8")):
+            raise IsolationError(f"member sidecar already has its own {relative}; its host would run "
+                                 "without the coordinator guard")
+
+
+def _write_member_hook_configs(coordinator: Path, checkout: Path, sidecar: Path) -> None:
+    configs = _member_hook_configs(coordinator)
+    _check_member_hook_collisions(configs, sidecar)
+    exclude = common_git_dir(checkout) / "info" / "exclude"
+    existing = exclude.read_text(encoding="utf-8") if exclude.is_file() else ""
+    missing = [f"/{relative}" for relative in configs if f"/{relative}" not in existing.splitlines()]
+    if missing:
+        exclude.parent.mkdir(parents=True, exist_ok=True)
+        prefix = existing + ("" if not existing or existing.endswith("\n") else "\n")
+        _common.atomic_write(exclude, prefix + "\n".join(missing) + "\n")
+    for relative, content in configs.items():
+        target = sidecar / relative
+        target.parent.mkdir(parents=True, exist_ok=True)
+        _common.atomic_write(target, content)
+
+
+def ensure_member_hooks(coordinator: Path, member: str, task_id: str) -> None:
+    checkout, project, _ = _member_context(coordinator, member)
+    sidecar = sidecar_root(checkout, "task", f"{project}-{validate_task_id(task_id)}")
+    branch = f"{TASK_BRANCH_PREFIX}{project}-{task_id}"
+    if require_attached(sidecar) != branch:
+        raise IsolationError(f"member task sidecar is not on its task branch: {sidecar}")
+    _write_member_hook_configs(coordinator, checkout, sidecar)
+
+
+def member_task_copy(sidecar: Path, task_file: str) -> Path:
+    return sidecar / MEMBER_TASK_COPY_DIR / relative_posix(task_file)
+
+
+def _safe_member_task_copy(sidecar: Path, task_file: str) -> Path:
+    copy = member_task_copy(sidecar, task_file)
+    if git_output(sidecar, "ls-files", "--", MEMBER_TASK_COPY_DIR):
+        raise IsolationError("member task copy directory is tracked")
+    parent = sidecar
+    for part in (MEMBER_TASK_COPY_DIR, *PurePosixPath(task_file).parts[:-1]):
+        parent = parent / part
+        if os.path.lexists(parent) and (parent.is_symlink() or not parent.is_dir()):
+            raise IsolationError(f"member task copy parent is not a real directory: {parent}")
+        try:
+            parent.resolve().relative_to(sidecar.resolve())
+        except ValueError as error:
+            raise IsolationError(f"member task copy parent escapes the sidecar: {parent}") from error
+    if os.path.lexists(copy) and (copy.is_symlink() or not copy.is_file()):
+        raise IsolationError(f"member task copy is not a regular file: {copy}")
+    return copy
+
+
+def member_task_authorization_ref(project: str, task_id: str) -> str:
+    return f"{TASK_AUTHORIZATION_PREFIX}{project}-{validate_task_id(task_id)}"
+
+
+def _activated_member_text(
+    contract: str, task_id: str, agent: str, base: str, sidecar: Path, branch: str, member_base: str
+) -> str:
+    activated = _activated_task_text(contract, task_id, agent, base, sidecar, branch)
+    head, body = split_frontmatter(activated)
+    head = [line for line in head if not line.startswith("member_base:")]
+    head.insert(next(i for i, line in enumerate(head) if line.startswith("base:")) + 1,
+                f"member_base: {member_base}")
+    return "---\n" + "\n".join(head) + "\n---\n" + body
+
+
+def activate_member_task(
+    coordinator: Path, member: str, task_id: str, agent: str, task_file: str, base: str
+) -> Dict[str, object]:
+    """Write the live task copy into the member sidecar and authorize its member base."""
+    coordinator = require_directory(coordinator, "coordinator")
+    if not agent or agent == "null" or "\n" in agent:
+        raise IsolationError("task activation requires an assigned agent")
+    task_file = relative_posix(task_file)
+    if not task_file.startswith(".project/tasks/"):
+        raise IsolationError("task activation file must stay under .project/tasks/")
+    checkout, project, entry = _member_context(coordinator, member)
+    sidecar = sidecar_root(checkout, "task", f"{project}-{validate_task_id(task_id)}")
+    branch = f"{TASK_BRANCH_PREFIX}{project}-{task_id}"
+    if require_attached(sidecar) != branch:
+        raise IsolationError(f"member task sidecar is not on its task branch: {sidecar}")
+    member_base = current_sha(sidecar)
+    if run_git(checkout, "rev-parse", "--verify", "--quiet", f"refs/heads/{branch}").stdout.strip() != member_base \
+            or run_git(checkout, "merge-base", "--is-ancestor", member_base,
+                       f"refs/heads/{entry['branch']}").returncode != 0:
+        raise IsolationError("member task activation requires the sidecar at its member base")
+    _check_member_hook_collisions(_member_hook_configs(coordinator), sidecar)
+    if uncommitted_paths(sidecar):
+        raise IsolationError("member task activation requires a clean member sidecar")
+    resolved_base = require_commit(coordinator, require_full_sha(base))
+    _member_contract(coordinator, resolved_base, task_file, member)
+    contract = git_text(coordinator, "show", f"{resolved_base}:{task_file}")
+    activated = _activated_member_text(contract, task_id, agent, resolved_base, sidecar, branch, member_base)
+    copy = _safe_member_task_copy(sidecar, task_file)
+    _write_member_hook_configs(coordinator, checkout, sidecar)
+    exclude = common_git_dir(checkout) / "info" / "exclude"
+    rule = f"/{MEMBER_TASK_COPY_DIR}/"
+    existing = exclude.read_text(encoding="utf-8") if exclude.is_file() else ""
+    if rule not in existing.splitlines():
+        exclude.parent.mkdir(parents=True, exist_ok=True)
+        _common.atomic_write(exclude, existing + ("" if not existing or existing.endswith("\n") else "\n") + rule + "\n")
+    if copy.is_file() and copy.read_text(encoding="utf-8") != activated:
+        current, _ = task_frontmatter(copy.read_text(encoding="utf-8"))
+        if (not current or current.get("agent") != agent or current.get("base") != resolved_base
+                or current.get("member_base") != member_base):
+            raise IsolationError(f"member task is already active with another agent or base: {copy}")
+    elif not copy.is_file():
+        copy.parent.mkdir(parents=True, exist_ok=True)
+        _common.atomic_write(copy, activated)
+    ref = member_task_authorization_ref(project, task_id)
+    created = run_git(checkout, "update-ref", ref, member_base, "0" * 40)
+    if created.returncode != 0 and run_git(checkout, "rev-parse", "--verify", "--quiet", ref).stdout.strip() != member_base:
+        raise IsolationError("could not record member task authorization")
+    result = {"agent": agent, "base": resolved_base, "copy": str(copy), "member": member,
+            "member_base": member_base, "status": "in-progress", "task_branch": branch,
+            "task_file": task_file, "worktree": str(sidecar)}
+    _write_native_member_dispatch_record(coordinator, result)
+    return result
+
+
+def retained_member_task(
+    coordinator: Path, member: str, task_id: str, task_file: str, base: str
+) -> Optional[Dict[str, object]]:
+    """Inspect an interrupted member isolate before another dispatch uses its name."""
+    checkout, project, _ = _member_context(coordinator, member)
+    branch = f"{TASK_BRANCH_PREFIX}{project}-{validate_task_id(task_id)}"
+    sidecar = sidecar_root(checkout, "task", f"{project}-{task_id}")
+    tip = run_git(checkout, "rev-parse", "--verify", "--quiet", f"refs/heads/{branch}").stdout.strip()
+    authorization = run_git(checkout, "rev-parse", "--verify", "--quiet",
+                            member_task_authorization_ref(project, task_id)).stdout.strip()
+    if not tip:
+        if os.path.lexists(sidecar) or authorization:
+            raise IsolationError(f"member task {task_id} has a sidecar or authorization without its branch")
+        return None
+    if _registered_worktrees(checkout).get(sidecar.resolve()) != f"refs/heads/{branch}":
+        raise IsolationError(f"member task branch has no matching sidecar: {branch}")
+    if require_attached(sidecar) != branch or current_sha(sidecar) != tip:
+        raise IsolationError(f"member task sidecar does not match its branch: {branch}")
+    bound = member_bound_checkout(coordinator, member)
+    bound_tip = current_sha(Path(str(bound["checkout"])))
+    if (run_git(checkout, "merge-base", "--is-ancestor", tip, bound_tip).returncode != 0
+            or uncommitted_paths(sidecar)):
+        raise IsolationError(f"member task branch is used or its member base moved: {branch}")
+    copy = _safe_member_task_copy(sidecar, task_file)
+    isolate = {"task_branch": branch, "member_base": tip, "worktree": str(sidecar)}
+    if not authorization:
+        if copy.is_file():
+            text = copy.read_text(encoding="utf-8")
+            fields, error = task_frontmatter(text)
+            if error or fields is None:
+                raise IsolationError(error or f"member task {task_id} has an unreadable activation")
+            copy_base = require_commit(coordinator, require_full_sha(str(fields.get("base", ""))))
+            _member_contract(coordinator, copy_base, task_file, member)
+            contract = git_text(coordinator, "show", f"{copy_base}:{task_file}")
+            expected = _activated_member_text(contract, task_id, f"build_{task_id.lower()}",
+                                              copy_base, sidecar, branch, tip)
+            if text != expected:
+                raise IsolationError(f"member task {task_id} has a changed activation")
+        return {"state": "unused", "isolate": isolate}
+    if not copy.is_file() or authorization != tip:
+        raise IsolationError(f"member task {task_id} has an incomplete activation")
+    if tip != bound_tip:
+        raise IsolationError(f"member task {task_id} has a used activation at an older member base")
+    journal = {"member": member, "task_id": task_id, "task_file": task_file,
+               "base": base, "member_base": tip, "copy": str(copy)}
+    text = _member_copy_text(journal, coordinator)
+    contract = git_text(coordinator, "show", f"{base}:{task_file}")
+    fields, _ = task_frontmatter(text)
+    if fields is None or fields.get("agent") != f"build_{task_id.lower()}" or member_log_delta(contract, text):
+        raise IsolationError(f"member task {task_id} has a used or changed activation")
+    return {"state": "active", "isolate": isolate,
+            "active": {"copy": str(copy), "worktree": str(sidecar)}}
+
+
+def _member_copy_text(journal: Dict[str, object], coordinator: Path) -> str:
+    """The live copy, checked against the contract: same contract fields, Log only grows."""
+    checkout, project, _ = _member_context(coordinator, str(journal["member"]))
+    sidecar = sidecar_root(checkout, "task", f"{project}-{journal['task_id']}")
+    copy = _safe_member_task_copy(sidecar, str(journal["task_file"]))
+    if copy != Path(str(journal["copy"])) or not copy.is_file():
+        raise IsolationError(f"member task is not activated: {copy}")
+    text = copy.read_text(encoding="utf-8")
+    contract = git_text(coordinator, "show", f"{journal['base']}:{journal['task_file']}")
+    fields, error = task_frontmatter(text)
+    expected, _ = task_frontmatter(contract)
+    if error or fields is None or expected is None:
+        raise IsolationError(error or "unreadable member task copy")
+    member_log_delta(contract, text)
+    if not isinstance(fields.get("agent"), str) or fields["agent"] in {"", "null"}:
+        raise IsolationError("member task copy has no assigned agent")
+    if (fields.get("status"), fields.get("base"), fields.get("member_base")) != (
+            "in-progress", journal["base"], journal["member_base"]):
+        raise IsolationError("member task copy is not the activated task for this landing")
+    if (fields.get("worktree"), fields.get("task_branch")) != (
+            str(sidecar), f"{TASK_BRANCH_PREFIX}{project}-{journal['task_id']}"):
+        raise IsolationError("member task copy is not the activated task for this landing")
+    return text
+
+
+def _coordinator_clean_for_record(coordinator: Path, recovery: Optional[Dict[str, object]] = None) -> None:
+    staged = set(git_output(coordinator, "diff", "--cached", "--name-only").splitlines())
+    dirty = (uncommitted_paths(coordinator) - BOOKKEEPING_PATHS) | staged
+    if recovery is not None:
+        task_file = str(recovery["task_file"])
+        if task_file in dirty:
+            stamped = _landed_task_text(_member_copy_text(recovery, coordinator), str(recovery["base"]))
+            current, _ = _read_task_text(coordinator / task_file)
+            if (current == stamped and (task_file not in staged
+                                        or git_text(coordinator, "show", f":{task_file}") == stamped)):
+                dirty.remove(task_file)
+    dirty = sorted(dirty)
+    if dirty:
+        raise IsolationError("coordinator worktree is dirty: " + ", ".join(dirty))
+
+
+def member_commit_body(task_file: str, paths: Sequence[str], member_base: str, contract: str) -> str:
+    """The member landing body: coordinator task, member base, contract revision, files."""
+    lines = [f"Task: {task_file}", f"Base: {member_base}", f"Contract: {contract}", "Files:"]
+    lines.extend(f"- {path}" for path in sorted(paths))
+    return "\n".join(lines) + "\n"
+
+
+def _member_journal_path(coordinator: Path, task_id: str) -> Path:
+    return common_git_dir(coordinator).joinpath(*MEMBER_LANDING_DIR, f"{validate_task_id(task_id)}.json")
+
+
+@contextlib.contextmanager
+def _member_landing_lock(coordinator: Path) -> Iterator[None]:
+    path = common_git_dir(coordinator).joinpath(*MEMBER_LANDING_DIR, ".lock")
+    with _common.exclusive_lock(path):
+        yield
+
+
+def _require_member_coordinator_branch(coordinator: Path) -> None:
+    branch = require_bound(coordinator)
+    if __package__:
+        from .pipeline_state import load_state
+    else:
+        try:
+            from pipeline_state import load_state
+        except ImportError:
+            from scripts.pipeline_state import load_state
+    state, _, _ = load_state(coordinator)
+    if branch != state.branch:
+        raise IsolationError(f"coordinator branch {branch} differs from STATE bound branch {state.branch}")
+
+
+def _record_member_journal(path: Path, journal: Dict[str, object]) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    _common.atomic_write(path, json.dumps(journal, indent=2, sort_keys=True) + "\n")
+
+
+def _member_contract(
+    coordinator: Path, base: str, task_file: str, member: str,
+    current_text: Optional[str] = None,
+) -> tuple[str, Set[str]]:
+    shown = run_git(coordinator, "show", f"{base}:{task_file}")
+    if shown.returncode != 0:
+        raise IsolationError(f"task contract is missing at {base}: {task_file}")
+    fields, error = task_frontmatter(shown.stdout)
+    if error or fields is None:
+        raise IsolationError(error or f"unreadable task contract: {task_file}")
+    current = current_text
+    if current is None:
+        current, _ = _read_task_text(coordinator / task_file)
+    current_fields, current_error = task_frontmatter(current)
+    if current_error or current_fields is None:
+        raise IsolationError(current_error or f"unreadable current task: {task_file}")
+    if any(current_fields.get(key) != fields.get(key) for key in MEMBER_IMMUTABLE_FIELDS):
+        raise IsolationError(f"current task contract differs from {base}: {task_file}")
+    if fields.get("repo") != member:
+        raise IsolationError(f"{task_file} is not a task for member {member}")
+    files = fields.get("files")
+    if not isinstance(files, list) or not files:
+        raise IsolationError(f"{task_file} declares no files")
+    return str(fields.get("title", "")), {relative_posix(str(path)) for path in files}
+
+
+def _prove_member_commit(
+    repo: Path, commit: str, parent: str, subject: str, body: str, allowed: Set[str]
+) -> Optional[str]:
+    found_parent, error = _single_parent(repo, commit)
+    if error or found_parent != parent:
+        return error or f"commit parent is not {parent}"
+    changed = set(git_output(repo, "diff-tree", "--no-commit-id", "--name-only", "-r", "--no-renames",
+                             parent, commit).splitlines())
+    if not changed:
+        return "commit changes nothing"
+    undeclared = sorted(changed - allowed)
+    if undeclared:
+        return "undeclared paths: " + ", ".join(undeclared)
+    if git_output(repo, "log", "-1", "--format=%s", commit) != subject:
+        return f"subject is not {subject!r}"
+    if git_output(repo, "log", "-1", "--format=%b", commit) != body.strip():
+        return "body is not the member landing block"
+    return None
+
+
+def _commit_member_source(sidecar: Path, journal: Dict[str, object], allowed: Set[str]) -> str:
+    member_base = str(journal["member_base"])
+    pending = uncommitted_paths(sidecar)
+    if pending:
+        if current_sha(sidecar) != member_base:
+            raise IsolationError("dirty member source HEAD must equal the member base")
+        undeclared = sorted(pending - allowed)
+        if undeclared:
+            raise IsolationError("undeclared paths: " + ", ".join(undeclared))
+        git_output(sidecar, "add", "-A", "--", *sorted(pending))
+        body = member_commit_body(str(journal["task_file"]), sorted(pending), member_base, str(journal["base"]))
+        git_output(sidecar, "commit", "-q", "-m", str(journal["subject"]), "-m", body.strip())
+    source = current_sha(sidecar)
+    if source == member_base:
+        raise IsolationError("no changes to land")
+    paths = git_output(sidecar, "diff-tree", "--no-commit-id", "--name-only", "-r", "--no-renames",
+                       member_base, source).splitlines()
+    body = member_commit_body(str(journal["task_file"]), paths, member_base, str(journal["base"]))
+    error = _prove_member_commit(sidecar, source, member_base, str(journal["subject"]), body, allowed)
+    if error:
+        raise IsolationError(f"member source commit proof failed: {error}")
+    return source
+
+
+def _pick_member_landing(bound: Path, journal: Dict[str, object]) -> str:
+    if current_sha(bound) != journal["expected_parent"] or uncommitted_paths(bound):
+        raise IsolationError("member bound checkout moved or is dirty before landing")
+    picked = run_git(bound, "cherry-pick", str(journal["source"]))
+    if picked.returncode != 0:
+        run_git(bound, "cherry-pick", "--abort")
+        detail = (picked.stderr or picked.stdout).strip() or "cherry-pick conflict"
+        raise IsolationError(f"conflict: {detail}")
+    return current_sha(bound)
+
+
+def _prove_member_landing(bound: Path, journal: Dict[str, object], landing: str, allowed: Set[str]) -> Optional[str]:
+    source = str(journal["source"])
+    body = git_output(bound, "log", "-1", "--format=%b", source) + "\n"
+    error = _prove_member_commit(bound, landing, str(journal["expected_parent"]),
+                                 str(journal["subject"]), body, allowed)
+    if error:
+        return error
+    if _tree_delta(bound, str(journal["expected_parent"]), landing) != _tree_delta(
+            bound, str(journal["member_base"]), source):
+        return "landing changes differ from the source commit"
+    return None
+
+
+def _write_member_record(coordinator: Path, journal: Dict[str, object]) -> str:
+    task_file = str(journal["task_file"])
+    task_path = coordinator / task_file
+    _, mode = _read_task_text(task_path)
+    stamped = _landed_task_text(_member_copy_text(journal, coordinator), str(journal["base"]))
+    _replace_regular_file(task_path, stamped.encode("utf-8"), mode)
+    record = (f"Task: {task_file}\nBase: {journal['base']}\n"
+              f"Member: {journal['member']} {journal['landing']} {journal['member_base']}")
+    git_output(coordinator, "add", "--", task_file)
+    git_output(coordinator, "commit", "-q", "-m", str(journal["subject"]), "-m", record)
+    return current_sha(coordinator)
+
+
+def _existing_member_record(coordinator: Path, journal: Dict[str, object]) -> Optional[str]:
+    task_file = str(journal["task_file"])
+    body = (f"Task: {task_file}\nBase: {journal['base']}\n"
+            f"Member: {journal['member']} {journal['landing']} {journal['member_base']}")
+    for sha, subject, found_body in _first_parent_records(coordinator, "HEAD"):
+        if subject != journal["subject"] or found_body != body:
+            continue
+        parent, error = _single_parent(coordinator, sha)
+        if error or parent is None:
+            continue
+        changed = set(git_output(coordinator, "diff-tree", "--no-commit-id", "--name-only", "-r",
+                                 "--no-renames", parent, sha).splitlines())
+        if changed == {task_file}:
+            return sha
+    return None
+
+
+def _finish_member_landing(
+    coordinator: Path, path: Path, journal: Dict[str, object], *, recovery: bool = False
+) -> Dict[str, object]:
+    _coordinator_clean_for_record(coordinator, journal if recovery else None)
+    record = _write_member_record(coordinator, journal)
+    path.unlink()
+    return {"commit": record, "landing": journal["landing"], "member": journal["member"],
+            "mode": "member", "source_commit": journal["source"], "state": "landed"}
+
+
+def land_member(
+    coordinator: Path, member: str, task_id: str, title: str, task_file: str, base: str, member_base: str
+) -> Dict[str, object]:
+    """Land a member task: member product commit first, then the coordinator record.
+
+    A journal in the coordinator Git directory is written before the member
+    branch moves, so recover_member_landing never lands the same work twice.
+    A conflict keeps the source commit on its task sidecar for retry; the bound
+    member branch and coordinator stay unchanged.
+    """
+    coordinator = require_directory(coordinator, "coordinator")
+    _require_member_coordinator_branch(coordinator)
+    task_file = relative_posix(task_file)
+    with _member_landing_lock(coordinator):
+        path = _member_journal_path(coordinator, task_id)
+        if os.path.lexists(path):
+            raise IsolationError(f"a member landing is pending for {task_id}; run recover_member_landing first")
+        for pending in sorted(path.parent.glob("*.json")):
+            if json.loads(pending.read_text(encoding="utf-8"))["member"] == member:
+                raise IsolationError(
+                    f"member {member} has pending landing {pending.stem}; run recover_member_landing first"
+                )
+        checkout, project, _ = _member_context(coordinator, member)
+        bound = Path(member_bound_checkout(coordinator, member)["checkout"])
+        sidecar = sidecar_root(checkout, "task", f"{project}-{task_id}")
+        if require_attached(sidecar) != f"{TASK_BRANCH_PREFIX}{project}-{task_id}":
+            raise IsolationError(f"member task sidecar is not on its task branch: {sidecar}")
+        resolved_base = require_commit(coordinator, require_full_sha(base))
+        contract_title, allowed = _member_contract(coordinator, resolved_base, task_file, member)
+        if title != contract_title:
+            raise IsolationError(f"title does not match the task contract: {contract_title!r}")
+        _coordinator_clean_for_record(coordinator)
+        member_base = require_full_sha(member_base)
+        authorization = run_git(checkout, "rev-parse", "--verify", "--quiet",
+                                member_task_authorization_ref(project, task_id)).stdout.strip()
+        if authorization != member_base:
+            raise IsolationError(f"member task {task_id} is not authorized at its member base")
+        journal: Dict[str, object] = {
+            "base": resolved_base, "copy": str(member_task_copy(sidecar, task_file)), "member": member,
+            "member_base": member_base, "subject": task_commit_subject(task_id, title),
+            "task_file": task_file, "task_id": task_id,
+        }
+        _member_copy_text(journal, coordinator)
+        journal["source"] = _commit_member_source(sidecar, journal, allowed)
+        journal["expected_parent"] = current_sha(bound)
+        journal["landing"] = None
+        _record_member_journal(path, journal)
+        try:
+            landing = _pick_member_landing(bound, journal)
+        except IsolationError:
+            path.unlink()
+            raise
+        error = _prove_member_landing(bound, journal, landing, allowed)
+        if error:
+            raise IsolationError(f"member landing proof failed: {error}; the journal keeps it for recovery")
+        journal["landing"] = landing
+        _record_member_journal(path, journal)
+        return _finish_member_landing(coordinator, path, journal)
+
+
+def recover_member_landing(coordinator: Path, task_id: str) -> Dict[str, object]:
+    """Finish an interrupted member landing from its journal, never picking twice."""
+    coordinator = require_directory(coordinator, "coordinator")
+    path = _member_journal_path(coordinator, task_id)
+    if not os.path.lexists(path):
+        return {"state": "none"}
+    _require_member_coordinator_branch(coordinator)
+    with _member_landing_lock(coordinator):
+        if not os.path.lexists(path):
+            return {"state": "none"}
+        journal = json.loads(path.read_text(encoding="utf-8"))
+        member = str(journal["member"])
+        bound = Path(member_bound_checkout(coordinator, member)["checkout"])
+        _, allowed = _member_contract(coordinator, str(journal["base"]), str(journal["task_file"]), member)
+        if journal.get("landing"):
+            record = _existing_member_record(coordinator, journal)
+            if record:
+                path.unlink()
+                return {"commit": record, "landing": journal["landing"], "member": member,
+                        "mode": "member", "source_commit": journal["source"], "state": "landed"}
+            if current_sha(bound) != journal["landing"]:
+                raise IsolationError("the member bound branch moved after the landing journal was written")
+            _require_first_parent_commit(bound, current_sha(bound), str(journal["landing"]))
+            error = _prove_member_landing(bound, journal, str(journal["landing"]), allowed)
+            if error:
+                raise IsolationError(f"member landing proof failed: {error}")
+        if not journal.get("landing"):
+            tip = current_sha(bound)
+            if tip == journal["expected_parent"]:
+                landing = _pick_member_landing(bound, journal)
+            elif _prove_member_landing(bound, journal, tip, allowed) is None:
+                landing = tip
+            else:
+                raise IsolationError("the member bound branch moved after the landing journal was written")
+            error = _prove_member_landing(bound, journal, landing, allowed)
+            if error:
+                raise IsolationError(f"member landing proof failed: {error}")
+            journal["landing"] = landing
+            _record_member_journal(path, journal)
+        return _finish_member_landing(coordinator, path, journal, recovery=True)
+
+
 def isolate_verify(primary: Path, base: str, name: str, historical_task: Optional[str] = None) -> Dict[str, object]:
     primary = require_directory(primary, "primary worktree")
     if worktree_root(primary) != primary:
@@ -612,6 +1413,69 @@ def isolate_verify(primary: Path, base: str, name: str, historical_task: Optiona
     }
 
 
+def check_member_verify_collision(entries: Sequence[Dict[str, str]], sidecar_name: str) -> None:
+    if any(item["name"] == sidecar_name for item in entries):
+        raise IsolationError(
+            f"locked member {sidecar_name} collides with coordinator Verify sidecar folder {sidecar_name}"
+        )
+
+
+def isolate_member_verify(coordinator: Path, sidecar: Path) -> Dict[str, Dict[str, str]]:
+    """Check out each locked member's bound tip beside the coordinator verify sidecar."""
+    try:
+        import members
+    except ImportError:  # pragma: no cover - package import used by tests
+        from scripts import members
+    lock = coordinator / members.LOCK_PATH
+    entries = json.loads(lock.read_text(encoding="utf-8"))["members"] if lock.is_file() else []
+    check_member_verify_collision(entries, sidecar.name)
+    created: Dict[str, Dict[str, str]] = {}
+    try:
+        for item in entries:
+            checkout, project, entry = _member_context(coordinator, item["name"])
+            tip = git_output(checkout, "rev-parse", "--verify", f"refs/heads/{entry['branch']}^{{commit}}")
+            branch = f"{VERIFY_BRANCH_PREFIX}{project}-{entry['name']}"
+            destination = sidecar.parent / entry["name"]
+            create_named_worktree(checkout, branch, destination, tip, bound=entry["branch"])
+            created[entry["name"]] = {"checkout": str(checkout), "worktree": str(destination),
+                                     "branch": branch, "tip": tip}
+    except BaseException:
+        retire_member_verify(created)
+        raise
+    return created
+
+
+def _member_verify_sidecar(record: Dict[str, str]) -> Tuple[Path, Path, str]:
+    checkout = Path(record["checkout"])
+    destination = Path(record["worktree"])
+    branch = record["branch"]
+    registered = _registered_worktrees(checkout)
+    if (destination.is_symlink() or not destination.is_dir()
+            or destination.resolve() not in registered
+            or worktree_root(destination) != destination.resolve()
+            or common_git_dir(destination) != common_git_dir(checkout)):
+        raise IsolationError(f"member Verify sidecar ownership changed: {destination}")
+    return checkout, destination, branch
+
+
+def retire_member_verify(created: Dict[str, Dict[str, str]]) -> None:
+    """Remove the member siblings of a coordinator verify sidecar; they hold no output."""
+    for record in reversed(list(created.values())):
+        checkout, destination, branch = _member_verify_sidecar(record)
+        _remove_worktree(checkout, destination, True)
+        git_output(checkout, "branch", "-D", branch)
+        release_workspace_quietly(checkout)
+
+
+def check_member_verify(created: Dict[str, Dict[str, str]]) -> None:
+    for record in created.values():
+        _, destination, _ = _member_verify_sidecar(record)
+        if require_attached(destination) != record["branch"]:
+            raise IsolationError(f"member Verify sidecar branch changed: {destination}")
+        if current_sha(destination) != record["tip"]:
+            raise IsolationError(f"member Verify sidecar HEAD changed: {destination}")
+
+
 def clean_verify(primary: Path, worktree: Path, base: str, branch: str) -> Dict[str, object]:
     """Discard command-created files only in the named verification sidecar."""
     primary = require_directory(primary, "primary worktree")
@@ -632,17 +1496,135 @@ def clean_verify(primary: Path, worktree: Path, base: str, branch: str) -> Dict[
     return {"worktree": str(worktree), "branch": branch, "base": expected, "removed": removed}
 
 
+def ensure_verify_sidecar(primary: Path, base: str, branch: str) -> Dict[str, object]:
+    """Return the named verify sidecar, recreating it when it is missing.
+
+    Finish needs the sidecar prepare-task created. A deleted sidecar must be
+    rebuildable from the recorded base without a clean primary: the serial
+    task's own product changes are exactly the tree finish reproduces next,
+    so this must not reuse isolate_verify's clean-tree gate.
+    """
+    primary = require_directory(primary, "primary worktree")
+    if worktree_root(primary) != primary:
+        raise IsolationError(f"primary is not its Git root: {primary}")
+    resolved_base = require_commit(primary, require_full_sha(base))
+    if not branch.startswith(VERIFY_BRANCH_PREFIX):
+        raise IsolationError("verify sidecar reproduction requires a verify branch")
+    destination = _sidecar_path_for_branch(primary, branch)
+    ref = f"refs/heads/{branch}"
+    registered = _registered_worktrees(primary)
+    if destination.is_symlink() or (destination.exists() and not destination.is_dir()):
+        raise IsolationError(f"worktree path already exists: {destination}")
+    if destination.is_dir():
+        try:
+            # A leftover empty directory (a half-deleted sidecar) clears;
+            # anything non-empty must be the sidecar itself.
+            destination.rmdir()
+        except OSError:
+            try:
+                same = (
+                    worktree_root(destination) == destination
+                    and destination.resolve() in registered
+                    and registered[destination.resolve()] == ref
+                    and common_git_dir(destination) == common_git_dir(primary)
+                )
+            except IsolationError:
+                same = False
+            if not same:
+                raise IsolationError(
+                    f"verify sidecar ownership changed: {destination}"
+                ) from None
+            if (
+                require_attached(destination) != branch
+                or current_sha(destination) != resolved_base
+            ):
+                raise IsolationError(f"verify sidecar HEAD changed: {destination}")
+            return {
+                "base": resolved_base,
+                "branch": branch,
+                "kind": "verify",
+                "mode": "sidecar",
+                "worktree": str(destination),
+            }
+    if destination.resolve() in registered:
+        cleared = run_git(primary, "worktree", "remove", str(destination))
+        if cleared.returncode != 0:
+            run_git(primary, "worktree", "prune")
+            if destination.resolve() in _registered_worktrees(primary):
+                raise IsolationError(
+                    (cleared.stderr or cleared.stdout).strip()
+                    or "could not clear stale worktree registration"
+                )
+    existing = run_git(primary, "show-ref", "--verify", "--quiet", ref)
+    if existing.returncode == 0:
+        deleted = run_git(primary, "update-ref", "-d", ref)
+        if deleted.returncode != 0:
+            raise IsolationError(
+                (deleted.stderr or deleted.stdout).strip() or "git update-ref failed"
+            )
+    create_named_worktree(primary, branch, destination, resolved_base)
+    return {
+        "base": resolved_base,
+        "branch": branch,
+        "kind": "verify",
+        "mode": "sidecar",
+        "worktree": str(destination),
+    }
+
+
+def reproduce_verify_sidecar(sidecar_path: Path, tree: str) -> None:
+    """Copy the primary's current task tree into the verify sidecar (clean_verify's inverse)."""
+    git_output(sidecar_path, "read-tree", "-u", "--reset", tree)
+    if git_output(sidecar_path, "write-tree") != tree:
+        raise IsolationError("sidecar reproduction differs from the primary task diff")
+
+
 def _split_paths(block: str) -> Set[str]:
     return {line.strip() for line in block.splitlines() if line.strip()}
 
 
-# Top-level .project entries the pipeline owns; ship verification rejects anything else.
+# Top-level .project entries the pipeline owns; ship checks filter other entries by Git visibility.
 PROJECT_ENTRIES = frozenset({
-    "STATE.md", "LESSONS.md", "REPOSITORY.md", "CHARTER.md", "ROADMAP.md", "SYNTHESIS.md",
+    "STATE.md", "LESSONS.md", "REPOSITORY.md", "MEMBERS.md", "CHARTER.md", "ROADMAP.md",
+    "SYNTHESIS.md", "config.json", "model-policy.json",
     "intent", "research", "plan", "tasks", "review", "build", "discuss", "archive", "next",
 })
 
 
+def prune_host_scratch(project: Path, archive: Optional[Path] = None) -> list:
+    """Remove file-free `.claude` dirs a host left under .project.
+
+    Claude Code's Bash sandbox creates `<cwd>/.claude/.cc-writes` as an atomic-write staging dir each
+    time it initializes, and adds `**/.claude/.cc-writes/` to the global gitignore. Git cannot ship
+    empty dirs, so removal loses nothing. A `.claude` that holds any file or symlink is kept, and the
+    caller checks retained entries against Git visibility at the .project top level. Archives stay
+    untouched except `archive`, the current uncommitted one.
+    """
+    roots = [path for path in project.iterdir() if path.name != "archive"]
+    if archive is not None:
+        roots.append(archive)
+    hosts = []
+    for root in roots:
+        if root.is_symlink() or not root.is_dir():
+            continue
+        if root.name == ".claude":
+            hosts.append(root)
+        for directory, names, _ in os.walk(root):
+            hosts.extend(Path(directory, name) for name in names if name == ".claude")
+    removed = []
+    for host in hosts:
+        if host.is_symlink() or not host.is_dir():
+            continue  # a symlink, or already removed with an outer `.claude`
+        tree = list(os.walk(host, topdown=False))
+        if any(files or any(Path(directory, name).is_symlink() for name in names)
+               for directory, names, files in tree):
+            continue
+        for directory, _, _ in tree:
+            os.rmdir(directory)
+        removed.append(host.relative_to(project).as_posix())
+    return removed
+
+
 def uncommitted_paths(repo: Path) -> Set[str]:
     tracked = git_output(
         repo, "diff", "--no-renames", "--name-only", "--relative", "HEAD"
@@ -664,12 +1646,30 @@ def committed_paths_since(repo: Path, base: str) -> Set[str]:
     )
 
 
-def _commit_pending(repo: Path, pending: Set[str], subject: str, body: str) -> str:
+def ignored_legacy_ledger(repo: Path) -> bool:
+    """True when a verify ledger absent from HEAD is hidden by an ignore rule.
+
+    Only milestones started before verify-record refused ignored ledgers reach
+    this state. A build checkpoint commits the file so a task that anchors the
+    rule does not expose it as a task change.
+    """
+    path = repo.joinpath(*PurePosixPath(VERIFY_LEDGER_PATH).parts)
+    if path.is_symlink() or not path.is_file():
+        return False
+    if run_git(repo, "cat-file", "-e", f"HEAD:{VERIFY_LEDGER_PATH}").returncode == 0:
+        return False
+    return run_git(repo, "check-ignore", "-q", "--no-index", "--", VERIFY_LEDGER_PATH).returncode == 0
+
+
+def _commit_pending(
+    repo: Path, pending: Set[str], subject: str, body: str, forced: Set[str] = frozenset()
+) -> str:
     reset = run_git(repo, "reset", "-q", "HEAD")
     if reset.returncode != 0:
         raise IsolationError("could not clear the index before commit")
     for path in sorted(pending):
-        added = run_git(repo, "add", "-A", "--", path)
+        mode = "-f" if path in forced else "-A"
+        added = run_git(repo, "add", mode, "--", path)
         if added.returncode != 0:
             raise IsolationError(f"could not stage {path}")
     staged = _split_paths(
@@ -691,14 +1691,24 @@ def _commit_pending(repo: Path, pending: Set[str], subject: str, body: str) -> s
 
 
 def validate_allowed_changes(
-    repo: Path, base: str, pending: Set[str], allowed: Set[str]
+    repo: Path,
+    base: str,
+    pending: Set[str],
+    allowed: Set[str],
+    tolerated: Set[str] = frozenset(),
 ) -> None:
-    if not pending:
+    # Tolerated paths (primary bookkeeping) may stay uncommitted; the next
+    # `.project` checkpoint commits them.
+    landing = pending - tolerated
+    if not landing:
         raise IsolationError("no changes to land")
-    since_base = committed_paths_since(repo, base) | pending
+    since_base = committed_paths_since(repo, base) | landing
     unexpected = sorted(path for path in since_base if path not in allowed)
     if unexpected:
-        raise IsolationError("unexpected paths: " + ", ".join(unexpected))
+        raise IsolationError(
+            "unexpected paths: " + ", ".join(unexpected)
+            + "; landing allows only the task file and its declared files"
+        )
 def _clean_blob_oid(repo: Path, path: str, text: str, *, write: bool) -> str:
     arguments = ["hash-object"]
     if write:
@@ -718,21 +1728,23 @@ def commit_allowed_changes(
     subject: str,
     allowed: Set[str],
     body: str,
+    tolerated: Set[str] = frozenset(),
 ) -> tuple[str, str, Dict[str, Optional[tuple[str, str]]]]:
     require_attached(repo)
     pending = uncommitted_paths(repo)
-    validate_allowed_changes(repo, base, pending, allowed)
+    validate_allowed_changes(repo, base, pending, allowed, tolerated)
+    staging = pending - tolerated
     reset = run_git(repo, "reset", "-q", "HEAD")
     if reset.returncode != 0:
         raise IsolationError("could not clear the index before landing")
-    for path in sorted(pending):
+    for path in sorted(staging):
         added = run_git(repo, "add", "-A", "--", path)
         if added.returncode != 0:
             raise IsolationError(f"could not stage {path}")
     staged = _split_paths(
         git_output(repo, "diff", "--cached", "--name-only", "--relative")
     )
-    if staged != pending:
+    if staged != staging:
         raise IsolationError("staged paths do not match the uncommitted change set")
     verified_tree = git_output(repo, "write-tree")
     verified_delta = _tree_delta(repo, base, verified_tree)
@@ -878,6 +1890,17 @@ def activate_task(
     if task_branch is None:
         if branch.startswith(TASK_BRANCH_PREFIX):
             raise IsolationError("parallel task activation requires --task-branch")
+        live = [
+            path
+            for path, ref in _registered_worktrees(worktree).items()
+            if ref == f"refs/heads/{task_branch_name(task_id)}"
+            and path != worktree
+        ]
+        if live:
+            raise IsolationError(
+                "task has an active parallel worktree; serial activation in "
+                f"another worktree is refused (activate {live[0]} with --task-branch)"
+            )
     elif task_branch != task_branch_name(task_id) or branch != task_branch:
         raise IsolationError("task activation branch does not match the task worktree")
     normalized_task = relative_posix(task_file)
@@ -908,7 +1931,7 @@ def activate_task(
             if existing.returncode != 0 or existing.stdout.strip() != resolved_base:
                 _replace_regular_file(task_path, text.encode("utf-8"), mode)
                 raise IsolationError("could not record task worktree authorization")
-    return {
+    result = {
         "agent": agent,
         "base": resolved_base,
         "status": "in-progress",
@@ -916,6 +1939,30 @@ def activate_task(
         "task_file": normalized_task,
         "worktree": str(worktree),
     }
+    _write_native_dispatch_record(worktree, result)
+    return result
+
+
+def _write_native_dispatch_record(worktree: Path, activation: Dict[str, object]) -> None:
+    try:
+        if __package__:
+            from . import dispatch_driver
+        else:
+            import dispatch_driver
+    except ImportError:
+        return
+    dispatch_driver.record_native_activation(worktree, activation)
+
+
+def _write_native_member_dispatch_record(coordinator: Path, activation: Dict[str, object]) -> None:
+    try:
+        if __package__:
+            from . import dispatch_driver
+        else:
+            import dispatch_driver
+    except ImportError:
+        return
+    dispatch_driver.record_native_member_activation(coordinator, activation)
 
 
 def deactivate_task(
@@ -1034,6 +2081,59 @@ def stamp_task_landed(task_path: Path, base: str) -> None:
     )
 
 
+def block_serial_task(
+    primary: Path, task_file: str, task_id: str, base: str
+) -> Dict[str, str]:
+    """Record an explicit blocked result on its still-active serial task."""
+    primary = require_directory(primary, "primary worktree")
+    if worktree_root(primary) != primary:
+        raise IsolationError(f"primary is not its Git root: {primary}")
+    normalized_task = relative_posix(task_file)
+    if not normalized_task.startswith(".project/tasks/"):
+        raise IsolationError("serial task file must stay under .project/tasks/")
+    task_id = validate_task_id(task_id)
+    expected_base = require_commit(primary, require_full_sha(base))
+    task_path = _real_file(primary, normalized_task, "serial task file")
+    text, mode = _read_task_text(task_path)
+    fields, error = task_frontmatter(text)
+    if error or fields is None:
+        raise IsolationError(error or "serial task frontmatter is unreadable")
+    if fields.get("id") != task_id:
+        raise IsolationError("serial task id changed before blocked result")
+    if fields.get("status") not in {"in-progress", "blocked"}:
+        raise IsolationError("serial task is no longer active")
+    if fields.get("base") != expected_base:
+        raise IsolationError("serial task base changed before blocked result")
+    if fields.get("task_branch") != "null":
+        raise IsolationError("serial task records a task branch")
+    recorded_worktree = fields.get("worktree")
+    if not isinstance(recorded_worktree, str) or Path(recorded_worktree).resolve() != primary:
+        raise IsolationError("serial task worktree changed before blocked result")
+
+    if fields.get("status") == "blocked":
+        return {"task_id": task_id, "task_file": normalized_task,
+                "base": expected_base, "status": "blocked"}
+
+    head, body = split_frontmatter(text)
+    replaced = False
+    lines = []
+    for line in head:
+        if _frontmatter_key(line) == "status":
+            if replaced:
+                raise IsolationError("serial task frontmatter repeats status")
+            replaced = True
+            lines.append("status: blocked")
+        else:
+            lines.append(line)
+    if not replaced:
+        raise IsolationError("serial task frontmatter is missing status")
+    _replace_regular_file(
+        task_path, ("---\n" + "\n".join(lines) + "\n---\n" + body).encode("utf-8"), mode
+    )
+    return {"task_id": task_id, "task_file": normalized_task,
+            "base": expected_base, "status": "blocked"}
+
+
 def _restore_landing_state(
     worktree: Path, task_path: Path, task_bytes: bytes, task_mode: int, index_tree: str
 ) -> None:
@@ -1068,7 +2168,12 @@ def _restore_rejected_commit(
 
 
 def _stamp_and_commit(
-    worktree: Path, base: str, subject: str, task_file: str, allowed: Set[str]
+    worktree: Path,
+    base: str,
+    subject: str,
+    task_file: str,
+    allowed: Set[str],
+    tolerated: Set[str] = frozenset(),
 ) -> tuple[str, Dict[str, Optional[tuple[str, str]]]]:
     task_path = worktree / task_file
     task_text, task_mode = _read_task_text(task_path)
@@ -1089,14 +2194,14 @@ def _stamp_and_commit(
     pending = uncommitted_paths(worktree)
     if stamped != task_bytes:
         pending.add(task_file)
-    validate_allowed_changes(worktree, base, pending, allowed)
+    validate_allowed_changes(worktree, base, pending, allowed, tolerated)
     original_head = current_sha(worktree)
     index_tree = git_output(worktree, "write-tree")
     try:
         _replace_regular_file(task_path, stamped, task_mode)
-        body = task_commit_body(task_file, uncommitted_paths(worktree), base)
+        body = task_commit_body(task_file, uncommitted_paths(worktree) - tolerated, base)
         commit, verified_tree, verified_delta = commit_allowed_changes(
-            worktree, base, subject, allowed, body
+            worktree, base, subject, allowed, body, tolerated
         )
         proof_error = _landing_commit_proof_error(
             worktree,
@@ -1147,6 +2252,10 @@ def land(
         raise IsolationError(f"source is not its Git root: {source}")
     if common_git_dir(primary) != common_git_dir(source):
         raise IsolationError("source worktree belongs to another repository")
+    # The source holds the task's own .gitignore edits, so a task that anchors a rule can land.
+    ignore_error = _common.project_ignore_error(source)
+    if ignore_error:
+        raise IsolationError(ignore_error)
     bound = require_bound(primary)
     source_branch = require_attached(source)
     resolved_base = require_commit(primary, require_full_sha(base))
@@ -1170,6 +2279,7 @@ def land(
             subject,
             relative_posix(task_file),
             allowed,
+            BOOKKEEPING_PATHS,
         )
         return {
             "bound_branch": bound,
@@ -1464,7 +2574,7 @@ def _landing_retry_error(
     if task_file not in pending:
         return "interrupted landing does not retain the task change"
     try:
-        validate_allowed_changes(repo, base, pending, contract_paths)
+        validate_allowed_changes(repo, base, pending, contract_paths, BOOKKEEPING_PATHS)
     except IsolationError as validation_error:
         return str(validation_error)
     return None
@@ -1687,6 +2797,145 @@ def _resume_task_error(
     return _retained_task_contract_error(current_text, isolate_text)
 
 
+def _serial_bookkeeping_error(primary: Path, base: str, head: str) -> Optional[str]:
+    """Prove that serial task history advanced only through linear .project commits."""
+    if base == head:
+        return None
+    if run_git(primary, "merge-base", "--is-ancestor", base, head).returncode != 0:
+        return "recorded base is not an ancestor of the current branch"
+    commits = git_output(
+        primary, "rev-list", "--first-parent", "--reverse", f"{base}..{head}"
+    ).splitlines()
+    previous = base
+    for commit in commits:
+        parents = git_output(primary, "rev-list", "--parents", "-n", "1", commit).split()
+        if len(parents) != 2 or parents[1] != previous:
+            return "history contains an unproven merge or commit sequence"
+        paths = git_output(
+            primary,
+            "diff-tree",
+            "--no-commit-id",
+            "--name-only",
+            "-r",
+            "--no-renames",
+            previous,
+            commit,
+        ).splitlines()
+        if not paths:
+            return "history contains an empty commit"
+        if any(path != ".project" and not path.startswith(".project/") for path in paths):
+            return "history contains changes outside .project"
+        previous = commit
+    if previous != head:
+        return "history does not prove a first-parent path from the recorded base"
+    return None
+
+
+MEMBER_RECORD_RE = re.compile(
+    r"Task: (?P<task>\S+)\nBase: (?P<base>[0-9a-f]{40})\n"
+    r"Member: (?P<member>\S+) (?P<landing>[0-9a-f]{40}) (?P<member_base>[0-9a-f]{40})"
+)
+
+
+def _recover_unfinished_member_task(coordinator: Path, task_id: str, member: str) -> Dict[str, object]:
+    """Unfinished member task: a pending journal retries landing; a retained sidecar resumes."""
+    if os.path.lexists(_member_journal_path(coordinator, task_id)):
+        return {"verdict": "resume", "landing_retry": True, "member": member, "worktree": None}
+    try:
+        checkout, project, _ = _member_context(coordinator, member)
+    except IsolationError as error:
+        return {"verdict": "block", "reason": str(error)}
+    branch = f"{TASK_BRANCH_PREFIX}{project}-{task_id}"
+    retained = run_git(checkout, "rev-parse", "--verify", "--quiet", f"refs/heads/{branch}").returncode == 0
+    if retained:
+        return {"verdict": "resume", "member": member, "task_branch": None, "worktree": None,
+                "member_task_branch": branch}
+    return {"verdict": "none", "reason": "pending member task has no retained isolate"}
+
+
+def deactivate_member_task(coordinator: Path, member: str, task_id: str) -> None:
+    """Clear a member task's authorization so a failed attempt cannot land."""
+    checkout, project, _ = _member_context(coordinator, member)
+    deleted = run_git(checkout, "update-ref", "-d", member_task_authorization_ref(project, task_id))
+    if deleted.returncode != 0:
+        raise IsolationError((deleted.stderr or deleted.stdout).strip() or "could not clear member task authorization")
+
+
+def member_log_delta(contract: str, copy: str) -> str:
+    """The Log a coder appended to a member task's live copy since its contract."""
+    expected, expected_error = task_frontmatter(contract)
+    fields, error = task_frontmatter(copy)
+    if expected_error or error or expected is None or fields is None:
+        raise IsolationError(error or expected_error or "unreadable member task copy")
+    if {key: value for key, value in fields.items() if key not in MEMBER_ACTIVATION_FIELDS} != {
+            key: value for key, value in expected.items() if key not in MEMBER_ACTIVATION_FIELDS}:
+        raise IsolationError("member task copy changes contract fields")
+    base_body = _normalize_newlines(split_frontmatter(contract)[1])
+    body = _normalize_newlines(split_frontmatter(copy)[1])
+    if not body.startswith(base_body):
+        raise IsolationError("member task copy Log is not append-only")
+    return body[len(base_body):]
+
+
+def _prove_member_task(
+    coordinator: Path, task_file: str, fields: Dict[str, object], subject: str,
+    history: Dict[str, list[tuple[str, str]]],
+) -> Dict[str, object]:
+    """A done member task: one coordinator record naming a proven member landing."""
+    if fields.get("status") != "done":
+        return {"verdict": "block", "reason": "member task must have status: done"}
+    member = str(fields.get("repo"))
+    records = []
+    for sha, body in history.get(subject, []):
+        match = MEMBER_RECORD_RE.fullmatch(body.strip())
+        if match and match["task"] == task_file and match["member"] == member:
+            records.append((sha, match))
+    if len(records) != 1:
+        return {"verdict": "block", "reason": f"expected one coordinator record for {task_file}, found {len(records)}"}
+    record, match = records[0]
+    if git_output(coordinator, "diff-tree", "--no-commit-id", "--name-only", "-r", record).splitlines() != [task_file]:
+        return {"verdict": "block", "reason": "the coordinator record touches more than the task file"}
+    for field in ("base", "member_base"):
+        if fields.get(field) != match[field]:
+            return {"verdict": "block", "reason": f"task {field} does not match the coordinator record"}
+    try:
+        recorded = run_git(coordinator, "show", f"{record}:{task_file}")
+        if recorded.returncode != 0:
+            raise IsolationError(f"task is missing from coordinator record: {task_file}")
+        recorded_fields, error = task_frontmatter(recorded.stdout)
+        if error or recorded_fields is None:
+            raise IsolationError(error or f"unreadable recorded task: {task_file}")
+        if recorded_fields.get("status") != "done":
+            raise IsolationError("recorded task status is not done")
+        for field in ("base", "member_base"):
+            if recorded_fields.get(field) != match[field]:
+                raise IsolationError(f"recorded task {field} does not match the coordinator record")
+        checkout, _, entry = _member_context(coordinator, member, lock_at=record)
+        _, allowed = _member_contract(
+            coordinator, match["base"], task_file, member, current_text=recorded.stdout
+        )
+        if any(fields.get(key) != recorded_fields.get(key) for key in MEMBER_IMMUTABLE_FIELDS):
+            raise IsolationError(f"task artifact contract differs from {match['base']}: {task_file}")
+    except IsolationError as error:
+        return {"verdict": "block", "reason": str(error)}
+    landing = match["landing"]
+    history_on_bound = git_output(checkout, "rev-list", "--first-parent", f"refs/heads/{entry['branch']}").split()
+    if landing not in history_on_bound:
+        return {"verdict": "block", "reason": f"landing {landing[:12]} is not on the member bound branch"}
+    parent, error = _single_parent(checkout, landing)
+    if error or parent is None or run_git(
+            checkout, "merge-base", "--is-ancestor", match["member_base"], parent).returncode != 0:
+        return {"verdict": "block", "reason": error or "member landing does not descend from member_base"}
+    paths = git_output(checkout, "diff-tree", "--no-commit-id", "--name-only", "-r", "--no-renames",
+                       parent, landing).splitlines()
+    body = member_commit_body(task_file, paths, match["member_base"], match["base"])
+    error = _prove_member_commit(checkout, landing, parent, subject, body, allowed)
+    if error:
+        return {"verdict": "block", "reason": f"member landing proof failed: {error}"}
+    return {"verdict": "recovered", "commit": record, "base": match["base"],
+            "landing": landing, "member": member}
+
+
 def _recover_task(
     primary: Path,
     path: Path,
@@ -1718,6 +2967,14 @@ def _recover_task(
         return result("block", reason=str(error))
     except IsolationError as exc:
         return result("block", reason=str(exc))
+    if fields.get("repo"):
+        # Only the landing record proves member task completion.
+        if status in ("pending", "in-progress"):
+            if any(MEMBER_RECORD_RE.fullmatch(body.strip()) and f"Task: {task_file}\n" in body
+                   for _, body in history.get(subject, [])):
+                return result("block", reason="member task has a landing record but is not done")
+            return result(**_recover_unfinished_member_task(primary, task_id, str(fields["repo"])))
+        return result(**_prove_member_task(primary, task_file, fields, subject, history))
     task_branch = task_branch_name(task_id)
     branch_exists = task_branch in branches
     worktree, worktree_error = _worktree_report(
@@ -1863,8 +3120,12 @@ def _recover_task(
                 )
             except IsolationError as error:
                 return result("block", reason=f"{status} task has invalid base: {error}")
-            if head != base:
-                return result("block", reason=f"{status} serial task advanced past its base")
+            advance_error = _serial_bookkeeping_error(primary, base, head)
+            if advance_error:
+                return result(
+                    "block",
+                    reason=f"{status} serial task advanced past its base: {advance_error}",
+                )
             primary_worktree, primary_error = _worktree_report(primary, primary, bound)
             if primary_error:
                 return result("block", reason=primary_error)
@@ -1878,6 +3139,15 @@ def _recover_task(
                 str(primary),
                 "null",
             )
+            if head != base and resume_error is None:
+                return result(
+                    "reconcile",
+                    base=base,
+                    reason=(
+                        "serial task advanced through .project bookkeeping; reconcile the "
+                        "attempt and any retained Verify sidecar before resetting it to pending"
+                    ),
+                )
         if resume_error:
             return result("block", reason=resume_error)
         return result("resume", base=base)
@@ -1906,8 +3176,12 @@ def _recover_task(
         if serial_retained:
             if str(fields.get("task_branch", "")) != "null":
                 return result("block", reason=f"{status} serial task records a task branch")
-            if run_git(primary, "merge-base", "--is-ancestor", base, head).returncode != 0:
-                return result("block", reason=f"{status} serial task base is not an ancestor")
+            advance_error = _serial_bookkeeping_error(primary, base, head)
+            if advance_error:
+                return result(
+                    "block",
+                    reason=f"{status} serial task advanced past its base: {advance_error}",
+                )
             primary_worktree, primary_error = _worktree_report(primary, primary, bound)
             if primary_error:
                 return result("block", reason=primary_error)
@@ -2907,10 +4181,13 @@ def publication_base(repo: Path, branch: str, ship_commit: str) -> Optional[str]
     Returns None when the milestone is not an adopted one; raises when the
     archived receipt, ship commit, or archived tasks fail proof.
     """
-    try:
-        from pipeline_state import load_state
-    except ImportError:  # pragma: no cover - package import used by tests
-        from scripts.pipeline_state import load_state
+    if __package__:
+        from .pipeline_state import load_state
+    else:
+        try:
+            from pipeline_state import load_state
+        except ImportError:  # pragma: no cover - package import used by tests
+            from scripts.pipeline_state import load_state
     repo = require_directory(repo, "repository")
     state, state_text, _ = load_state(repo)
     if (state.phase, state.status, state.integration, state.branch) != (
@@ -3123,6 +4400,22 @@ def checkpoint(
             }
         raise IsolationError("primary HEAD differs from --expected-head")
     pending = uncommitted_paths(repo)
+    forced: Set[str] = set()
+    # Build only: an approval undo resets to a parent without the ledger and would drop it.
+    if (
+        subject.strip().startswith("build:")
+        and any(
+            VERIFY_LEDGER_PATH == path or VERIFY_LEDGER_PATH.startswith(path + "/")
+            for path in allowed
+        )
+        and ignored_legacy_ledger(repo)
+    ):
+        try:
+            _common.verify_ledger_entries(repo / VERIFY_LEDGER_PATH)
+        except ValueError as error:
+            raise IsolationError(str(error)) from error
+        forced.add(VERIFY_LEDGER_PATH)
+        pending.add(VERIFY_LEDGER_PATH)
     if not pending:
         raise IsolationError("no changes to checkpoint")
     unexpected = sorted(
@@ -3176,7 +4469,7 @@ def checkpoint(
                 + ", ".join(removed)
             )
     return {
-        "commit": _commit_pending(repo, pending, normalized_subject, body),
+        "commit": _commit_pending(repo, pending, normalized_subject, body, forced),
         "paths": sorted(pending),
         "status": "committed",
         "subject": normalized_subject,
@@ -3303,6 +4596,16 @@ def retire(
                         )
                     if proof_error:
                         raise IsolationError(proof_error)
+                    # A half-retire can leave the missing checkout registered, which blocks -D.
+                    if _registered_worktrees(primary).get(resolved_worktree) == f"refs/heads/{branch}":
+                        cleared = run_git(
+                            primary, "worktree", "remove", str(resolved_worktree)
+                        )
+                        if cleared.returncode != 0:
+                            raise IsolationError(
+                                (cleared.stderr or cleared.stdout).strip()
+                                or "could not clear stale worktree registration"
+                            )
                     deleted = run_git(primary, "branch", "-D", branch)
                     if deleted.returncode != 0:
                         raise IsolationError(
@@ -3310,6 +4613,7 @@ def retire(
                             or f"could not delete {branch}"
                         )
                 branch_retired = True
+        release_workspace_quietly(primary)
         return {
             "bound_branch": bound,
             "branch": branch,
@@ -3343,22 +4647,13 @@ def retire(
             raise IsolationError(
                 "worktree is dirty; pass --force only from the retry-retirement path"
             )
-    remove = run_git(
-        primary,
-        "worktree",
-        "remove",
-        *(("--force",) if force else ()),
-        str(resolved_worktree),
-    )
-    if remove.returncode != 0:
-        raise IsolationError(
-            (remove.stderr or remove.stdout).strip() or "git worktree remove failed"
-        )
+    _remove_worktree(primary, resolved_worktree, force)
     deleted = run_git(primary, "branch", "-D", retire_branch)
     if deleted.returncode != 0:
         raise IsolationError(
             (deleted.stderr or deleted.stdout).strip() or f"could not delete {retire_branch}"
         )
+    release_workspace_quietly(primary)
     return {
         "bound_branch": bound,
         "branch": retire_branch,
@@ -3368,6 +4663,54 @@ def retire(
     }
 
 
+def retire_unused_verify(
+    primary: Path, worktree: Path, base: str, branch: str
+) -> Dict[str, object]:
+    """Retire a Verify sidecar only when it is provably untouched since creation."""
+    primary = require_directory(primary, "primary worktree")
+    if worktree_root(primary) != primary:
+        raise IsolationError(f"primary is not its Git root: {primary}")
+    if not branch.startswith(VERIFY_BRANCH_PREFIX):
+        raise IsolationError("unused Verify retirement requires a verify branch")
+    expected = _sidecar_path_for_branch(primary, branch)
+    resolved_worktree = worktree.resolve()
+    if resolved_worktree != expected:
+        raise IsolationError("unused Verify path differs from its branch")
+    expected_base = require_commit(primary, require_full_sha(base))
+
+    if os.path.lexists(worktree):
+        if worktree.is_symlink() or not worktree.is_dir() or worktree.resolve() != worktree:
+            raise IsolationError(f"unused Verify path is not an owned worktree: {worktree}")
+        if worktree_root(worktree) != worktree:
+            raise IsolationError(f"unused Verify path is not its Git root: {worktree}")
+        if common_git_dir(primary) != common_git_dir(worktree):
+            raise IsolationError("unused Verify sidecar belongs to another repository")
+        if require_attached(worktree) != branch:
+            raise IsolationError("unused Verify sidecar branch changed")
+        if current_sha(worktree) != expected_base:
+            raise IsolationError("unused Verify sidecar HEAD changed; preserving it")
+        dirty = git_output(
+            worktree,
+            "status",
+            "--porcelain",
+            "--untracked-files=all",
+            "--ignored=matching",
+        )
+        if dirty:
+            raise IsolationError("unused Verify sidecar has uncommitted files; preserving it")
+    else:
+        branch_head = run_git(
+            primary, "rev-parse", "--verify", "--quiet", f"refs/heads/{branch}"
+        )
+        if branch_head.returncode == 0 and branch_head.stdout.strip() != expected_base:
+            raise IsolationError("unused Verify branch HEAD changed; preserving it")
+        for registered_path, registered_branch in _registered_worktrees(primary).items():
+            if registered_branch == f"refs/heads/{branch}" and registered_path != expected:
+                raise IsolationError("unused Verify branch is checked out at another path")
+
+    return retire(primary, expected, branch, False)
+
+
 def parser() -> argparse.ArgumentParser:
     argument_parser = argparse.ArgumentParser(description=__doc__)
     subparsers = argument_parser.add_subparsers(dest="command", required=True)
@@ -3390,6 +4733,33 @@ def parser() -> argparse.ArgumentParser:
     activate_task_parser.add_argument("--task-file", required=True)
     activate_task_parser.add_argument("--task-branch")
 
+    isolate_member_parser = subparsers.add_parser(
+        "isolate-member-task", help="create a member task sidecar at the member bound tip"
+    )
+    isolate_member_parser.add_argument("--repo", type=Path, required=True, help="coordinator root")
+    isolate_member_parser.add_argument("--member", required=True)
+    isolate_member_parser.add_argument("--task-id", required=True)
+
+    activate_member_parser = subparsers.add_parser(
+        "activate-member-task", help="record one member task dispatch in its sidecar"
+    )
+    activate_member_parser.add_argument("--repo", type=Path, required=True, help="coordinator root")
+    activate_member_parser.add_argument("--member", required=True)
+    activate_member_parser.add_argument("--task-id", required=True)
+    activate_member_parser.add_argument("--agent", required=True)
+    activate_member_parser.add_argument("--task-file", required=True)
+    activate_member_parser.add_argument("--base", required=True)
+
+    retire_member_parser = subparsers.add_parser(
+        "retire-member-task", help="remove a member task sidecar and branch before a retry"
+    )
+    retire_member_parser.add_argument("--repo", type=Path, required=True, help="coordinator root")
+    retire_member_parser.add_argument("--member", required=True)
+    retire_member_parser.add_argument("--task-id", required=True)
+    retire_member_parser.add_argument("--force", action="store_true",
+                                      help="discard a rejected attempt whose Log the coordinator task holds")
+    retire_member_parser.add_argument("--task-file")
+
     deactivate_task_parser = subparsers.add_parser(
         "deactivate-task", help="revoke one helper-owned task dispatch"
     )
@@ -3490,6 +4860,17 @@ def main(argv: Optional[Sequence[str]] = None) -> int:
                 arguments.task_file,
                 arguments.task_branch,
             )
+        elif arguments.command == "isolate-member-task":
+            result = isolate_member_task(arguments.repo, arguments.member, arguments.task_id)
+        elif arguments.command == "activate-member-task":
+            result = activate_member_task(arguments.repo, arguments.member, arguments.task_id,
+                                          arguments.agent, arguments.task_file, arguments.base)
+        elif arguments.command == "retire-member-task":
+            copy_rejected = retire_member_task(arguments.repo, arguments.member, arguments.task_id,
+                                               arguments.force, arguments.task_file)
+            result = {"member": arguments.member, "retired": True, "task_id": arguments.task_id}
+            if copy_rejected:
+                result["copy_rejected"] = copy_rejected
         elif arguments.command == "deactivate-task":
             result = deactivate_task(
                 arguments.repo,