@opengsd/gsd-path 1.3.1 → 1.4.0

package/skills/gsd-path-roadmap/scripts/archive_milestone.py

@@ -24,13 +24,15 @@ from datetime import date
 from pathlib import Path, PurePosixPath
 from typing import Iterator, NamedTuple, Optional, Sequence
 
-try:
-    from isolation import (
+if __package__:
+    from .isolation import (
         IsolationError,
+        prune_host_scratch,
+        PROJECT_ENTRIES,
         checkpoint as isolation_checkpoint,
         verify_landed_task_files,
     )
-    from pipeline_git import (
+    from .pipeline_git import (
         bound_branch_name,
         default_branch_name,
         integrate_commit_body,
@@ -43,45 +45,75 @@ try:
         ship_commit_body,
         ship_subject,
     )
-    from review_panel import KNOWN_FAMILIES, ReviewPanelError, parse_sources
-    from pipeline_state import (
+    from .review_panel import KNOWN_FAMILIES, ReviewPanelError, parse_sources
+    from .pipeline_state import (
         PipelineState,
         PipelineStateError,
         load_state,
         transition_state,
     )
-    import _common
-except ImportError:  # pragma: no cover - package import used by tests
-    from scripts.isolation import (
-        IsolationError,
-        checkpoint as isolation_checkpoint,
-        verify_landed_task_files,
-    )
-    from scripts.pipeline_git import (
-        bound_branch_name,
-        default_branch_name,
-        integrate_commit_body,
-        integrate_subject,
-        is_bound_branch,
-        is_integrate_subject,
-        is_ship_subject,
-        milestone_id,
-        milestone_number,
-        ship_commit_body,
-        ship_subject,
-    )
-    from scripts.review_panel import KNOWN_FAMILIES, ReviewPanelError, parse_sources
-    from scripts.pipeline_state import (
-        PipelineState,
-        PipelineStateError,
-        load_state,
-        transition_state,
-    )
-    from scripts import _common
-
-if sys.platform == "win32":
-    import msvcrt
+    from . import _common
 else:
+    try:
+        from isolation import (
+            IsolationError,
+            prune_host_scratch,
+            PROJECT_ENTRIES,
+            checkpoint as isolation_checkpoint,
+            verify_landed_task_files,
+        )
+        from pipeline_git import (
+            bound_branch_name,
+            default_branch_name,
+            integrate_commit_body,
+            integrate_subject,
+            is_bound_branch,
+            is_integrate_subject,
+            is_ship_subject,
+            milestone_id,
+            milestone_number,
+            ship_commit_body,
+            ship_subject,
+        )
+        from review_panel import KNOWN_FAMILIES, ReviewPanelError, parse_sources
+        from pipeline_state import (
+            PipelineState,
+            PipelineStateError,
+            load_state,
+            transition_state,
+        )
+        import _common
+    except ImportError:  # pragma: no cover - package import used by tests
+        from scripts.isolation import (
+            IsolationError,
+            prune_host_scratch,
+            PROJECT_ENTRIES,
+            checkpoint as isolation_checkpoint,
+            verify_landed_task_files,
+        )
+        from scripts.pipeline_git import (
+            bound_branch_name,
+            default_branch_name,
+            integrate_commit_body,
+            integrate_subject,
+            is_bound_branch,
+            is_integrate_subject,
+            is_ship_subject,
+            milestone_id,
+            milestone_number,
+            ship_commit_body,
+            ship_subject,
+        )
+        from scripts.review_panel import KNOWN_FAMILIES, ReviewPanelError, parse_sources
+        from scripts.pipeline_state import (
+            PipelineState,
+            PipelineStateError,
+            load_state,
+            transition_state,
+        )
+        from scripts import _common
+
+if sys.platform != "win32":
     import fcntl
 
 
@@ -350,31 +382,25 @@ else:  # standalone script or sibling import
 @contextmanager
 def discussion_lock(active_root: Path) -> Iterator[None]:
     if sys.platform == "win32":
-        lock_value = require_git_success(
-            run_git(
-                active_root.parent,
-                "rev-parse",
-                "--git-path",
-                "gsd-path-discussion.lock",
-            ),
-            "resolve discussion lock",
+        # Windows cannot flock a directory, so lock a file in the git dir,
+        # where it never shows up as an untracked project file.
+        resolved = run_git(
+            active_root.parent,
+            "rev-parse",
+            "--git-path",
+            "gsd-path-discussion.lock",
         )
-        lock_path = Path(lock_value)
+        if resolved.returncode != 0 or not resolved.stdout.strip():
+            # Outside git, which the POSIX directory lock allows: the same
+            # named kernel mutex pipeline_state holds for this directory.
+            with _common.directory_mutex(active_root):
+                yield
+            return
+        lock_path = Path(resolved.stdout.strip())
         if not lock_path.is_absolute():
             lock_path = active_root.parent / lock_path
-        lock_path.parent.mkdir(parents=True, exist_ok=True)
-        with lock_path.open("a+b") as handle:
-            handle.seek(0, os.SEEK_END)
-            if handle.tell() == 0:
-                handle.write(b"\0")
-                handle.flush()
-            handle.seek(0)
-            msvcrt.locking(handle.fileno(), msvcrt.LK_LOCK, 1)
-            try:
-                yield
-            finally:
-                handle.seek(0)
-                msvcrt.locking(handle.fileno(), msvcrt.LK_UNLCK, 1)
+        with _common.exclusive_lock(lock_path):
+            yield
         return
 
     descriptor = os.open(active_root, os.O_RDONLY)
@@ -535,6 +561,8 @@ def archive_sequence_entries(project: Path) -> dict[int, Path]:
     archive_root = safe_archive_root(project)
     entries = {}
     for candidate in archive_root.iterdir():
+        if _common.is_ignored_junk(candidate):
+            continue
         match = ARCHIVE_PATTERN.fullmatch(candidate.name)
         if match is None or not candidate.is_dir():
             raise ArchiveError(f"archive root has a noncanonical entry: {candidate.name}")
@@ -620,7 +648,7 @@ def pending_ruling_count(audit: Path) -> int:
 
 
 def is_existing_carry_forward(source: Path, archived: Path) -> bool:
-    entries = list(source.iterdir()) if source.is_dir() else []
+    entries = [path for path in source.iterdir() if not _common.is_ignored_junk(path)] if source.is_dir() else []
     archived_audit = archived / "DOCS-AUDIT.md"
     if not archived_audit.is_file() or pending_ruling_count(archived_audit) == 0:
         return False
@@ -681,7 +709,7 @@ def is_real_file(path: Path) -> bool:
 def canonical_task_files(tasks: Path) -> Sequence[Path]:
     if tasks.is_symlink() or not tasks.is_dir():
         return ()
-    candidates = sorted(tasks.iterdir())
+    candidates = sorted(path for path in tasks.iterdir() if not _common.is_ignored_junk(path))
     if any(
         not TASK_FILE_PATTERN.fullmatch(path.name) or not is_real_file(path)
         for path in candidates
@@ -1001,6 +1029,7 @@ def prepare(repo: Path, slug: str) -> dict:
     project = repo.resolve()
     active_root = require_project_layout(project)
     with discussion_lock(active_root):
+        prune_host_scratch(active_root)
         return prepare_locked(project, active_root, slug)
 
 
@@ -1131,13 +1160,7 @@ def require_canonical_abandon_inputs(active_root: Path, archive: Path) -> None:
 def write_abandon_manifest(
     archive: Path, slug: str, ruling: str, abandoned_on: str
 ) -> None:
-    contents = []
-    for path in archive.rglob("*"):
-        if path.is_symlink():
-            raise ArchiveError(f"archive contents must not be symlinks: {path}")
-        if path.is_file() and path.name != "MANIFEST.md":
-            contents.append(path.relative_to(archive).as_posix())
-    contents.sort()
+    contents = archive_file_inventory(archive)
     listed_contents = "\n".join(f"- {path}" for path in contents)
     atomic_replace(
         archive / "MANIFEST.md",
@@ -1693,10 +1716,13 @@ def require_clean_older_archives(project: Path, configured: str) -> None:
     current_prefix = f"{configured}/"
     dirty = set()
     ignored_current = set()
+    current_files = {f"{configured}/{name}" for name in archive_file_inventory(project / configured)}
     for record in status.split("\0"):
         has_status = len(record) > 3 and record[2] == " "
         code = record[:2] if has_status else ""
         path = record[3:] if has_status else record
+        if code == "!!" and _common.is_ignored_junk(project / path) and path not in current_files:
+            continue  # Ignored OS junk never ships and is not an artifact.
         if code == "!!" and (
             path == ".project/archive/"
             or path == configured
@@ -1745,7 +1771,7 @@ def require_clean_active_root(active_root: Path, archive: Path) -> None:
     archived_audit = archive / "research" / "DOCS-AUDIT.md"
     carried_forward = pending_ruling_count(archived_audit)
     # Persistent project metadata ships but never archives with a milestone.
-    allowed = {"STATE.md", "REPOSITORY.md", "archive", "LESSONS.md", "next"}
+    allowed = {"STATE.md", "REPOSITORY.md", "MEMBERS.md", "archive", "LESSONS.md", "next"}
     for name in ("config.json", "model-policy.json"):
         path = active_root / name
         if path.exists() or path.is_symlink():
@@ -1760,7 +1786,9 @@ def require_clean_active_root(active_root: Path, archive: Path) -> None:
     if carried_forward:
         allowed.add("research")
         active_audit = active_research / "DOCS-AUDIT.md"
-        entries = sorted(path.name for path in active_research.iterdir()) if active_research.is_dir() else []
+        entries = sorted(
+            path.name for path in active_research.iterdir() if not _common.is_ignored_junk(path)
+        ) if active_research.is_dir() else []
         if (
             active_research.is_symlink()
             or entries != ["DOCS-AUDIT.md"]
@@ -1772,7 +1800,12 @@ def require_clean_active_root(active_root: Path, archive: Path) -> None:
     elif active_research.exists() or active_research.is_symlink():
         raise ArchiveError("active research exists without a pending carry-forward queue")
 
-    unexpected = sorted(path.name for path in active_root.iterdir() if path.name not in allowed)
+    # Ignored, untracked non-pipeline entries (.DS_Store) never ship; pipeline entries block even when ignored.
+    visible = _common.git_visible_entries(active_root)
+    unexpected = sorted(
+        path.name for path in active_root.iterdir()
+        if path.name not in allowed and (path.name in PROJECT_ENTRIES or path.name in visible)
+    )
     if unexpected:
         raise ArchiveError(f"unexpected active .project paths remain: {', '.join(unexpected)}")
 
@@ -1848,6 +1881,12 @@ def prepared_transaction(
 
 
 def preflight(repo: Path) -> dict:
+    project = repo.resolve()
+    active_root = require_project_layout(project)
+    configured = strict_state(project)[0].archive
+    current = (archive_from_state(project, configured)
+               if configured and not archive_is_committed(project, configured) else None)
+    prune_host_scratch(active_root, current)
     project, _, state, configured, archive, _, reviewed_head = prepared_transaction(
         repo,
         ("ship", "shipped"),
@@ -1937,6 +1976,28 @@ def validate_shipped_roadmap(text: str, state: PipelineState, archive: str) -> N
         raise ArchiveError("ROADMAP.md must record Status: shipped and the exact Archive")
 
 
+def member_ship_rows(project: Path, archive: Path, ship_commit: str) -> list:
+    """Ship body member lines, bound to the archived lock order and FINAL.md member heads."""
+    if __package__:
+        from . import check_handoffs
+        from .pipeline_git import ship_member_rows
+    else:
+        import check_handoffs
+        from pipeline_git import ship_member_rows
+    message = require_git_success(run_git(project, "show", "-s", "--format=%B", ship_commit), "inspect ship body")
+    rows = ship_member_rows(message)
+    lock = archive / "build" / "members.json"
+    locked = [entry["name"] for entry in json.loads(lock.read_text(encoding="utf-8"))["members"]] if lock.is_file() else []
+    try:
+        heads = check_handoffs.member_reviewed_heads((archive / "review" / "FINAL.md").read_text(encoding="utf-8"),
+                                                     "FINAL.md")
+    except check_handoffs.HandoffError as error:
+        raise ArchiveError(str(error)) from error
+    if [row["name"] for row in rows] != locked or {row["name"]: row["reviewed_head"] for row in rows} != heads:
+        raise ArchiveError("ship commit member lines must name each locked member at its FINAL.md reviewed HEAD")
+    return rows
+
+
 def validate(repo: Path, *, historical: bool = False) -> dict:
     project, _, state, configured, archive, archived_files, reviewed_head = prepared_transaction(
         repo,
@@ -2030,6 +2091,7 @@ def validate(repo: Path, *, historical: bool = False) -> dict:
         )
     require_committed_carry_forward(project, configured, archive, ship_commit)
 
+    members = member_ship_rows(project, archive, ship_commit)
     ship_parent = require_git_success(run_git(project, "rev-parse", f"{ship_commit}^"), "resolve ship parent")
     if reviewed_head != ship_parent:
         raise ArchiveError(
@@ -2039,7 +2101,7 @@ def validate(repo: Path, *, historical: bool = False) -> dict:
         project,
         ship_commit,
         ship_subject(archive.name),
-        ship_commit_body(configured, reviewed_head),
+        ship_commit_body(configured, reviewed_head, members),
         "ship",
     )
 
@@ -2077,7 +2139,10 @@ def validate(repo: Path, *, historical: bool = False) -> dict:
             + f"; run: git -C {project} revert <commits after {ship_commit[:12]} that touch .project>"
         )
 
-    return {"archive": configured, "commit": ship_commit}
+    result = {"archive": configured, "commit": ship_commit}
+    if members:
+        result["members"] = members
+    return result
 
 
 def parser() -> argparse.ArgumentParser:
@@ -2119,6 +2184,12 @@ def parser() -> argparse.ArgumentParser:
     )
     refresh_parser.add_argument("--repo", required=True, type=Path)
 
+    close_members_parser = subparsers.add_parser(
+        "close-members",
+        help="after preflight, integrate each locked member in lock order before the ship commit",
+    )
+    close_members_parser.add_argument("--repo", required=True, type=Path)
+
     integrate_parser = subparsers.add_parser(
         "integrate",
         help="resume and publish the shipped milestone integration",
@@ -2139,7 +2210,7 @@ def parser() -> argparse.ArgumentParser:
 def main(argv: Optional[Sequence[str]] = None) -> int:
     arguments = parser().parse_args(argv)
     try:
-        if arguments.command in {"validate-integrated", "refresh-origin", "integrate"}:
+        if arguments.command in {"validate-integrated", "refresh-origin", "integrate", "close-members"}:
             if __package__:
                 from . import integration
             else:
@@ -2156,6 +2227,8 @@ def main(argv: Optional[Sequence[str]] = None) -> int:
             result = integration.validate_integrated(arguments.repo, arguments.slug)
         elif arguments.command == "refresh-origin":
             result = integration.refresh_origin(arguments.repo)
+        elif arguments.command == "close-members":
+            result = integration.close_members(arguments.repo)
         elif arguments.command == "integrate":
             result = integration.integrate(arguments.repo, arguments.slug)
         else:

package/skills/gsd-path-roadmap/scripts/build_recovery.py

@@ -90,6 +90,8 @@ def settled_tasks(repo: Path) -> dict[str, tuple[str, dict]]:
         raise state.PipelineStateError("build recovery requires real task artifacts")
     tasks = {}
     for path in sorted(directory.iterdir()):
+        if state._common.is_ignored_junk(path):
+            continue
         if not re.fullmatch(r"T[0-9]{3}-[a-z0-9][a-z0-9-]*\.md", path.name):
             raise state.PipelineStateError(f"invalid recovery task path: {path.name}")
         text = state._read_real_file(path, path.name)
@@ -165,7 +167,8 @@ def validate_review_backup(repo: Path, recovery: dict, directory: Path) -> None:
         if path:
             expected[str(Path(path).relative_to(".project/review"))] = checkpoint_runtime()._git_text_at(repo, recovery["base"], path)
     actual = {str(path.relative_to(directory)): path.read_text(encoding="utf-8")
-              for path in directory.rglob("*") if path.is_file()} if directory.exists() else {}
+              for path in directory.rglob("*")
+              if path.is_file() and not state._common.is_ignored_junk(path)} if directory.exists() else {}
     if actual != expected:
         raise state.PipelineStateError("review backup differs from the recovery base")
 

package/skills/gsd-path-roadmap/scripts/check_handoffs.py

@@ -13,12 +13,16 @@ sys.dont_write_bytecode = True
 from pathlib import Path, PurePosixPath
 from typing import Dict, List, Optional, Sequence, Set, Tuple
 
-try:
-    from pipeline_state import PipelineStateError, load_state
-    import _common
-except ImportError:  # pragma: no cover - package imports used by tests
-    from scripts.pipeline_state import PipelineStateError, load_state
-    from scripts import _common
+if __package__:
+    from .pipeline_state import PipelineStateError, load_state
+    from . import _common
+else:
+    try:
+        from pipeline_state import PipelineStateError, load_state
+        import _common
+    except ImportError:  # pragma: no cover - package imports used by tests
+        from scripts.pipeline_state import PipelineStateError, load_state
+        from scripts import _common
 
 
 PIPELINE = "gsd-path/v2"
@@ -377,7 +381,10 @@ def validate_research(
 ) -> Dict[str, object]:
     """Validate the research-to-synthesis hand-off and return its summary."""
 
-    _require_state(root, "research", "active", project_dir)
+    # Research runs this before closing; decide runs it after its entry transition.
+    _require_state_one_of(
+        root, {("research", "active"), ("decide", "active")}, project_dir
+    )
     return validate_research_artifacts(root, project_dir)
 
 
@@ -548,6 +555,45 @@ def _reviewed_head(text: str, source: str) -> str:
     return value
 
 
+MEMBER_HEAD_PATTERN = re.compile(r"(?m)^Member reviewed HEAD:(.*)$")
+
+
+def member_reviewed_heads(text: str, source: str) -> Dict[str, str]:
+    """`Member reviewed HEAD: <member> <sha>` lines, one per member of a multi-repo milestone."""
+    heads: Dict[str, str] = {}
+    # Only the header binds heads; command output quoted in later sections cannot add one.
+    for value in MEMBER_HEAD_PATTERN.findall(_strip_comments(text).split("\n## ", 1)[0]):
+        name, _, sha = value.strip().partition(" ")
+        if not name or not SHA_PATTERN.fullmatch(sha.strip()):
+            raise HandoffError(
+                f"{source} Member reviewed HEAD must be '<member> <full commit SHA>', not {value.strip() or 'empty'}"
+            )
+        if name in heads:
+            raise HandoffError(f"{source} repeats Member reviewed HEAD for {name}")
+        heads[name] = sha.strip()
+    return heads
+
+
+def _member_tips(root: Path) -> Dict[str, str]:
+    """Each locked member's bound branch tip; empty when the milestone locks no member."""
+    try:
+        import isolation
+    except ImportError:  # pragma: no cover - package import used by tests
+        from scripts import isolation
+    lock = root / ".project/build/members.json"
+    if not lock.is_file():
+        return {}
+    tips: Dict[str, str] = {}
+    try:
+        for item in json.loads(lock.read_text(encoding="utf-8"))["members"]:
+            checkout, _, entry = isolation._member_context(root, item["name"])
+            tips[entry["name"]] = isolation.git_output(
+                checkout, "rev-parse", "--verify", f"refs/heads/{entry['branch']}^{{commit}}")
+    except isolation.IsolationError as error:
+        raise HandoffError(str(error)) from error
+    return tips
+
+
 def _strip_comments(text: str) -> str:
     return COMMENT_PATTERN.sub("", text)
 
@@ -750,6 +796,8 @@ def _task_texts(root: Path, project_dir: str) -> Dict[str, str]:
         raise HandoffError(f"missing {project_dir}/tasks")
     tasks: Dict[str, str] = {}
     for path in sorted(tasks_dir.iterdir()):
+        if _common.is_ignored_junk(path):
+            continue
         named = TASK_FILE_NAME.fullmatch(path.name)
         if named is None or not path.is_file() or path.is_symlink():
             raise HandoffError(f"non-canonical task artifact: {path.name}")
@@ -1008,7 +1056,10 @@ def _validate_task_graph(
     graph: Dict[str, List[str]] = {}
     task_waves: Dict[str, int] = {}
     task_files: Dict[str, List[str]] = {}
+    # `repo:` names the member a task changes; absent means the coordinator.
+    task_repos: Dict[str, str] = {}
     for task_id, text in tasks.items():
+        task_repos[task_id] = str(_strict_frontmatter(text, task_id).get("repo") or "")
         # Patch mode reopens planning beside landed tasks; only new tasks start clean.
         landed = _task_scalar(text, task_id, "status") == "done"
         _require_task_structure(task_id, text, initial=initial and not landed)
@@ -1028,7 +1079,7 @@ def _validate_task_graph(
 
     for index, left in enumerate(task_ids):
         for right in task_ids[index + 1 :]:
-            if task_waves[left] != task_waves[right]:
+            if task_waves[left] != task_waves[right] or task_repos[left] != task_repos[right]:
                 continue
             overlap = sorted(set(task_files[left]) & set(task_files[right]))
             if overlap:
@@ -1039,6 +1090,7 @@ def _validate_task_graph(
     visiting: Set[str] = set()
     visited: Set[str] = set()
     dependency_files: Dict[str, Set[str]] = {}
+    dependency_pairs: Dict[str, Set[Tuple[str, str]]] = {}
 
     def visit(task_id: str) -> None:
         if task_id in visiting:
@@ -1046,11 +1098,15 @@ def _validate_task_graph(
         if task_id in visited:
             return
         visiting.add(task_id)
-        dependency_files[task_id] = set()
+        dependency_pairs[task_id] = set()
         for dependency in graph[task_id]:
             visit(dependency)
-            dependency_files[task_id].update(task_files[dependency])
-            dependency_files[task_id].update(dependency_files[dependency])
+            dependency_pairs[task_id].update((task_repos[dependency], name) for name in task_files[dependency])
+            dependency_pairs[task_id].update(dependency_pairs[dependency])
+        # A dependency's files are supplied only within the same repo.
+        dependency_files[task_id] = {
+            name for repo, name in dependency_pairs[task_id] if repo == task_repos[task_id]
+        }
         visiting.remove(task_id)
         visited.add(task_id)
 
@@ -1212,7 +1268,7 @@ def _head_file(root: Path, relative: str) -> Optional[str]:
         ["git", "show", f"HEAD:{relative}"],
         cwd=root,
         capture_output=True,
-        text=True,
+        encoding="utf-8", errors="replace",
         check=False,
     )
     return result.stdout if result.returncode == 0 else None
@@ -1313,6 +1369,21 @@ def validate_roadmap(
     return {"phase": "roadmap", "milestones": ids, "dependencies": dependencies}
 
 
+def _integrated_members(root: Path, state: Dict[str, str]) -> Set[str]:
+    """Members this milestone already closed; a new task for one would need a second merge."""
+    match = re.fullmatch(r"gsd-path/M(\d{3,})", state.get("branch") or "")
+    common = subprocess.run(["git", "-C", str(root), "rev-parse", "--path-format=absolute", "--git-common-dir"],
+                            capture_output=True, text=True, check=False)
+    if match is None or common.returncode != 0:
+        return set()
+    if __package__:
+        from . import members
+    else:
+        import members
+    rows = members.milestone_member_close(Path(common.stdout.strip()), int(match.group(1)))
+    return {row["name"] for row in rows if row.get("status") == "integrated"}
+
+
 def validate_plan(
     root: Path, project_dir: str = DEFAULT_PROJECT_DIR
 ) -> Dict[str, object]:
@@ -1332,6 +1403,14 @@ def validate_plan(
     # Build readiness owns task lifecycle validation; coverage must survive landings.
     state = _require_pipeline(root, project_dir)
     _validate_task_graph(wave_depths, tasks, initial=state["phase"] == "plan")
+    integrated = _integrated_members(root, state)
+    for task_id, text in tasks.items():
+        repo = str(_strict_frontmatter(text, task_id).get("repo") or "")
+        if repo in integrated and _task_scalar(text, task_id, "status") != "done":
+            raise HandoffError(
+                f"{task_id} changes member {repo}, which is already integrated in this milestone; "
+                "plan that change in a new milestone"
+            )
     assigned: Dict[str, Set[str]] = {task_id: set() for task_id in tasks}
     covered = set()
     for criterion, task_id, acceptance in rows:
@@ -1591,6 +1670,19 @@ def validate_wave_evidence(
     }
 
 
+def criterion_surfaces(root: Path, project_dir: str = DEFAULT_PROJECT_DIR) -> Dict[str, str]:
+    """Map each surface-owned INTENT SC to the surface PLAN.md's contract lists it under."""
+
+    surface_of: Dict[str, str] = {}
+    surfaces = _surfaces(_read(root, _intent_path(project_dir)), "INTENT.md")
+    if surfaces:
+        plan = _read(root, f"{project_dir}/plan/PLAN.md")
+        for surface, (_task, owned) in _surface_contract(plan, surfaces).items():
+            for criterion in owned:
+                surface_of[criterion] = surface
+    return surface_of
+
+
 def validate_final(
     root: Path, project_dir: str = DEFAULT_PROJECT_DIR, *, final_text: Optional[str] = None
 ) -> Dict[str, object]:
@@ -1599,20 +1691,14 @@ def validate_final(
     _require_state(root, "ship", "active", project_dir)
     intent = _read(root, _intent_path(project_dir))
     criteria = _success_criteria(intent)
-    surface_of: Dict[str, str] = {}
-    surfaces = _surfaces(intent, "INTENT.md")
-    if surfaces:
-        plan = _read(root, f"{project_dir}/plan/PLAN.md")
-        for surface, (_task, owned) in _surface_contract(plan, surfaces).items():
-            for criterion in owned:
-                surface_of[criterion] = surface
+    surface_of = criterion_surfaces(root, project_dir)
     relative = f"{project_dir}/review/FINAL.md"
     text = _read(root, relative) if final_text is None else final_text
     reviewed_head = _reviewed_head(text, relative)
     head_result = subprocess.run(
         ("git", "-C", str(root), "rev-parse", "--verify", "HEAD"),
         capture_output=True,
-        text=True,
+        encoding="utf-8", errors="replace",
         check=False,
     )
     if head_result.returncode != 0:
@@ -1623,6 +1709,14 @@ def validate_final(
             f"FINAL.md Reviewed HEAD {reviewed_head} is not the current HEAD "
             f"{current_head}; re-run the final review on the current commit"
         )
+    member_heads = member_reviewed_heads(text, relative)
+    tips = _member_tips(root)
+    if member_heads != tips:
+        expected = ", ".join(f"{name} {tip}" for name, tip in tips.items()) or "none"
+        raise HandoffError(
+            f"FINAL.md Member reviewed HEAD lines must name each locked member head ({expected}); "
+            "re-run the final review on the current member heads"
+        )
     overall = _line_value(text, "Overall verdict:")
     if overall not in {"pass", "blocked"}:
         raise HandoffError("FINAL.md Overall verdict is invalid")
@@ -1697,6 +1791,8 @@ def validate_final(
             raise HandoffError(f"{gap_relative} heading does not match its file number")
         if _reviewed_head(gap, gap_relative) != reviewed_head:
             raise HandoffError(f"{gap_relative} Reviewed HEAD differs from FINAL.md")
+        if member_reviewed_heads(gap, gap_relative) != member_heads:
+            raise HandoffError(f"{gap_relative} Member reviewed HEAD lines differ from FINAL.md")
         verdict = _line_value(gap, "Gap verdict:")
         if verdict not in {"pass", "blocked"}:
             raise HandoffError(f"{gap_relative} Gap verdict is invalid")