brindle 0.4.3__tar.gz → 0.4.5__tar.gz

{brindle-0.4.3 → brindle-0.4.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: brindle
-Version: 0.4.3
+Version: 0.4.5
 Summary: Run coding agents in parallel, each on its own git branch, with a supervisor that delegates, reviews, and merges
 Project-URL: Homepage, https://pawdelta.com/brindle/
 Project-URL: Documentation, https://pawdelta.com/brindle/docs/recommended-use

{brindle-0.4.3 → brindle-0.4.5}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "brindle"
-version = "0.4.3"
+version = "0.4.5"
 description = "Run coding agents in parallel, each on its own git branch, with a supervisor that delegates, reviews, and merges"
 readme = "README.md"
 requires-python = ">=3.11"

{brindle-0.4.3 → brindle-0.4.5}/src/brindle/agents.py

@@ -2159,9 +2159,45 @@ def finish_review(db: DB, reviewer_id: str, ws_id: str) -> None:
 
             learned_rules.refresh_later(ws.repo_root)   # the finding just landed in the history
     finally:
+        # A merge removes the workspace but leaves the session this reviewer
+        # runs in; once the reviewer is gone nobody else would end it.
+        if ws and db.get_workspace(ws_id) is None:
+            _closing_session(reviewer_id).write_text(ws.tmux_session)
         close_later(reviewer_id)
 
 
+def _closing_session(agent_id: str):
+    from brindle.config import brindle_home
+
+    d = brindle_home() / "closing"
+    d.mkdir(parents=True, exist_ok=True)
+    return d / agent_id
+
+
+def close_removed(db: DB, agent_id: str) -> None:
+    """Kill an agent and, when its workspace was removed with the session left
+    running (noted by ``finish_review``), that session too: only brindle's own,
+    unattached session of a workspace that no longer exists."""
+    note = _closing_session(agent_id)
+    try:
+        session = note.read_text().strip()
+        note.unlink()
+    except OSError:
+        session = ""
+    root_id = root_of(db, agent_id)   # before kill drops the record that links it
+    try:
+        kill(db, agent_id)
+    except AgentError:
+        pass
+    if session and db.workspace_by_tmux_session(session) is None \
+            and not tmux.session_attached(session):
+        # A sidebar left in this session would go down with it.
+        sidebar = db.get_sidebar_pane(root_id)
+        if sidebar and sidebar != SIDEBAR_DISMISSED and tmux.pane_session(sidebar) == session:
+            sidebar_come_home(db, root_id, sidebar)
+        tmux.kill_session(session)
+
+
 def close_later(agent_id: str, delay: float = 5.0) -> None:
     """Stop an agent shortly, from a detached process: used by an agent's own
     tool call, which must return before its CLI goes away."""
@@ -2182,6 +2218,12 @@ def _stop(db: DB, agent: Agent) -> None:
     # Only a window on the server brindle is using: another server's pane
     # ids mean other panes here (see same_server).
     window = agent.tmux_window if same_server(agent) and owns_pane(db, agent) else ""
+    if window:
+        from brindle.sidebar_follow import rescue_sidebar_from_window
+
+        # Before the pids are read: a moved pane keeps its process, and the
+        # sidebar's would otherwise be stopped with the agent's.
+        rescue_sidebar_from_window(db, agent)
     pane_pids = tmux.window_pids(window) if window else []
     if window:
         tmux.kill_window(window)

{brindle-0.4.3 → brindle-0.4.5}/src/brindle/cli.py

@@ -3080,10 +3080,7 @@ def quit_cmd(root_id: str) -> None:
 @app.command("_close", hidden=True)
 def close_cmd(agent_id: str, delay: float = typer.Option(0.0)) -> None:
     time.sleep(delay)
-    try:
-        agents.kill(_helper_db(), agent_id)
-    except agents.AgentError:
-        pass
+    agents.close_removed(_helper_db(), agent_id)
 
 
 @app.command("_finish-review", hidden=True)

{brindle-0.4.3 → brindle-0.4.5}/src/brindle/codex_hook.py

@@ -36,6 +36,7 @@ import json
 import os
 import queue
 import shlex
+import signal
 import subprocess
 import threading
 import time
@@ -228,7 +229,8 @@ class _AppServer:
         self.timeout = timeout
         try:
             self.proc = subprocess.Popen([binary, "app-server", *flags], stdin=subprocess.PIPE,
-                                         stdout=subprocess.PIPE, stderr=subprocess.DEVNULL, text=True)
+                                         stdout=subprocess.PIPE, stderr=subprocess.DEVNULL, text=True,
+                                         start_new_session=True)
         except OSError as e:
             raise CodexHookError(f"couldn't run {binary}: {e}") from e
         self.lines: queue.Queue = queue.Queue()
@@ -279,6 +281,14 @@ class _AppServer:
                 return result
 
     def close(self) -> None:
+        # The app-server leads its own process group (see __init__): kill the
+        # group so nothing it spawned outlives it.
+        pid = getattr(self.proc, "pid", None)
+        if pid:
+            try:
+                os.killpg(pid, signal.SIGKILL)
+            except OSError:
+                pass
         try:
             self.proc.kill()
         except OSError:

{brindle-0.4.3 → brindle-0.4.5}/src/brindle/sessions.py

@@ -40,10 +40,22 @@ class Session:
 
 
 def paused(db: DB, repo_root: str) -> list[Session]:
-    """Paused sessions whose chat ran in ``repo_root``, newest first."""
+    """Paused sessions whose chat ran in ``repo_root``, newest first. A
+    "failed" chat whose pane is still running isn't one: that status also
+    marks a live chat (a brief whose delivery wasn't confirmed, an auth error
+    on one turn), and dropping it (see enforce) would close it mid-session."""
     out = []
+    panes = owners = None
     for ws in db.find_workspaces(repo_root):
         for a in db.list_agents(ws.id):
+            if a.mode == "interactive" and a.status == "failed":
+                if panes is None:
+                    panes = tmux.list_panes()
+                    owners = agents.pane_owners(db, panes)
+                # On another server, its own server's panes say whose its pane is.
+                mine = owners if agents.same_server(a, panes) else None
+                if agents.is_alive(a, panes) and agents.owns_pane(db, a, mine):
+                    continue
             if a.mode == "interactive" and a.status in ("paused", "failed"):
                 members = agents.tree(db, a.id)
                 branches = []
@@ -212,6 +224,9 @@ def _forget(db: DB, s: Session) -> None:
         # some other pane here (see agents.same_server).
         if (a.tmux_window and agents.same_server(a, panes) and agents.is_alive(a, panes)
                 and agents.owns_pane(db, a, owners)):
+            from brindle.sidebar_follow import rescue_sidebar_from_window
+
+            rescue_sidebar_from_window(db, a)
             tmux.kill_window(a.tmux_window)
         ws = db.get_workspace(a.workspace_id)
         if ws and ws.kind == "worktree":

{brindle-0.4.3 → brindle-0.4.5}/src/brindle/sidebar_follow.py

@@ -196,6 +196,54 @@ def rescue_sidebar(db: DB, ws: Workspace) -> None:
         pass
 
 
+def _home_session(db: DB, root_id: str, sidebar: str) -> str | None:
+    """The brindle session whose agent window ``sidebar`` sits in. Not
+    ``tmux.pane_session``: a window the app linked into its own
+    ``brindle-view-*`` session reports that one, and that session being
+    attached says nothing about the person's terminal on the brindle session."""
+    window = tmux.pane_window(sidebar)
+    for agent in db.list_agents():
+        if (window and agent.tmux_window and root_of(db, agent.id) == root_id
+                and tmux.pane_window(agent.tmux_window) == window):
+            ws = db.get_workspace(agent.workspace_id)
+            if ws is not None:
+                return ws.tmux_session
+    return tmux.pane_session(sidebar)
+
+
+def rescue_sidebar_from_window(db: DB, agent: Agent) -> None:
+    """Call before ``agent``'s tmux window is killed: if its root's sidebar is
+    a pane in that window, move it to a window of the root's session that
+    survives (the root's active one, else any other agent's there: a worker
+    sharing the root's workspace has its window in the same session). Never
+    raises."""
+    try:
+        if not agent.tmux_window:
+            return
+        root_id = root_of(db, agent.id)
+        root = db.get_agent(root_id)
+        root_ws = db.get_workspace(root.workspace_id) if root else None
+        if root is None or root_ws is None or agent.id == root_id:
+            return
+        with _sidebar_lock(root_id):
+            sidebar = db.get_sidebar_pane(root_id)
+            doomed = tmux.pane_window(agent.tmux_window)
+            if not (_valid_sidebar(sidebar, root_id) and doomed
+                    and tmux.pane_window(sidebar) == doomed):
+                return
+            candidates = [tmux.active_window(root_ws.tmux_session)]
+            candidates += [tmux.pane_window(a.tmux_window) for a in db.list_agents(root_ws.id)
+                           if a.tmux_window and a.status not in ("paused", "done")]
+            for window in candidates:
+                target_pane = window and window != doomed and tmux.agent_pane_in_window(window, sidebar)
+                if target_pane:
+                    _note_sidebar_move(f"rescue to {root_ws.tmux_session}", sidebar, target_pane)
+                    tmux.move_pane(sidebar, target_pane, SIDEBAR_COLUMNS, _sidebar_position(root_ws))
+                    return
+    except Exception:  # noqa: BLE001 - cleanup must not fail because of the sidebar
+        pass
+
+
 def sidebar_follow(db: DB, session: str) -> None:
     ws = db.workspace_by_tmux_session(session)
     if ws is None:
@@ -240,10 +288,13 @@ def sidebar_follow(db: DB, session: str) -> None:
         if tmux.pane_window(sidebar) == window:
             _repaint(sidebar)
             return
-        if not tmux.session_attached(session):
-            home = tmux.pane_session(sidebar)
-            if home and home != session and tmux.session_attached(home):
-                return
+        # Never take it out of another session someone still looks at: the
+        # person's own switch-client leaves that session first, so it reads
+        # unattached by now. A second client (the app's, attached to a
+        # worker's session) changing windows must not pull it from their terminal.
+        home = _home_session(db, root_id, sidebar)
+        if home and home != session and tmux.session_attached(home):
+            return
         target_pane = tmux.agent_pane_in_window(window, sidebar)
         if not target_pane:
             return