@opengsd/gsd-path 1.3.1 → 1.4.0

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