@opengsd/gsd-path 1.3.1 → 1.5.0

package/scripts/migrate_core.py

@@ -119,8 +119,8 @@ def prepare(repo, output, files, manifest):
             target.parent.mkdir(parents=True, exist_ok=True)
             target.write_bytes(content)
         manifest = dict(manifest, status="prepared", output=str(output))
-        (output / "manifest.json").write_text(
-            json.dumps(manifest, indent=2) + "\n", encoding="utf-8"
+        (output / "manifest.json").write_bytes(
+            (json.dumps(manifest, indent=2) + "\n").encode("utf-8")
         )
     except BaseException:
         shutil.rmtree(output)

package/scripts/path_config.py

@@ -13,7 +13,7 @@ sys.dont_write_bytecode = True
 ROLES = ('coder', 'reviewer', 'review_panel', 'skeptic', 'inspect_codebase',
          'inspect_docs', 'docs_audit', 'research', 'decide', 'roadmap', 'plan', 'plan_patch')
 HOSTS = ('codex', 'claude', 'grok', 'opencode', 'copilot', 'qwen', 'antigravity',
-         'cursor', 'zed', 'kiro', 'kimi')
+         'cursor', 'zed', 'kiro', 'kimi', 'muse')
 
 
 def sibling(name):
@@ -73,8 +73,8 @@ def validate_value(key, value):
     if not isinstance(value, str) or not value or value != value.strip():
         raise ValueError(f'{key} requires a nonempty string')
     if key == 'integration':
-        if value not in ('direct', 'pull-request'):
-            raise ValueError('integration must be direct or pull-request')
+        if value not in ('direct', 'pull-request', 'external-landing'):
+            raise ValueError('integration must be direct, pull-request, or external-landing')
     elif key == 'review_panel':
         if any(char.isspace() for char in value):
             raise ValueError('use off, detected, or comma-separated families without spaces')
@@ -174,13 +174,13 @@ def set_value(repo, scope, key, value, reset=False):
     if scope == 'project':
         state, _, _ = sibling('pipeline_state').load_state(repo)
         branch = subprocess.run(['git', '-C', str(repo), 'branch', '--show-current'],
-                                capture_output=True, text=True)
+                                capture_output=True, encoding="utf-8", errors="replace")
         if branch.returncode or not state.branch or branch.stdout.strip() != state.branch:
             raise ValueError('Run the router to bind the project branch before editing settings.')
         head = subprocess.run(['git', '-C', str(repo), 'rev-parse', '--verify', 'HEAD'], capture_output=True)
         if head.returncode == 0:
             closed = subprocess.run([sys.executable, '-B', str(Path(__file__).with_name('git_guard.py')),
-                                     'closed-milestone'], cwd=repo, capture_output=True, text=True)
+                                     'closed-milestone'], cwd=repo, capture_output=True, encoding="utf-8", errors="replace")
             if closed.returncode:
                 raise ValueError(closed.stderr.strip() or 'Cannot verify the milestone branch is open.')
     if scope == 'project' and key == 'integration':

package/scripts/pipeline_diagnose.py

@@ -10,6 +10,7 @@ from __future__ import annotations
 
 import argparse
 import json
+import os
 import shlex
 import sys
 
@@ -20,14 +21,14 @@ from typing import Callable, Optional, Sequence
 
 
 def _load_diagnose_modules():
-    try:
-        import archive_milestone
-        import detect_project
-        import discussion_records
-        import integration
-        import isolation
-        import pipeline_git
-        import pipeline_state
+    if __package__:
+        from . import archive_milestone
+        from . import detect_project
+        from . import discussion_records
+        from . import integration
+        from . import isolation
+        from . import pipeline_git
+        from . import pipeline_state
         return (
             archive_milestone,
             detect_project,
@@ -37,17 +38,35 @@ def _load_diagnose_modules():
             pipeline_git,
             pipeline_state,
         )
-    except ModuleNotFoundError as error:
-        if error.name not in {
-            "archive_milestone",
-            "detect_project",
-            "discussion_records",
-            "integration",
-            "isolation",
-            "pipeline_git",
-            "pipeline_state",
-        }:
-            raise
+    else:
+        try:
+            import archive_milestone
+            import detect_project
+            import discussion_records
+            import integration
+            import isolation
+            import pipeline_git
+            import pipeline_state
+            return (
+                archive_milestone,
+                detect_project,
+                discussion_records,
+                integration,
+                isolation,
+                pipeline_git,
+                pipeline_state,
+            )
+        except ModuleNotFoundError as error:
+            if error.name not in {
+                "archive_milestone",
+                "detect_project",
+                "discussion_records",
+                "integration",
+                "isolation",
+                "pipeline_git",
+                "pipeline_state",
+            }:
+                raise
     try:
         from scripts import (
             archive_milestone,
@@ -116,21 +135,25 @@ _worktree_report = isolation._worktree_report
 PipelineStateError = pipeline_state.PipelineStateError
 status_state = pipeline_state.status_state
 validate_state = pipeline_state.validate_state
+_run_git = pipeline_state._run_git
 
-try:
-    import pipeline_undo
-except ModuleNotFoundError as error:
-    if error.name != "pipeline_undo":
-        raise
+if __package__:
+    from . import pipeline_undo
+else:
     try:
-        from scripts import pipeline_undo
+        import pipeline_undo
     except ModuleNotFoundError as error:
-        if error.name not in {"scripts", "scripts.pipeline_undo"}:
+        if error.name != "pipeline_undo":
             raise
-        shared = Path(__file__).resolve().parents[2] / "gsd-path" / "scripts"
-        if str(shared) not in sys.path:
-            sys.path.insert(0, str(shared))
-        import pipeline_undo
+        try:
+            from scripts import pipeline_undo
+        except ModuleNotFoundError as error:
+            if error.name not in {"scripts", "scripts.pipeline_undo"}:
+                raise
+            shared = Path(__file__).resolve().parents[2] / "gsd-path" / "scripts"
+            if str(shared) not in sys.path:
+                sys.path.insert(0, str(shared))
+            import pipeline_undo
 
 UndoError = pipeline_undo.UndoError
 undo_preview = pipeline_undo.preview
@@ -194,7 +217,12 @@ def _state_template() -> Path:
 
 def _command(module: object, *arguments: object) -> str:
     script = Path(str(getattr(module, "__file__"))).resolve()
-    return shlex.join([sys.executable, str(script), *map(str, arguments)])
+    def text(value: object) -> str:
+        # Agents paste this into Git Bash on Windows, where unquoted
+        # backslashes are escapes; forward slashes need no quoting.
+        return value.as_posix() if isinstance(value, Path) and os.name == "nt" else str(value)
+
+    return shlex.join([text(Path(sys.executable)), text(script), *map(text, arguments)])
 
 
 def _route_retry(
@@ -391,6 +419,29 @@ def diagnose(repo: Path) -> dict[str, object]:
             for key, path in (status.get("journals") or {}).items()
             if path
         }
+        pending_members = [row["name"] for row in status.get("members") or [] if row["close"] == "pending"]
+        if pending_members:
+            findings.append(
+                _finding(
+                    "member-close",
+                    "stuck",
+                    "member close is pending for: " + ", ".join(pending_members),
+                    _command(archive_milestone, "close-members", "--repo", resolved),
+                )
+            )
+        common = _run_git(resolved, "rev-parse", "--path-format=absolute", "--git-common-dir", check=False)
+        landings = sorted(
+            (Path(common.stdout.strip()) / "gsd-path" / "member-landings").glob("*.json")
+        ) if common.returncode == 0 else []
+        if landings:
+            findings.append(
+                _finding(
+                    "member-landing",
+                    "stuck",
+                    "member landing journal is pending: " + ", ".join(path.stem for path in landings),
+                    "resume build; the dispatch driver finishes pending member landings before new work",
+                )
+            )
         undo_probe = by_name["undo-preview"]
         undo_result = undo_probe["result"] if undo_probe["ok"] else None
         route_retry = _route_retry(resolved, route, undo_result)

package/scripts/pipeline_git.py

@@ -23,10 +23,13 @@ sys.dont_write_bytecode = True
 from pathlib import Path
 from typing import Optional, Sequence
 
-try:
-    import _common
-except ImportError:  # pragma: no cover - package import used by tests
-    from scripts import _common
+if __package__:
+    from . import _common
+else:
+    try:
+        import _common
+    except ImportError:  # pragma: no cover - package import used by tests
+        from scripts import _common
 
 
 ARCHIVE_NAME_RE = re.compile(r"^(\d{3,})-([a-z0-9][a-z0-9-]*)$")
@@ -123,8 +126,47 @@ def is_integrate_subject(subject: str, archive_name: str, default_branch: str) -
     }
 
 
-def ship_commit_body(archive_path: str, reviewed_head: str) -> str:
-    return f"Archive: {archive_path}\nReviewed-HEAD: {reviewed_head}\n"
+MEMBER_SHIP_ROW = re.compile(
+    r"(?m)^Member-Reviewed-HEAD: (?P<name>[^@\s]+)@(?P<reviewed_head>[0-9a-f]{40})\n"
+    r"Member: (?P=name) (?P<merge>[0-9a-f]{40}) (?P<tag>\S+)$"
+)
+
+
+def ship_member_rows(body: str) -> list:
+    """Closed-member rows named by a ship body; callers compare the rebuilt body exactly."""
+    return [match.groupdict() for match in MEMBER_SHIP_ROW.finditer(body)]
+
+
+def ship_commit_body(archive_path: str, reviewed_head: str, members: Sequence[dict] = ()) -> str:
+    """The ship body; a multi-repo milestone adds each closed member in lock order."""
+    return f"Archive: {archive_path}\nReviewed-HEAD: {reviewed_head}\n" + "".join(
+        f"Member-Reviewed-HEAD: {row['name']}@{row['reviewed_head']}\n"
+        f"Member: {row['name']} {row['merge']} {row['tag']}\n"
+        for row in members
+    )
+
+
+_TRAILER_LINE = re.compile(r"^[A-Za-z-]+:\s")
+
+
+def ship_body_matches(body: str, expected_body: str) -> bool:
+    """True when body equals the contract or adds only optional git trailers after it."""
+    normalized = body.rstrip("\n")
+    expected = expected_body.rstrip("\n")
+    if normalized == expected:
+        return True
+    prefix = expected + "\n"
+    if not normalized.startswith(prefix):
+        return False
+    remainder = normalized[len(prefix):]
+    if not remainder:
+        return True
+    for line in remainder.splitlines():
+        if not line.strip():
+            return False
+        if not _TRAILER_LINE.match(line):
+            return False
+    return True
 
 
 def integrate_commit_body(
@@ -200,7 +242,7 @@ def _run_git(
     result = subprocess.run(
         ["git", "-C", str(repo), *args],
         capture_output=True,
-        text=True,
+        encoding="utf-8", errors="replace",
     )
     if check and result.returncode != 0:
         detail = result.stderr.strip() or result.stdout.strip()
@@ -251,22 +293,50 @@ def _symbolic_branch(repo: Path) -> str:
     return result.stdout.strip()
 
 
-def _branch_worktrees(repo: Path) -> dict[str, Path]:
-    """Return every checked-out local branch from Git's worktree registry."""
-    output = _run_git(repo, "worktree", "list", "--porcelain", "-z").stdout
+def worktree_list_porcelain(repo: Path) -> tuple[str, bool]:
+    """Return worktree list output and whether it is NUL-separated."""
+    result = _run_git(repo, "worktree", "list", "--porcelain", "-z", check=False)
+    if result.returncode == 0:
+        return result.stdout, True
+    result = _run_git(repo, "worktree", "list", "--porcelain", check=False)
+    if result.returncode != 0:
+        message = (result.stderr or result.stdout).strip() or "could not list worktrees"
+        raise PipelineGitError(message)
+    return result.stdout, False
+
+
+def branch_worktrees_from_porcelain(output: str, *, nul_separated: bool) -> dict[str, Path]:
     worktrees: dict[str, Path] = {}
-    current_path: Optional[Path] = None
-    for field in output.split("\0"):
-        if field.startswith("worktree "):
-            current_path = Path(field.removeprefix("worktree ")).resolve()
-        elif field.startswith("branch ") and current_path is not None:
-            ref = field.removeprefix("branch ")
-            prefix = "refs/heads/"
-            if ref.startswith(prefix):
-                worktrees[ref.removeprefix(prefix)] = current_path
+    if nul_separated:
+        current_path: Optional[Path] = None
+        for field in output.split("\0"):
+            if not field:
+                continue
+            if field.startswith("worktree "):
+                current_path = Path(field.removeprefix("worktree ")).resolve()
+            elif field.startswith("branch ") and current_path is not None:
+                ref = field.removeprefix("branch ")
+                prefix = "refs/heads/"
+                if ref.startswith(prefix):
+                    worktrees[ref.removeprefix(prefix)] = current_path
+        return worktrees
+    for block in output.strip().split("\n\n"):
+        fields = block.splitlines()
+        if not fields or not fields[0].startswith("worktree "):
+            continue
+        current_path = Path(fields[0].removeprefix("worktree ")).resolve()
+        for line in fields[1:]:
+            if line.startswith("branch refs/heads/"):
+                worktrees[line.removeprefix("branch refs/heads/")] = current_path
     return worktrees
 
 
+def _branch_worktrees(repo: Path) -> dict[str, Path]:
+    """Return every checked-out local branch from Git's worktree registry."""
+    output, nul_separated = worktree_list_porcelain(repo)
+    return branch_worktrees_from_porcelain(output, nul_separated=nul_separated)
+
+
 def _remote_ref_sha(repo: Path, ref: str) -> Optional[str]:
     if not _origin_remote_exists(repo):
         raise PipelineGitError("origin remote is not configured")
@@ -319,7 +389,7 @@ def _validated_shipped_state(repo: Path) -> dict[str, object]:
             str(repo),
         ],
         capture_output=True,
-        text=True,
+        encoding="utf-8", errors="replace",
     )
     if result.returncode != 0:
         detail = result.stderr.strip() or result.stdout.strip()
@@ -446,19 +516,16 @@ def _write_bind_next_journal(path: Path, value: dict[str, object]) -> None:
         raise PipelineGitError(f"bind-next journal temporary path exists: {temporary}")
     descriptor: Optional[int] = None
     try:
-        descriptor = os.open(temporary, os.O_WRONLY | os.O_CREAT | os.O_EXCL, 0o600)
-        with os.fdopen(descriptor, "w", encoding="utf-8") as handle:
+        descriptor = os.open(
+            temporary, os.O_WRONLY | os.O_CREAT | os.O_EXCL | _common.O_BINARY, 0o600
+        )
+        with os.fdopen(descriptor, "wb") as handle:
             descriptor = None
-            json.dump(value, handle, indent=2, sort_keys=True)
-            handle.write("\n")
+            handle.write((json.dumps(value, indent=2, sort_keys=True) + "\n").encode("utf-8"))
             handle.flush()
             os.fsync(handle.fileno())
-        os.replace(temporary, path)
-        directory = os.open(path.parent, os.O_RDONLY)
-        try:
-            os.fsync(directory)
-        finally:
-            os.close(directory)
+        _common.replace(temporary, path)
+        _common.fsync_directory(path.parent)
     finally:
         if descriptor is not None:
             os.close(descriptor)
@@ -473,10 +540,13 @@ def _initial_binding_snapshot(repo: Path) -> Optional[tuple]:
         return None
     if dirty != "?? .project/STATE.md\0":
         raise PipelineGitError("primary worktree is not clean")
-    try:
-        import pipeline_state
-    except ImportError:  # pragma: no cover - package import used by tests
-        from scripts import pipeline_state
+    if __package__:
+        from . import pipeline_state
+    else:
+        try:
+            import pipeline_state
+        except ImportError:  # pragma: no cover - package import used by tests
+            from scripts import pipeline_state
 
     project = repo / ".project"
     path = project / "STATE.md"
@@ -635,6 +705,25 @@ def retire_previous_branch(
         _run_git(repo, "branch", "-d", previous_branch)
 
 
+def _retire_members(repo: Path, ship_sha: str) -> None:
+    """Retire each member the ship commit names; each step is idempotent for a resumed bind-next."""
+    message = _run_git(repo, "show", "-s", "--format=%B", ship_sha).stdout
+    rows = ship_member_rows(message)
+    if not rows:
+        return
+    if __package__:
+        from . import integration
+    else:
+        import integration
+    archive = re.search(r"(?m)^Archive: (\S+)$", message)
+    try:
+        for row in rows:
+            integration.retire_member(repo, row["name"], archive.group(1), row["reviewed_head"],
+                                      row["merge"], row["tag"])
+    except integration.ArchiveError as error:
+        raise PipelineGitError(f"member retirement failed: {error}") from error
+
+
 def bind_next_milestone_branch(
     repo: Path,
     branch: str,
@@ -868,6 +957,7 @@ def bind_next_milestone_branch(
             allow_remote_absent or journal["stage"] in {"switched", "retired"}
         ),
     )
+    _retire_members(repo, ship_sha)
     journal["stage"] = "retired"
     _write_bind_next_journal(journal_path, journal)
     return {