@opengsd/gsd-path 1.3.1 → 1.5.0

package/skills/gsd-path-forensics/scripts/discussion_records.py

@@ -16,14 +16,20 @@ from pathlib import Path
 from typing import Iterator, Optional, Sequence
 
 def _load_pipeline_modules():
-    try:
-        import archive_milestone
-        import pipeline_state
-        import _common
+    if __package__:
+        from . import archive_milestone
+        from . import pipeline_state
+        from . import _common
         return _common, archive_milestone, pipeline_state
-    except ModuleNotFoundError as error:
-        if error.name not in {"archive_milestone", "pipeline_state", "_common"}:
-            raise
+    else:
+        try:
+            import archive_milestone
+            import pipeline_state
+            import _common
+            return _common, archive_milestone, pipeline_state
+        except ModuleNotFoundError as error:
+            if error.name not in {"archive_milestone", "pipeline_state", "_common"}:
+                raise
     try:
         from scripts import archive_milestone, pipeline_state, _common
         return _common, archive_milestone, pipeline_state
@@ -111,7 +117,7 @@ def record_count(directory: Path) -> int:
 def validate_or_empty(directory: Path) -> None:
     if directory.is_symlink() or not directory.is_dir():
         raise DiscussionError("discussion records must be a real directory")
-    if sorted(path.name for path in directory.iterdir()) != sorted(FILES):
+    if sorted(path.name for path in directory.iterdir() if not _common.is_ignored_junk(path)) != sorted(FILES):
         raise DiscussionError("discussion directory must contain exactly DIALOGUE.md and ANSWERS.md")
     if record_count(directory) == 0:
         if "### D" in (directory / "DIALOGUE.md").read_text(encoding="utf-8"):
@@ -170,7 +176,7 @@ def validate_contents(project: Path, files: dict) -> None:
     staging.mkdir()
     try:
         for name in FILES:
-            (staging / name).write_text(files[name], encoding="utf-8")
+            (staging / name).write_bytes(files[name].encode("utf-8"))
         validate_or_empty(staging)
     finally:
         shutil.rmtree(staging)
@@ -187,11 +193,11 @@ def initialize_records(discussion: Path, dialogue_template: Path, answers_templa
         shutil.rmtree(staging)
     staging.mkdir()
     try:
-        (staging / "DIALOGUE.md").write_text(
-            template_header(dialogue_template, "### D001"), encoding="utf-8"
+        (staging / "DIALOGUE.md").write_bytes(
+            template_header(dialogue_template, "### D001").encode("utf-8")
         )
-        (staging / "ANSWERS.md").write_text(
-            template_header(answers_template, "## Answer A001"), encoding="utf-8"
+        (staging / "ANSWERS.md").write_bytes(
+            template_header(answers_template, "## Answer A001").encode("utf-8")
         )
         os.replace(staging, discussion)
     finally:

package/skills/gsd-path-forensics/scripts/loop_run.py

@@ -32,10 +32,10 @@ from datetime import datetime, timedelta, timezone
 from pathlib import Path
 from typing import Iterator, Optional, Sequence
 
-if sys.platform == "win32":
-    import msvcrt
-else:
-    import fcntl
+try:
+    from . import _common
+except ImportError:
+    import _common
 
 
 class LoopError(RuntimeError):
@@ -119,25 +119,8 @@ def log_path(fields: dict) -> Path:
 def log_lock(fields: dict) -> Iterator[None]:
     path = log_path(fields)
     path.parent.mkdir(parents=True, exist_ok=True)
-    lock_path = path.with_name(f".{path.name}.lock")
-    with lock_path.open("a+b") as handle:
-        if sys.platform == "win32":
-            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)
-        else:
-            fcntl.flock(handle.fileno(), fcntl.LOCK_EX)
-        try:
-            yield
-        finally:
-            if sys.platform == "win32":
-                handle.seek(0)
-                msvcrt.locking(handle.fileno(), msvcrt.LK_UNLCK, 1)
-            else:
-                fcntl.flock(handle.fileno(), fcntl.LOCK_UN)
+    with _common.exclusive_lock(path.with_name(f".{path.name}.lock")):
+        yield
 
 
 def load_log(fields: dict) -> list[dict]:
@@ -528,15 +511,34 @@ def command_claim(fields: dict) -> dict:
 
 
 def run_shell(command: str, timeout: float) -> tuple[Optional[int], str]:
-    """Run one spec command; a hung command counts as failed (exit None)."""
+    """Run one spec command; a hung command counts as failed (exit None).
+
+    POSIX runs /bin/sh as shell=True did; Windows runs Git for Windows bash, not
+    cmd.exe. A timeout kills the whole process group when possible; if output
+    pipes stay open, drain them with a short grace timeout and then close them.
+    """
+    argv = _common.bash_argv(command) if os.name == "nt" else ["/bin/sh", "-c", command]
+    process = _common.popen_group(argv, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+    stdout = b""
+    stderr = b""
     try:
-        completed = subprocess.run(
-            command, shell=True, capture_output=True, text=True, check=False, timeout=timeout
-        )
+        stdout, stderr = process.communicate(timeout=timeout)
     except subprocess.TimeoutExpired as expired:
-        output = (expired.stdout or b"").decode(errors="replace") + (expired.stderr or b"").decode(errors="replace")
+        _common.kill_tree(process)
+        try:
+            stdout, stderr = process.communicate(timeout=5)
+        except subprocess.TimeoutExpired as drained:
+            stdout = drained.stdout or expired.stdout or b""
+            stderr = drained.stderr or expired.stderr or b""
+            if process.stdout:
+                process.stdout.close()
+            if process.stderr:
+                process.stderr.close()
+            process.kill()
+            process.wait(timeout=5)
+        output = stdout.decode("utf-8", errors="replace") + stderr.decode("utf-8", errors="replace")
         return None, f"{output}\ntimed out at the admitted wall-clock deadline"
-    return completed.returncode, completed.stdout + completed.stderr
+    return process.returncode, (stdout + stderr).decode("utf-8", errors="replace")
 
 
 def command_verify(fields: dict, claim_identifier: Optional[str]) -> dict:

package/skills/gsd-path-forensics/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/skills/gsd-path-forensics/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)