@opengsd/gsd-path 1.3.1 → 1.4.0

package/scripts/dispatch_driver.py

@@ -19,8 +19,6 @@ import hashlib
 import json
 import os
 import re
-import shlex
-import signal
 import subprocess
 import sys
 import tempfile
@@ -170,12 +168,7 @@ def child_running(state: Dict[str, object]) -> bool:
     return state.get("finished_at") is None and bool(state.get("pid")) and process_alive(int(state["pid"]))
 
 
-def process_alive(pid: int) -> bool:
-    try:
-        os.kill(pid, 0)
-    except ProcessLookupError:
-        return False
-    return True
+process_alive = _common.process_alive
 
 
 # --- child process ---------------------------------------------------------
@@ -208,13 +201,13 @@ def child_main(state_path: Path) -> int:
     attempt_dir = state_path.parent
     with open(attempt_dir / "brief.md", "rb") as brief, \
             open(attempt_dir / "stdout", "wb") as out, open(attempt_dir / "stderr", "wb") as err:
-        process = subprocess.Popen(state["command"], cwd=state["worktree"], stdin=brief,
-                                   stdout=out, stderr=err, start_new_session=True)
+        process = _common.popen_group(_common.resolve_argv(state["command"]), cwd=state["worktree"],
+                                      stdin=brief, stdout=out, stderr=err)
         try:
             exit_code: Optional[int] = process.wait(timeout=state.get("child_timeout"))
             timed_out = False
         except subprocess.TimeoutExpired:
-            os.killpg(process.pid, signal.SIGKILL)
+            _common.kill_tree(process)
             process.wait()
             exit_code, timed_out = None, True
     save_state(attempt_dir / "exit.json",
@@ -224,6 +217,7 @@ def child_main(state_path: Path) -> int:
 
 def brief_text(state: Dict[str, object], role_brief: Path, task_template: Path) -> str:
     worktree = Path(str(state["worktree"]))
+    project_root = Path(str(state.get("project_root") or worktree))
     task_id = state["task_id"]
     agents = worktree / "AGENTS.md"
     workflow = worktree / "WORKFLOW.md"
@@ -234,12 +228,14 @@ def brief_text(state: Dict[str, object], role_brief: Path, task_template: Path)
         f"Work only in this worktree root: {worktree}",
         f"Task file: {worktree / str(state['task_file'])}",
         f"Task template: {task_template}",
-        f"INTENT.md: {worktree / '.project/intent/INTENT.md'}",
+        f"INTENT.md: {project_root / '.project/intent/INTENT.md'}",
         f"AGENTS.md: {agents if agents.exists() else 'absent'}",
         f"WORKFLOW.md: {workflow if workflow.exists() else 'absent'}",
         f"Recorded base: {state['base']}",
         f"Dispatch mode: {state['mode']} ("
         + ("the primary worktree on the bound branch" if state["mode"] == "serial"
+           else f"an isolated worktree of member {state['member']}; never touch the member team's "
+                "checkout or the coordinator" if state["mode"] == "member"
            else "an isolated task worktree; never touch the primary") + ").",
         "Next consumer: the build orchestrator reruns Verify in an isolated checkout and lands "
         "the task. Gate: Verify passes and only the task's declared files plus its Log changed.",
@@ -248,7 +244,7 @@ def brief_text(state: Dict[str, object], role_brief: Path, task_template: Path)
     if state.get("answered"):
         lines.append(f"The task Log now records an `{ANSWER_MARK}` to your earlier question; "
                      "continue from it.")
-    lines.append(task_context.render(worktree, worktree / str(state['task_file'])))
+    lines.append(task_context.render(project_root, worktree / str(state['task_file'])))
     return "\n".join(lines) + "\n"
 
 
@@ -282,7 +278,7 @@ def selected_command(state: Dict[str, object], options: argparse.Namespace, comm
     if caps_path is None:
         if overrides or previous or model_policy.policy_path(primary, project_dir).exists():
             raise model_policy.PolicyError('model policy requires --model-capabilities for this dispatch')
-        return shlex.split(command), None
+        return _common.split_command(command), None
     caps = model_policy.read_json(caps_path)
     action = getattr(options, 'action', 'round')
     role = {'round': 'coder', 'review': 'reviewer', 'panel': 'review_panel',
@@ -297,7 +293,7 @@ def selected_command(state: Dict[str, object], options: argparse.Namespace, comm
                                               dict(overrides, model=state['slug']), previous)
         model_policy.validate_panel(selection, state['family'], state.get('excluded_families', []))
         state['slug'] = selection['selected']['model']
-    return model_policy.command_args(shlex.split(command), selection), selection
+    return model_policy.command_args(_common.split_command(command), selection), selection
 
 
 def retain_selection(root: Path, state: Dict[str, object]) -> Dict[str, object]:
@@ -340,12 +336,12 @@ def spawn(root: Path, state: Dict[str, object], options: argparse.Namespace,
                   "child_timeout": options.child_timeout, "outcome": None,
                   "dispatched_at": now(), "origin": "question" if state.get("answered") else "dispatch"})
     state_path = attempt_dir / "state.json"
-    (attempt_dir / "brief.md").write_text(brief(state), encoding="utf-8")
+    (attempt_dir / "brief.md").write_bytes(brief(state).encode("utf-8"))
     save_state(state_path, state)
-    wrapper = subprocess.Popen(
+    wrapper = _common.popen_detached(
         [sys.executable, "-B", str(Path(__file__).resolve()), "_child", "--state", str(state_path)],
         cwd=state["worktree"], stdin=subprocess.DEVNULL, stdout=subprocess.DEVNULL,
-        stderr=subprocess.DEVNULL, start_new_session=True,
+        stderr=subprocess.DEVNULL,
     )
     state["_path"] = str(state_path)
     update_state(state, pid=wrapper.pid)
@@ -356,8 +352,11 @@ def spawn(root: Path, state: Dict[str, object], options: argparse.Namespace,
 
 
 def log_delta(primary: Path, state: Dict[str, object]) -> str:
-    base_text = isolation.git_text(primary, "show", f"{state['base']}:{state['task_file']}")
+    contract_file = state.get("contract_file") or state["task_file"]
+    base_text = isolation.git_text(primary, "show", f"{state['base']}:{contract_file}")
     text = (Path(str(state["worktree"])) / str(state["task_file"])).read_text(encoding="utf-8")
+    if state["mode"] == "member":
+        return isolation.member_log_delta(base_text, text)
     return isolation.task_log_delta(base_text, text)
 
 
@@ -374,14 +373,14 @@ def snapshot_tree(primary: Path) -> str:
         env = dict(os.environ, GIT_INDEX_FILE=str(Path(temporary) / "index"))
         for arguments in (("read-tree", "HEAD"), ("add", "-A"), ("write-tree",)):
             completed = subprocess.run(("git", "-C", str(primary), *arguments), env=env,
-                                       text=True, capture_output=True)
+                                       encoding="utf-8", errors="replace", capture_output=True)
             if completed.returncode:
                 raise DriverStop(f"git {' '.join(arguments)} failed: {completed.stderr.strip()}")
         return completed.stdout.strip()
 
 
 def run_verify(command: str, cwd: Path) -> Dict[str, object]:
-    completed = _common.run_command("bash", "-c", command, cwd=cwd)
+    completed = _common.run_command(*_common.bash_argv(command), cwd=cwd)
     return {"exit_code": completed.returncode, "stdout": completed.stdout, "stderr": completed.stderr}
 
 
@@ -394,6 +393,30 @@ def state_from_task(primary: Path, task_id: str) -> Dict[str, object]:
             break
     else:
         raise DriverStop(f"task {task_id} has no task file")
+    member = fields.get("repo")
+    if member:
+        # A member activation lives in the live copy inside its member sidecar.
+        try:
+            checkout, project, _ = isolation._member_context(primary, str(member))
+        except isolation.IsolationError as error:
+            raise DriverStop(str(error), task=task_id) from error
+        task_file = task_path.relative_to(primary).as_posix()
+        sidecar = isolation.sidecar_root(checkout, "task", f"{project}-{task_id}").resolve()
+        copy = isolation.member_task_copy(sidecar, task_file)
+        live, _ = isolation.task_frontmatter(copy.read_text(encoding="utf-8")) if copy.is_file() else ({}, None)
+        if not live or live.get("status") != "in-progress" or not live.get("base") or not live.get("member_base"):
+            raise DriverStop(f"member task {task_id} has no activated live copy in {sidecar}", task=task_id)
+        return {"task_id": task_id, "title": str(live.get("title")), "task_file": copy.relative_to(sidecar).as_posix(),
+                "contract_file": task_file, "files": list(live.get("files") or []), "base": str(live["base"]),
+                "worktree": str(sidecar), "task_branch": f"{isolation.TASK_BRANCH_PREFIX}{project}-{task_id}",
+                "mode": "member", "member": str(member), "member_base": str(live["member_base"]),
+                "project_root": str(primary), "sidecar": None}
+    if fields.get("status") != "in-progress" or not fields.get("base"):
+        # A parallel activation lives only in its isolate; the primary copy stays pending.
+        isolate = isolation.sidecar_root(primary, "task", task_id).resolve()
+        if isolation.authorized_task_worktree(isolate, isolation.require_bound(primary)):
+            fields, _ = isolation.task_frontmatter(
+                (isolate / task_path.relative_to(primary)).read_text(encoding="utf-8"))
     if fields.get("status") != "in-progress" or not fields.get("base"):
         raise DriverStop(f"task {task_id} is not an in-progress task with a recorded base")
     def value(key: str) -> Optional[str]:
@@ -453,7 +476,21 @@ def finish_task(primary: Path, state: Dict[str, object]) -> Dict[str, object]:
     if not passed:
         if state["mode"] == "parallel":
             isolation.deactivate_task(worktree, task_id, str(state["task_branch"]))
+        elif state["mode"] == "member":
+            isolation.deactivate_member_task(primary, str(state["member"]), task_id)
         raise DriverStop("Verify failed in the isolate", task=task_id, execution=execution)
+    if state["mode"] == "member":
+        member = str(state["member"])
+        landed = isolation.land_member(primary, member, task_id, str(state["title"]),
+                                       str(state["contract_file"]), base, str(state["member_base"]))
+        landing = str(landed["landing"])
+        # Only a landing whose parent is the member base proves the verified member tree.
+        ledger = isolation.git_output(worktree, "rev-parse", f"{landing}^") == str(state["member_base"])
+        if ledger:
+            build_state.verify_record(str(primary), command, landing, "pass", execution=execution, member=member)
+        isolation.retire_member_task(primary, member, task_id)
+        return {"task": task_id, "commit": str(landed["commit"]), "mode": "member",
+                "landing": landing, "verify": execution, "ledger": ledger}
     landed = isolation.land(primary, worktree, base, task_id, str(state["title"]), task_file,
                             list(state["files"]))
     commit = str(landed["commit"])
@@ -485,7 +522,8 @@ def recover_report(primary: Path, project_dir: str, receipt: Dict[str, object])
 
 def checkpoint_project(primary: Path, receipt: Dict[str, object], subject: str, body: str) -> Optional[str]:
     """Commit .project bookkeeping through the canonical checkpoint; None when nothing is dirty."""
-    if not any(path.startswith(".project/") for path in isolation.uncommitted_paths(primary)):
+    if not any(path.startswith(".project/") for path in isolation.uncommitted_paths(primary)) \
+            and not isolation.ignored_legacy_ledger(primary):
         return None
     result = isolation.checkpoint(primary, isolation.current_sha(primary), subject, body, [".project"])
     receipt["steps"].append({"script": "isolation.py checkpoint", "result": result})
@@ -582,7 +620,7 @@ class Round:
         """Run the bundled token_budget.py against this milestone's ledger; blocked is a stop."""
         command = [sys.executable, "-B", str(Path(__file__).resolve().parent / "token_budget.py"),
                    action, "--ledger", str(budget_ledger(self.primary)), *arguments]
-        completed = subprocess.run(command, cwd=self.primary, capture_output=True, text=True)
+        completed = subprocess.run(command, cwd=self.primary, capture_output=True, encoding="utf-8", errors="replace")
         result = json.loads(completed.stdout) if completed.stdout.strip() else {}
         self.receipt["steps"].append({"script": f"token_budget.py {action}", "command": command,
                                       "exit_code": completed.returncode, "result": result,
@@ -605,12 +643,24 @@ class Round:
     # recovery -------------------------------------------------------------
 
     def recover(self) -> None:
+        # A journaled member landing is safe to finish; it never lands the same work twice.
+        journals = isolation.common_git_dir(self.primary).joinpath(*isolation.MEMBER_LANDING_DIR)
+        retired_members = set()
+        for journal in sorted(journals.glob("*.json")) if journals.is_dir() else []:
+            result = isolation.recover_member_landing(self.primary, journal.stem)
+            self.receipt["steps"].append({"script": "isolation.recover_member_landing", "task": journal.stem,
+                                          "result": result})
+            if result["state"] == "landed":
+                isolation.retire_member_task(self.primary, str(result["member"]), journal.stem)
+                retired_members.add(journal.stem)
         report = recover_report(self.primary, self.project_dir, self.receipt)
         for task in report["tasks"]:
             worktree = task.get("worktree")
             verdict = task["verdict"]
             if verdict in ("recovered", "attested"):
                 self.proven[str(task.get("task_id"))] = str(task.get("commit"))
+            if verdict == "recovered" and task.get("member") and task.get("task_id") not in retired_members:
+                isolation.retire_member_task(self.primary, str(task["member"]), str(task["task_id"]))
             if verdict == "recovered" and worktree and worktree["clean"] and task.get("task_branch"):
                 isolation.retire(self.primary, Path(str(worktree["path"])),
                                  str(task["task_branch"]), False)
@@ -730,6 +780,8 @@ class Round:
         if state.get("wave") != self.receipt["wave"]:
             raise DriverStop("task is outside the requested wave", task=state["task_id"],
                              wave=state.get("wave"), requested_wave=self.receipt["wave"])
+        if state.get("mode") == "member":
+            isolation.ensure_member_hooks(self.primary, str(state["member"]), str(state["task_id"]))
         fresh = spawn(self.root, state, self.options,
                       lambda fresh: brief_text(fresh, self.options.role_brief, self.options.task_template))
         self.receipt["dispatched"].append(self.summary(fresh))
@@ -805,6 +857,28 @@ class Round:
         self.runner("lint-round", head)
         round_size = len(selected) + len(in_flight)
         for task in selected:
+            if task.get("repo"):
+                member = str(task["repo"])
+                retained = isolation.retained_member_task(self.primary, member, task["id"],
+                                                          task["task_file"], head)
+                if retained and retained["state"] == "unused":
+                    isolation.retire_member_task(self.primary, member, task["id"])
+                    retained = None
+                if retained:
+                    isolate, active = retained["isolate"], retained["active"]
+                else:
+                    isolate = isolation.isolate_member_task(self.primary, member, task["id"])
+                    active = isolation.activate_member_task(self.primary, member, task["id"],
+                                                            f"build_{task['id'].lower()}", task["task_file"], head)
+                sidecar_path = Path(str(active["worktree"]))
+                self.launch({"task_id": task["id"], "title": task["title"],
+                             "task_file": Path(str(active["copy"])).relative_to(sidecar_path).as_posix(),
+                             "contract_file": task["task_file"], "files": task["files"], "wave": task["wave"],
+                             "verify_heavy": task["verify_heavy"], "base": head, "worktree": str(sidecar_path),
+                             "task_branch": isolate["task_branch"], "mode": "member", "member": member,
+                             "member_base": isolate["member_base"], "project_root": str(self.primary),
+                             "sidecar": None, "answered": False, "model_selection": task['model_selection']})
+                continue
             prepared = self.runner("prepare-task", head, task["id"], round_size)
             isolate = prepared[0]["result"]
             sidecar = prepared[1]["result"] if len(prepared) > 1 else None
@@ -1178,7 +1252,7 @@ class Review:
 def helper_json(receipt: Dict[str, object], script: str, *arguments: str, cwd: Path) -> Dict[str, object]:
     """Run a bundled helper and return its JSON stdout; a non-zero exit is a typed stop."""
     command = [sys.executable, "-B", str(Path(__file__).resolve().parent / script), *arguments]
-    completed = subprocess.run(command, cwd=cwd, capture_output=True, text=True)
+    completed = subprocess.run(command, cwd=cwd, capture_output=True, encoding="utf-8", errors="replace")
     step = {"script": script, "command": command, "exit_code": completed.returncode,
             "stdout": completed.stdout, "stderr": completed.stderr}
     receipt["steps"].append(step)
@@ -1746,7 +1820,7 @@ Heavy: {'yes' if heavy else 'no'}
         receipt["plan_wave"] = fix_wave
         lint = subprocess.run([sys.executable, "-B", str(Path(__file__).resolve().parent / "check_task_briefs.py"),
                                "--repo", str(primary), "--base", isolation.current_sha(primary),
-                               "--tasks-dir", f"{options.project_dir}/tasks"], capture_output=True, text=True)
+                               "--tasks-dir", f"{options.project_dir}/tasks"], capture_output=True, encoding="utf-8", errors="replace")
         receipt["steps"].append({"script": "check_task_briefs.py", "exit_code": lint.returncode,
                                  "stdout": lint.stdout, "stderr": lint.stderr})
         if lint.returncode:
@@ -1981,6 +2055,17 @@ def main(argv=None) -> int:
             current.recover()
             records = [state for state in latest_states(current.root)
                        if state["task_id"] == arguments.task_id]
+            native = None
+            if records and records[0].get("outcome") is not None:
+                # A settled driver record at an older base is superseded by a native retry.
+                try:
+                    native = state_from_task(primary, arguments.task_id)
+                except DriverStop:
+                    pass
+                if native and native["base"] != records[0].get("base"):
+                    records = []
+                else:
+                    native = None
             if arguments.task_id in current.proven:
                 commit = current.proven[arguments.task_id]
                 if records and records[0].get("outcome") is None:
@@ -1997,7 +2082,7 @@ def main(argv=None) -> int:
                 current.classify(record)
             else:  # a coder dispatched by hand: derive the isolate from the task frontmatter
                 current.receipt["landed"].append(
-                    finish_task(primary, state_from_task(primary, arguments.task_id)))
+                    finish_task(primary, native or state_from_task(primary, arguments.task_id)))
             result = {**current.receipt, "status": "landed" if current.receipt["landed"] else "blocked"}
         elif arguments.action == "answer":
             result = answer(primary, arguments.task_id, arguments.answer)

package/scripts/git_guard.py

@@ -6,6 +6,7 @@ hook wiring. Inspection failures and violations both exit 1: unreadable Git
 state cannot prove archive immutability or safe publication.
 """
 
+import json
 import re
 import subprocess
 from functools import lru_cache
@@ -19,8 +20,9 @@ sys.path.insert(0, str(_HERE / "runtime" if (_HERE / "runtime" / "isolation.py")
 sys.dont_write_bytecode = True  # a hook must not leave __pycache__ in the worktree
 try:
     from isolation import BOOKKEEPING_PREFIXES, NULL_SHA, _landing_state, task_frontmatter
-    from pipeline_git import is_ship_subject, task_commit_body
+    from pipeline_git import is_ship_subject, ship_commit_body, task_commit_body
     from pipeline_state import _completion_status
+    import members
 except ImportError as error:  # pragma: no cover - broken install
     print(
         f"gsd-path guard: pipeline runtime is missing ({error}); commit blocked; "
@@ -57,6 +59,10 @@ PRODUCT_HINT = (
     f"while this worktree carries unfinished milestone state, {LANDING_HINT}; "
     "findings during ship reopen through the patch plan"
 )
+MEMBER_PUSH_HINT = (
+    "a member publishes its coordinator's Path refs, or work from them, only with "
+    "a coordinator authorization for that exact ref and object"
+)
 PUBLICATION_HINT = (
     "unshipped milestone work reaches a remote only as its ship commit "
     "(STATE shipped/done) through archive_milestone.py integrate; findings during "
@@ -84,7 +90,7 @@ def staged_entries():
     output = subprocess.run(
         ["git", "diff", "--cached", "--name-status", "-z", "--find-renames"],
         capture_output=True,
-        text=True,
+        encoding="utf-8", errors="replace",
         check=True,
     ).stdout
     tokens = output.split("\0")
@@ -139,7 +145,7 @@ def committed_archive_roots():
     head = subprocess.run(
         ["git", "rev-parse", "--verify", "--quiet", "HEAD^{commit}"],
         capture_output=True,
-        text=True,
+        encoding="utf-8", errors="replace",
         check=False,
     )
     if head.returncode == 1:
@@ -148,7 +154,7 @@ def committed_archive_roots():
     output = subprocess.run(
         ["git", "ls-tree", "-r", "--name-only", "HEAD", "--", ARCHIVE_PREFIX],
         capture_output=True,
-        text=True,
+        encoding="utf-8", errors="replace",
         check=True,
     ).stdout
     return {
@@ -162,7 +168,7 @@ def staged_file(path):
     return subprocess.run(
         ["git", "show", f":{path}"],
         capture_output=True,
-        text=True,
+        encoding="utf-8", errors="replace",
         check=True,
     ).stdout
 
@@ -176,7 +182,7 @@ def shown_file(revspec):
     shown = subprocess.run(
         ["git", "show", revspec],
         capture_output=True,
-        text=True,
+        encoding="utf-8", errors="replace",
         check=False,
     )
     return shown.stdout if shown.returncode == 0 else None
@@ -187,7 +193,7 @@ def state_at(revision):
     subprocess.run(
         ["git", "cat-file", "-e", revision],
         capture_output=True,
-        text=True,
+        encoding="utf-8", errors="replace",
         check=True,
     )
     content = shown_file(f"{revision}:.project/STATE.md")
@@ -288,12 +294,25 @@ def ship_contract_violations(entries, subject, body, new_archives, state):
     reviewed_head = subprocess.run(
         ["git", "rev-parse", "--verify", "HEAD"],
         capture_output=True,
-        text=True,
+        encoding="utf-8", errors="replace",
         check=True,
     ).stdout.strip()
-    expected_body = f"Archive: {archive}\nReviewed-HEAD: {reviewed_head}"
+    lock = f"{archive}/build/members.json"
+    staged_lock = subprocess.run(
+        ["git", "ls-files", "--cached", "--", lock],
+        capture_output=True,
+        encoding="utf-8", errors="replace",
+        check=True,
+    ).stdout
+    locked = [entry["name"] for entry in json.loads(staged_file(lock))["members"]] if staged_lock else []
+    rows = members.read_member_close(
+        Path(git_output("rev-parse", "--path-format=absolute", "--git-common-dir")), Path(archive).name
+    ) if locked else []
+    if [row["name"] for row in rows] != locked or any(row["status"] != "integrated" for row in rows):
+        found.append("ship commit requires every locked member closed; run archive_milestone.py close-members")
+    expected_body = ship_commit_body(archive, reviewed_head, rows).rstrip("\n")
     if body != expected_body:
-        found.append("ship commit body does not match Archive and Reviewed-HEAD")
+        found.append("ship commit body does not match Archive, Reviewed-HEAD, and closed members")
     changed_paths = {
         new if code in "CR" else old
         for code, old, new in entries
@@ -383,11 +402,15 @@ def staged_abandon_target(new_archives, state):
 
 
 @lru_cache(maxsize=None)
+def git_output(*arguments):
+    return subprocess.run(["git", *arguments], capture_output=True, encoding="utf-8", errors="replace", check=True).stdout.strip()
+
+
 def current_branch():
     return subprocess.run(
         ["git", "branch", "--show-current"],
         capture_output=True,
-        text=True,
+        encoding="utf-8", errors="replace",
         check=True,
     ).stdout.strip()
 
@@ -398,7 +421,7 @@ def closed_milestone_reason():
         return None
     commits = subprocess.run(
         ["git", "log", "--format=%H", "--grep=^ship:", "HEAD"],
-        capture_output=True, text=True, check=True,
+        capture_output=True, encoding="utf-8", errors="replace", check=True,
     ).stdout.splitlines()
     if any(ship_commit_at(sha, branch) for sha in commits):
         return (f"closed milestone {branch} accepts no new work; finish integration "
@@ -411,7 +434,7 @@ def head_descends_from(commit):
         subprocess.run(
             ["git", "merge-base", "--is-ancestor", commit, "HEAD"],
             capture_output=True,
-            text=True,
+            encoding="utf-8", errors="replace",
             check=False,
         ).returncode
         == 0
@@ -429,7 +452,7 @@ def repo_root():
         subprocess.run(
             ["git", "rev-parse", "--show-toplevel"],
             capture_output=True,
-            text=True,
+            encoding="utf-8", errors="replace",
             check=True,
         ).stdout.strip()
     )
@@ -505,7 +528,7 @@ def ship_commit_at(sha, bound):
     shown = subprocess.run(
         ["git", "show", "--no-patch", "--format=%s", sha],
         capture_output=True,
-        text=True,
+        encoding="utf-8", errors="replace",
         check=True,
     )
     archive = state.get("archive") or ""
@@ -514,13 +537,7 @@ def ship_commit_at(sha, bound):
     )
 
 
-def pre_push_violations(lines):
-    """Refuse ref updates that publish unshipped milestone work.
-
-    A bound-named ref moves only to, or away from, its strict ship commit. Any
-    other ref may not carry a commit whose STATE.md still owes a ship commit.
-    """
-    found = []
+def _push_updates(lines):
     for line in lines:
         parts = line.split()
         if len(parts) != 4:
@@ -528,6 +545,60 @@ def pre_push_violations(lines):
         local_ref, local_sha, remote_ref, remote_sha = parts
         if any(re.fullmatch(r"[0-9a-fA-F]{40}", sha) is None for sha in (local_sha, remote_sha)):
             raise ValueError(f"unexpected pre-push SHA: {line!r}")
+        yield local_ref, local_sha, remote_ref, remote_sha
+
+
+def _commits(*arguments):
+    listed = subprocess.run(
+        ["git", "rev-list", *arguments], capture_output=True, encoding="utf-8", errors="replace", check=True
+    )
+    return set(listed.stdout.split())
+
+
+def member_pre_push_violations(lines, role):
+    """Member mode: the member's own STATE is ignored; coordinator refs need authorization."""
+    checkout, project = repo_root(), role["project"]
+    reserved = members.member_ref_prefixes(project)
+    members.require_origin_main(checkout)
+    exclude = ["--not", "refs/remotes/origin/main"]
+    member_work = None
+    found = []
+    for _, local_sha, remote_ref, remote_sha in _push_updates(lines):
+        if local_sha == NULL_SHA:
+            if remote_ref.startswith(reserved) and not members.authorized(
+                checkout, project, "delete", remote_ref, remote_sha
+            ):
+                found.append(f"{remote_ref} deletion is not authorized by {project}; {MEMBER_PUSH_HINT}")
+            continue
+        if members.authorized(checkout, project, "push", remote_ref, local_sha):
+            continue
+        if remote_ref.startswith(reserved):
+            found.append(
+                f"{remote_ref} <- {local_sha[:12]} is not authorized by {project}; {MEMBER_PUSH_HINT}"
+            )
+            continue
+        if member_work is None:
+            bound = [ref for ref in subprocess.run(
+                ["git", "for-each-ref", "--format=%(refname)", "refs/heads/gsd-path/"],
+                capture_output=True, encoding="utf-8", errors="replace", check=True,
+            ).stdout.split() if ref.startswith(f"refs/heads/gsd-path/{project}-")]
+            member_work = _commits(*bound, *exclude) if bound else set()
+        if member_work & _commits(local_sha, *exclude):
+            found.append(
+                f"{remote_ref} <- {local_sha[:12]} carries unpublished {project} member work; "
+                f"{MEMBER_PUSH_HINT}"
+            )
+    return found
+
+
+def pre_push_violations(lines):
+    """Refuse ref updates that publish unshipped milestone work.
+
+    A bound-named ref moves only to, or away from, its strict ship commit. Any
+    other ref may not carry a commit whose STATE.md still owes a ship commit.
+    """
+    found = []
+    for local_ref, local_sha, remote_ref, remote_sha in _push_updates(lines):
         names = [ref.removeprefix("refs/heads/") for ref in (local_ref, remote_ref)]
         bounds = {name for name in names if BOUND_BRANCH.fullmatch(name)}
         if bounds:
@@ -574,7 +645,7 @@ def default_branch():
     origin_head = subprocess.run(
         ["git", "symbolic-ref", "--quiet", "--short", "refs/remotes/origin/HEAD"],
         capture_output=True,
-        text=True,
+        encoding="utf-8", errors="replace",
         check=False,
     )
     if origin_head.returncode == 0 and origin_head.stdout.strip().startswith("origin/"):
@@ -582,7 +653,7 @@ def default_branch():
     configured = subprocess.run(
         ["git", "config", "--get", "init.defaultBranch"],
         capture_output=True,
-        text=True,
+        encoding="utf-8", errors="replace",
         check=False,
     )
     if configured.returncode == 0 and configured.stdout.strip():
@@ -604,7 +675,7 @@ def is_integration_merge(subject):
     merge_head = subprocess.run(
         ["git", "rev-parse", "--verify", "--quiet", "MERGE_HEAD^{commit}"],
         capture_output=True,
-        text=True,
+        encoding="utf-8", errors="replace",
         check=False,
     )
     bound_head = subprocess.run(
@@ -616,7 +687,7 @@ def is_integration_merge(subject):
             f"refs/heads/{match.group('branch')}^{{commit}}",
         ],
         capture_output=True,
-        text=True,
+        encoding="utf-8", errors="replace",
         check=False,
     )
     return (
@@ -708,18 +779,34 @@ def report(found, action):
 
 
 def main(argv):
+    # Git reads hook output as UTF-8; a Windows pipe would default to cp1252.
+    # In-process callers may substitute text streams.
+    for stream in (sys.stdout, sys.stderr):
+        if hasattr(stream, "reconfigure"):
+            stream.reconfigure(encoding="utf-8", errors="replace")
     if len(argv) > 1 and argv[1] == "closed-milestone":
         reason = closed_milestone_reason()
         return report([reason] if reason else [], "mutation")
     if len(argv) > 1 and argv[1] == "pre-push":
         try:
-            found = pre_push_violations(sys.stdin.read().splitlines())
+            stdin = getattr(sys.stdin, "buffer", None)
+            text = (stdin.read().decode("utf-8", errors="surrogateescape")
+                    if stdin is not None else sys.stdin.read())
+            lines = text.splitlines()
+            role = members.member_role(repo_root())
+            found = member_pre_push_violations(lines, role) if role else pre_push_violations(lines)
         except Exception as error:
             print(f"gsd-path guard: inspection failed; push blocked ({error})", file=sys.stderr)
             return 1
         return report(found, "push")
     try:
-        reason = closed_milestone_reason()
+        # A member follows its coordinator, so its own STATE does not gate commits.
+        role = members.member_role(repo_root())
+        member = role is not None
+        if member and current_branch().startswith(f"gsd-path/{role['project']}-"):
+            return report([f"direct commits on the member bound branch {current_branch()} are refused; "
+                           "member tasks land there through Path"], "commit")
+        reason = None if member else closed_milestone_reason()
         if reason:
             return report([reason], "commit")
         entries = staged_entries()
@@ -740,7 +827,7 @@ def main(argv):
         )
         if abandon is not None:
             current_archive = abandon[0]
-        landing = product_commit_violations(entries, subject, body)
+        landing = [] if member else product_commit_violations(entries, subject, body)
     except Exception as error:
         print(
             f"gsd-path guard: inspection failed; commit blocked ({error}); "