brindle 0.3.20__tar.gz → 0.3.22__tar.gz

{brindle-0.3.20 → brindle-0.3.22}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: brindle
-Version: 0.3.20
+Version: 0.3.22
 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
@@ -94,7 +94,7 @@ uv tool install --editable ~/Projects/brindle   # or from a local checkout
 brindle drives Claude Code, so you need that too (`npm install -g @anthropic-ai/claude-code`).
 
 `brindle --version` prints the installed version; the tmux status bar of every brindle
-session shows it too (`brindle 0.3.20`). A session started before an upgrade keeps
+session shows it too (`brindle 0.3.22`). A session started before an upgrade keeps
 running the old code, and shows the old number, until you restart it.
 
 ## Quick start

{brindle-0.3.20 → brindle-0.3.22}/README.md

@@ -63,7 +63,7 @@ uv tool install --editable ~/Projects/brindle   # or from a local checkout
 brindle drives Claude Code, so you need that too (`npm install -g @anthropic-ai/claude-code`).
 
 `brindle --version` prints the installed version; the tmux status bar of every brindle
-session shows it too (`brindle 0.3.20`). A session started before an upgrade keeps
+session shows it too (`brindle 0.3.22`). A session started before an upgrade keeps
 running the old code, and shows the old number, until you restart it.
 
 ## Quick start

{brindle-0.3.20 → brindle-0.3.22}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "brindle"
-version = "0.3.20"
+version = "0.3.22"
 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.3.20 → brindle-0.3.22}/src/brindle/agents.py

@@ -19,6 +19,7 @@ import subprocess
 import sys
 import time
 import uuid
+from types import SimpleNamespace
 
 from brindle import cloud_credential, company_identity, company_login, git, keystore, pane_auth, providers, secrets, tmux, workspaces
 from brindle.config import RepoConfig
@@ -981,11 +982,12 @@ def run_headless(db: DB, agent_id: str, resume: str | None = None, *,
     provider = get_provider(agent.provider)
     session = resume
     turn = 0
+    retry = None    # a turn the cloud login failed: run again before anything else
     while True:
         agent = db.get_agent(agent_id)
         if agent is None:
             return 0
-        msg = db.pop_pending(agent_id)
+        msg, retry = retry or db.pop_pending(agent_id), None
         if msg is None:
             if exit_when_idle:
                 return 0
@@ -1014,12 +1016,46 @@ def run_headless(db: DB, agent_id: str, resume: str | None = None, *,
             return 0
         session = agent.session_ref or session
         if code != 0:
+            if wait_for_cloud_login(db, agent, ws):
+                # The same turn again, from where it stopped.
+                retry = SimpleNamespace(body=HEADLESS_CONTINUE) if session else msg
+                continue
             print(f"\n── brindle: claude exited with code {code}; this worker has stopped ──", flush=True)
             return code
         db.set_status(agent_id, "idle", only_if="processing")
         print("── brindle: turn finished; waiting for messages ──", flush=True)
 
 
+def wait_for_cloud_login(db: DB, agent: Agent, ws: Workspace, poll: float = 60.0) -> bool:
+    """A headless turn failed. If it was on a lapsed cloud login, wait here
+    (offering the one browser sign-in, see cloud_login.sign_in) until the
+    login works again and return True; False for any other failure."""
+    from brindle import cloud_login
+
+    try:
+        env = agent_env(ws, agent.id, agent)
+    except Exception:  # noqa: BLE001 - an unreadable env: not ours to wait on
+        return False
+    if cloud_login.provider_from_env({**os.environ, **env}) is None:
+        return False
+    s = cloud_login.refresh(env=env)
+    if not s.expired:
+        return False
+    print("\n── brindle: the cloud login lapsed; this worker waits until it's renewed "
+          f"(sign in with the browser tab brindle opens, or run `{s.refresh_cmd}`) ──", flush=True)
+    while db.get_agent(agent.id) is not None:
+        try:
+            last_input = tmux.last_input()
+        except tmux.TmuxError:
+            last_input = None
+        cloud_login.sign_in(env=env, last_input=last_input)
+        if cloud_login.status(env=env).ok:
+            print("── brindle: cloud login renewed; continuing ──", flush=True)
+            return True
+        time.sleep(poll)
+    return False
+
+
 def ready(db: DB, agent_id: str) -> None:
     """after_launch saw the CLI's input box. For CLIs with no hook that says
     so, this is when it's ready (and when queued messages can go in)."""
@@ -1867,6 +1903,16 @@ def _detach(args: list[str]) -> None:
                      stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
 
 
+def _detach_orphan(args: list[str]) -> None:
+    """Start a brindle helper that outlives this process and its agent: a
+    shell starts it in the background and exits, so it is nobody's child.
+    Stopping an agent stops every process descended from its MCP server
+    (brindle.procs), a helper ``_detach`` started there included."""
+    subprocess.run(["/bin/sh", "-c", '"$@" </dev/null >/dev/null 2>&1 &', "sh", *args],
+                   start_new_session=True, stdin=subprocess.DEVNULL,
+                   stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL, check=False)
+
+
 def wait_for_result(db: DB, agent_id: str, timeout: float, poll: float = 2.0) -> str:
     deadline = time.time() + timeout
     while time.time() < deadline:
@@ -1935,37 +1981,73 @@ def submit_review(db: DB, caller_id: str, approved: bool, summary: str) -> str:
             db.enqueue(root_id, text, None)   # handed over at the supervisor's next Stop
         close_later(caller.id)
         return "Audit recorded and sent to the supervisor. You're done."
+    # Already recorded: closing this reviewer is its verdict's job, once
+    # whatever the verdict set off is done. Checked before the lock too, which
+    # that work (a merge running the checks) can hold for minutes.
+    recorded = "Your review was already recorded. You're done."
+    if caller.result is not None:
+        return recorded
     # One verdict at a time per workspace: a second one (the same reviewer
     # calling twice, or another reviewer of the same branch) waits here, then
     # finds what the first one did instead of merging alongside it.
     with pipeline.merge_lock(ws.id):
         caller = db.get_agent(caller_id)
-        if caller is None or caller.result is not None or db.get_workspace(ws.id) is None \
-                or not os.path.isdir(ws.path):
-            # Already recorded, or the branch merged (or was removed) meanwhile.
-            close_later(caller_id)
-            return "Your review was already recorded, or the branch is already merged. You're done."
+        if caller is not None and caller.result is not None:
+            return recorded
+        if caller is None or db.get_workspace(ws.id) is None or not os.path.isdir(ws.path):
+            close_later(caller_id)   # the branch merged (or was removed) meanwhile
+            return "The branch is already merged or removed. You're done."
         sha = gates.head(ws)
         db.add_review(ws.id, sha, caller.id, approved, summary)
         if approved:
             db.bump_progress(autopilot.root_of(db, caller.id))
         pipeline.note_review(db, ws, approved, reviewer=caller)
         verdict = "APPROVED" if approved else "CHANGES REQUESTED"
-        text = f"Review of {ws.branch} (workspace {ws.id}) at {sha[:8]}: {verdict}\n\n{summary}"
-    # Outside the lock: an approval merges every ready branch of the base,
-    # taking each one's lock in turn, and holding this branch's lock while
-    # waiting for that would deadlock with a drain that wants it.
-    handled = pipeline.on_review(db, caller, ws, approved, summary)
-    # A merge the pipeline just made removes this reviewer's own record.
-    report_result(db, caller.id, text, forward=not handled, removed=(caller, ws))
-    close_later(caller.id)
-    if not approved:
-        from brindle import learned_rules
-
-        learned_rules.refresh_later(ws.repo_root)   # the finding just landed in the history
-    if handled:
-        return f"Review recorded ({verdict}); brindle takes it from here. You're done."
-    return f"Review recorded ({verdict}) and sent to your supervisor. You're done."
+        db.set_result(caller.id, _review_text(ws, sha, approved, summary))
+    finish_review_later(caller.id, ws.id)
+    return f"Review recorded ({verdict}); brindle takes it from here. You're done."
+
+
+def _review_text(ws: Workspace, sha: str, approved: bool, summary: str) -> str:
+    verdict = "APPROVED" if approved else "CHANGES REQUESTED"
+    return f"Review of {ws.branch} (workspace {ws.id}) at {sha[:8]}: {verdict}\n\n{summary}"
+
+
+def finish_review_later(reviewer_id: str, ws_id: str) -> None:
+    """Act on a recorded verdict (``finish_review``) from a process of its
+    own. Not in the reviewer's MCP server: a merge runs the repo's checks,
+    which can take minutes, and a reviewer kept waiting that long calls
+    submit_review again, or is closed, which would stop the merge, the
+    queued tasks it starts and the supervisor's notice half way."""
+    from brindle.providers import brindle_invocation
+
+    _detach_orphan([*brindle_invocation(), "_finish-review", reviewer_id, ws_id])
+
+
+def finish_review(db: DB, reviewer_id: str, ws_id: str) -> None:
+    """Hand a verdict submit_review recorded to the pipeline if the branch
+    is piped, else to the supervisor, then close the reviewer."""
+    from brindle import pipeline
+
+    try:
+        caller, ws = db.get_agent(reviewer_id), db.get_workspace(ws_id)
+        review = next((r for r in reversed(db.workspace_reviews(ws_id))
+                       if r.reviewer_id == reviewer_id), None) if caller and ws else None
+        if review is None:
+            return
+        # Outside the lock: an approval merges every ready branch of the base,
+        # taking each one's lock in turn, and holding this branch's lock while
+        # waiting for that would deadlock with a drain that wants it.
+        handled = pipeline.on_review(db, caller, ws, review.approved, review.summary or "")
+        # A merge the pipeline just made removes this reviewer's own record.
+        text = _review_text(ws, review.sha, review.approved, review.summary or "")
+        report_result(db, caller.id, text, forward=not handled, removed=(caller, ws))
+        if not review.approved:
+            from brindle import learned_rules
+
+            learned_rules.refresh_later(ws.repo_root)   # the finding just landed in the history
+    finally:
+        close_later(reviewer_id)
 
 
 def close_later(agent_id: str, delay: float = 5.0) -> None:
@@ -2713,6 +2795,15 @@ def _stop_decision(db: DB, agent: Agent, payload: dict, via_inbox: bool = False)
     inbox message rather than block the stop, so ``stop_hook_active`` never
     caps a repeat; the unread-mail reminder is then limited to one per
     NOTICE_TTL (DB.claim_stop_reminder)."""
+    if agent.mode == "interactive":
+        # Every supervisor turn ends here: start any queued task a cut-off or
+        # manual merge left waiting (its "Started" note is delivered below).
+        try:
+            from brindle import tasks
+
+            tasks.sweep(db)
+        except Exception:  # noqa: BLE001 -- must never break the Stop hook
+            log.exception("brindle: queued-task sweep failed")
     msg = db.pop_pending(agent.id)
     if msg:
         db.set_status(agent.id, "processing")

{brindle-0.3.20 → brindle-0.3.22}/src/brindle/cli.py

@@ -589,7 +589,12 @@ def _pause_running(db: DB, ws: Workspace, stop_procs: bool = True) -> None:
     ``stop_procs=False`` when a detached cull follows (see agents.pause)."""
     from brindle import scratch
 
-    for a in _live_sessions(db, ws):
+    live = _live_sessions(db, ws)
+    caller = os.environ.get("BRINDLE_AGENT_ID")
+    if caller and any(a.id == caller for a in live):
+        # Pausing kills the session's process tree, this command with it.
+        _fail("this command would stop the session running it; run it from a terminal instead")
+    for a in live:
         # A session starts here next: keep its local models loaded.
         agents.pause(db, a.id, stop_procs=stop_procs, stop_local_models=False)
         typer.echo(f"Paused the session that was still running here ({a.id}); "
@@ -2814,6 +2819,15 @@ def close_cmd(agent_id: str, delay: float = typer.Option(0.0)) -> None:
         pass
 
 
+@app.command("_finish-review", hidden=True)
+def finish_review_cmd(reviewer_id: str, workspace_id: str) -> None:
+    import signal
+
+    # Started by the reviewer's submit_review, and must outlive its close.
+    signal.signal(signal.SIGHUP, signal.SIG_IGN)
+    agents.finish_review(_helper_db(), reviewer_id, workspace_id)
+
+
 @app.command("_statusline", hidden=True)
 def statusline_cmd() -> None:
     from brindle.providers import status_line