brindle 0.3.23__tar.gz → 0.3.24__tar.gz

{brindle-0.3.23 → brindle-0.3.24}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: brindle
-Version: 0.3.23
+Version: 0.3.24
 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.23`). A session started before an upgrade keeps
+session shows it too (`brindle 0.3.24`). 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.23 → brindle-0.3.24}/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.23`). A session started before an upgrade keeps
+session shows it too (`brindle 0.3.24`). 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.23 → brindle-0.3.24}/pyproject.toml

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

@@ -1358,6 +1358,24 @@ def is_alive(agent: Agent, panes: dict[str, bool] | None = None) -> bool:
     return tmux.window_alive(agent.tmux_window, server=agent.tmux_server or None)
 
 
+LAUNCH_GRACE = 60.0   # seconds a just-spawned agent may go without a window before it counts as dead
+
+
+def alive_or_starting(agent: Agent) -> bool:
+    """``is_alive``, or still being launched: spawn records the agent before
+    its window opens (the launch's checks can take seconds), so one with no
+    window yet is starting, not dead, for LAUNCH_GRACE seconds. A launch known
+    to have failed ends that: spawn deletes the row of one that raised, and
+    launch_health marks one whose CLI died at startup "failed". For the
+    checks that would replace the agent (start another reviewer, forget an
+    auditor), not for ones that talk to its pane."""
+    if is_alive(agent):
+        return True
+    return (runs_process(agent) and not agent.tmux_window and agent.result is None
+            and agent.status not in ("paused", "done", "failed")
+            and time.time() - agent.created_at < LAUNCH_GRACE)
+
+
 def server_of(agent: Agent) -> str | None:
     """The tmux server ``agent``'s window is on (a private socket name, or
     None for the default server), for the ``server`` argument of tmux calls
@@ -1908,12 +1926,17 @@ def _detach(args: list[str]) -> None:
                      stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
 
 
+# A shell that starts the command after it in the background and exits, so the
+# command is nobody's child (see _detach_orphan).
+ORPHANED = ["/bin/sh", "-c", '"$@" </dev/null >/dev/null 2>&1 &', "sh"]
+
+
 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],
+    subprocess.run([*ORPHANED, *args],
                    start_new_session=True, stdin=subprocess.DEVNULL,
                    stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL, check=False)
 
@@ -2350,7 +2373,7 @@ def _live_reviewer(db: DB, ws: Workspace, sha: str, profile: str | None = None)
     ``profile``, only one running that profile (a second review by another
     profile is not a duplicate)."""
     for a in db.list_agents(ws.id):
-        if a.mode == "review" and a.result is None and is_alive(a) and a.review_sha == sha \
+        if a.mode == "review" and a.result is None and alive_or_starting(a) and a.review_sha == sha \
                 and (profile is None or a.profile == profile):
             return a
     return None
@@ -2386,7 +2409,9 @@ def start_review(db: DB, caller: Agent | None, ws: Workspace, profile: str | Non
         argv += ["--profile", profile]
     if focus:
         argv += ["--focus", focus]
-    _detach(argv)
+    # Nobody's child: the worker reporting here may be closed while the checks
+    # still run, and stopping it would stop this run too, so no reviewer (#190).
+    _detach([*ORPHANED, *argv])
     return None
 
 
@@ -2417,34 +2442,36 @@ def review_after_checks(db: DB, caller_id: str | None, ws: Workspace, profile: s
     a new report (its worker committed again, or merged its moved base in)
     is checked again on its new head, up to ``MOVED_RETRIES`` times, and then
     goes to the supervisor. Raises ``AgentError`` when the reviewer can't
-    start."""
+    start. Holds ``pipeline.review_run`` throughout, so the sweep can tell
+    this run at work (queued for a slot, say) from one that died."""
     from brindle import gates, pipeline
     from brindle.config import load_repo_config
 
     cfg = cfg or load_repo_config(ws.repo_root)
-    since = pipeline.review_claim(db, ws)
-    for _attempt in range(MOVED_RETRIES + 1):
-        sha = gates.head(ws)
-        if _live_reviewer(db, ws, sha, profile):
-            return None
-        try:
-            summary = gates.check_summary(db, ws, cfg, cancel=lambda sha=sha: gates.head(ws) != sha)
-        except gates.Abandoned:
-            summary = None
-        except Exception as e:  # noqa: BLE001 - the review goes ahead, saying so
-            summary = f"(running the checks crashed: {e})"
-        if db.get_workspace(ws.id) is None:
-            return None
-        if gates.head(ws) == sha:
-            break
-        if not pipeline.still_claimed(db, ws, since):
+    with pipeline.review_run(ws.id):
+        since = pipeline.review_claim(db, ws)
+        for _attempt in range(MOVED_RETRIES + 1):
+            sha = gates.head(ws)
+            if _live_reviewer(db, ws, sha, profile):
+                return None
+            try:
+                summary = gates.check_summary(db, ws, cfg, cancel=lambda sha=sha: gates.head(ws) != sha)
+            except gates.Abandoned:
+                summary = None
+            except Exception as e:  # noqa: BLE001 - the review goes ahead, saying so
+                summary = f"(running the checks crashed: {e})"
+            if db.get_workspace(ws.id) is None:
+                return None
+            if gates.head(ws) == sha:
+                break
+            if not pipeline.still_claimed(db, ws, since):
+                return None
+        else:
+            pipeline.on_moved_during_checks(db, ws)
             return None
-    else:
-        pipeline.on_moved_during_checks(db, ws)
-        return None
-    caller = db.get_agent(caller_id) if caller_id else None
-    text = f"Checks for {ws.branch} at {sha[:8]}:\n\n{summary}" if summary else None
-    return request_review(db, caller, ws, profile, focus, cfg, check_summary=text)
+        caller = db.get_agent(caller_id) if caller_id else None
+        text = f"Checks for {ws.branch} at {sha[:8]}:\n\n{summary}" if summary else None
+        return request_review(db, caller, ws, profile, focus, cfg, check_summary=text)
 
 
 def request_review(db: DB, caller: Agent | None, ws: Workspace, profile: str | None = None,
@@ -2469,7 +2496,7 @@ def request_review(db: DB, caller: Agent | None, ws: Workspace, profile: str | N
     cfg = cfg or load_repo_config(ws.repo_root)
     sha = gates.head(ws)
     for old in db.list_agents(ws.id):
-        if old.mode != "review" or old.result is not None or not is_alive(old):
+        if old.mode != "review" or old.result is not None or not alive_or_starting(old):
             continue
         if old.unreported_noted:
             continue   # it stopped without a verdict: not the reviewer of anything

{brindle-0.3.23 → brindle-0.3.24}/src/brindle/antigravity.py

@@ -110,7 +110,9 @@ def binary() -> str:
     explicit = os.environ.get("BRINDLE_AGY_BIN")
     if explicit:
         return explicit
-    return shutil.which("agy") or (BUNDLED if os.path.exists(BUNDLED) else "agy")
+    from brindle.providers import which_cli
+
+    return which_cli("agy") or (BUNDLED if os.path.exists(BUNDLED) else "agy")
 
 
 def tool_names() -> list[str]:

{brindle-0.3.23 → brindle-0.3.24}/src/brindle/autopilot.py

@@ -1823,9 +1823,10 @@ def on_stop(db: DB, agent: Agent, payload: dict) -> dict | None:
     if ap.state == "auditing":
         if ap.auditor_id:
             auditor = db.get_agent(ap.auditor_id)
-            if auditor is None or auditor.status in ("paused", "done") or not agents.is_alive(auditor) or auditor.result is not None:
-                # Auditor was spawned but is no longer running (dead or crashed without verdict).
-                # Reset state to running so autopilot can recover.
+            if auditor is None or auditor.status in ("paused", "done") or not agents.alive_or_starting(auditor) \
+                    or auditor.result is not None:
+                # Auditor was spawned but is no longer running (dead or crashed without verdict;
+                # one still starting isn't). Reset state to running so autopilot can recover.
                 db.update_autopilot(agent.id, state="running", auditor_id=None)
                 ap = db.get_autopilot(agent.id)
             else:

{brindle-0.3.23 → brindle-0.3.24}/src/brindle/cli.py

@@ -35,6 +35,7 @@ class _App(typer.Typer):
 
 
 SUPERVISOR_FLAGS = ("-s", "--supervisor")
+_group_supervisor: Optional[str] = None      # -s given before the subcommand (set by default())
 
 
 def _bare_supervisor_flag(args: list[str], commands) -> list[str]:
@@ -44,6 +45,11 @@ def _bare_supervisor_flag(args: list[str], commands) -> list[str]:
     value."""
     from brindle.picker import PICK
 
+    split = []
+    for a in args:
+        # Click would read "-s=codex" as the value "=codex".
+        split += ["-s", a[3:]] if a.startswith("-s=") else [a]
+    args = split
     out = []
     for i, a in enumerate(args):
         out.append(a)
@@ -306,7 +312,18 @@ def start(
     from brindle.config import load_repo_config
     from brindle import scratch
 
-    provider = provider or provider_alias
+    from brindle import picker
+    from brindle.providers import NOT_SUPERVISOR, SUPERVISOR_PROVIDERS, get_provider
+
+    provider = provider or provider_alias or _group_supervisor
+    if provider and provider != picker.PICK:
+        if provider in NOT_SUPERVISOR:
+            _fail(f"the {provider} provider can't run the supervisor; use one of: "
+                  f"{', '.join(SUPERVISOR_PROVIDERS)}")
+        try:
+            get_provider(provider)
+        except KeyError as e:
+            _fail(str(e).strip("'\""))
     db = DB()
     if branch or worktree:
         ws = _run(workspaces.checkout_for, db, os.getcwd(), branch=branch, worktree=worktree)
@@ -314,7 +331,7 @@ def start(
         ws = _here_or_scratch(db, reuse_scratch=False)
         running = _running_session(db, ws)
         if running and attach and sys.stdin.isatty():
-            choice = _ask_about_running(running)
+            choice = _ask_about_running(running, provider)
             if choice == "o":
                 _attach(ws, running.tmux_window)
                 return
@@ -324,30 +341,27 @@ def start(
 
     if not branch and not worktree and not scratch.is_scratch(ws.path):
         curr_b = git.current_branch(ws.path)
+        default_b = git.default_branch(ws.repo_root) if curr_b else None
         if curr_b and git.merged_into_default(ws.repo_root, curr_b):
-            default_b = git.default_branch(ws.repo_root)
             typer.secho(f"! Branch '{curr_b}' is already merged into '{default_b}'.", fg="yellow")
             try:
                 if not git.dirty_files(ws.path):
                     git.run(["checkout", default_b], ws.path)
                     ws = workspaces.refresh_branch(db, ws)
+                    curr_b = default_b
                     typer.secho(f"✓ Switched to '{default_b}'.", fg="green")
             except Exception:
                 pass
-        elif curr_b and git.upstream_gone(ws.path, curr_b):
+        elif curr_b != default_b and git.upstream_gone(ws.path, curr_b):
+            # (the default branch is left out: a network probe for the common case)
             typer.secho(f"! Branch '{curr_b}' was deleted on origin but has unmerged changes.", fg="yellow")
         try:
-            if curr_b and git.current_branch(ws.path) == git.default_branch(ws.repo_root):
-                if warning := git.fast_forward(ws.path, git.current_branch(ws.path)):
+            if curr_b and curr_b == default_b:
+                if warning := git.fast_forward(ws.path, curr_b):
                     typer.secho(f"! {warning}", fg="yellow")
         except git.GitError:
             pass
 
-    from brindle.providers import NOT_SUPERVISOR, SUPERVISOR_PROVIDERS
-
-    if provider and provider in NOT_SUPERVISOR:
-        _fail(f"the {provider} provider can't run the supervisor; use one of: "
-              f"{', '.join(SUPERVISOR_PROVIDERS)}")
     provider = _resolve_supervisor(ws.repo_root, provider, yes=yes, demo=demo)
     _preflight(agents.SUPERVISOR, provider, ws.repo_root)
     _trust_codex_hook(ws.repo_root)
@@ -474,14 +488,12 @@ def _trust_codex_hook(repo_root: str) -> None:
     hook if it isn't yet (or brindle moved), and say so in one line, so Codex
     workers follow the policy from their first launch. A trust the person
     removed stays removed; `brindle doctor` points at it."""
-    import shutil
-
     from brindle import codex_hook
-    from brindle.providers import codex_binary
+    from brindle.providers import codex_binary, which_cli
 
     try:
         binary = codex_binary()
-        if not codex_hook.policy_on(repo_root) or not (shutil.which(binary) or os.path.isfile(binary)):
+        if not codex_hook.policy_on(repo_root) or not (which_cli(binary) or os.path.isfile(binary)):
             return
         command = codex_hook.hook_command()
         before = codex_hook.status(command)
@@ -562,12 +574,21 @@ def _running_session(db: DB, ws: Workspace):
     return live[0] if live else None
 
 
-def _ask_about_running(running) -> str:
+def _ask_about_running(running, wanted: Optional[str] = None) -> str:
+    """Open, branch off or pause the session running here. ``wanted`` is the
+    CLI asked for with -s: when the running session is on another one,
+    opening it wouldn't give that, so the default is to start fresh."""
     import click
 
+    from brindle import picker
+
+    differs = bool(wanted) and wanted != picker.PICK and wanted != running.provider
     typer.echo(f"A brindle session is already running here ({running.id}).")
+    if differs:
+        typer.echo(f"It runs on {running.provider}, not {wanted}; opening it keeps {running.provider}.")
     typer.echo("  [o] open it   [n] new session in its own worktree   [p] pause it and start fresh")
-    return typer.prompt("Which", type=click.Choice(["o", "n", "p"]), default="o", show_choices=False)
+    return typer.prompt("Which", type=click.Choice(["o", "n", "p"]), default="p" if differs else "o",
+                        show_choices=False)
 
 
 def _session_worktree(db: DB, ws: Workspace) -> Workspace:
@@ -874,6 +895,8 @@ def default(
 ) -> None:
     """Bare `brindle`: a fresh supervisor chat here (a scratch session outside git)."""
     provider = provider or provider_alias
+    global _group_supervisor
+    _group_supervisor = provider if ctx.invoked_subcommand else None   # `-s codex start`
     if show_version:
         from brindle import __version__
 
@@ -888,6 +911,9 @@ def default(
             legacy_root = None
         legacy.warn_once(legacy_root)
         if cont:
+            if provider:
+                _fail("--continue resumes the session on the CLI it had; drop -s, "
+                      "or run `brindle -s <cli>` to start fresh")
             continue_cmd(session_id=None, attach=True)
         else:
             start(prompt=None, provider=provider, attach=True, watch=True,

{brindle-0.3.23 → brindle-0.3.24}/src/brindle/cloud_login.py

@@ -131,6 +131,30 @@ def _aws(env: Mapping[str, str], home: Path, now: float) -> LoginStatus:
     return _from_expiry(expires, refresh, now, "no AWS SSO login found for this profile")
 
 
+def run_bounded(argv: list[str], *, capture_output: bool = True, text: bool = True,
+                timeout: float = CLI_TIMEOUT, env=None) -> subprocess.CompletedProcess:
+    """``subprocess.run`` for a cloud CLI that leaves nothing behind: the CLI
+    gets no terminal and its own process group, and a timeout ends the whole
+    group (gcloud is a wrapper around python, which may hold a local auth
+    server and its port), not just the wrapper."""
+    with subprocess.Popen(argv, stdin=subprocess.DEVNULL, stdout=subprocess.PIPE,
+                          stderr=subprocess.PIPE, text=text, env=env,
+                          start_new_session=True) as proc:
+        try:
+            out, err = proc.communicate(timeout=timeout)
+        except BaseException:
+            try:
+                os.killpg(proc.pid, signal.SIGKILL)
+            except OSError:
+                proc.kill()
+            raise      # Popen's exit reaps the wrapper
+        try:    # a server the CLI left running (trade-off: the group id could in theory
+            os.killpg(proc.pid, signal.SIGKILL)    # be reused once the group is empty)
+        except OSError:
+            pass
+        return subprocess.CompletedProcess(argv, proc.returncode, out, err)
+
+
 def _full_env(env: Mapping[str, str] | None) -> dict[str, str] | None:
     """The environment for a CLI call: the supplied one over the ambient one,
     or None (inherit) when the caller supplied none."""
@@ -203,7 +227,7 @@ def _google(run, env, now: float, expiry) -> LoginStatus:
 
 def status(provider: str | None = None, *, env: Mapping[str, str] | None = None,
            home: str | Path | None = None, now: float | None = None,
-           run=subprocess.run, expiry=tokeninfo_expiry) -> LoginStatus:
+           run=run_bounded, expiry=tokeninfo_expiry) -> LoginStatus:
     """The login state for ``provider`` (bedrock, vertex or foundry; by default
     the one the environment's ``CLAUDE_CODE_USE_*`` flag selects)."""
     supplied = env
@@ -222,7 +246,7 @@ def status(provider: str | None = None, *, env: Mapping[str, str] | None = None,
 
 def refresh(provider: str | None = None, *, env: Mapping[str, str] | None = None,
             home: str | Path | None = None, now: float | None = None,
-            run=subprocess.run, expiry=tokeninfo_expiry) -> LoginStatus:
+            run=run_bounded, expiry=tokeninfo_expiry) -> LoginStatus:
     """Renew the login without the person where the CLI can, and return the
     status after. Asking gcloud or az for an access token (as ``status`` does)
     renews it from the stored refresh token; the AWS CLI renews an SSO token
@@ -417,8 +441,8 @@ def _dead_at(last: dict, running: bool, now: float) -> float | None:
 
 def sign_in(provider: str | None = None, *, env: Mapping[str, str] | None = None,
             home: str | Path | None = None, now: float | None = None,
-            last_input: float | None = None, run=subprocess.run, expiry=tokeninfo_expiry,
-            popen=None, kill=None, platform: str | None = None) -> str:
+            last_input: float | None = None, run=run_bounded, expiry=tokeninfo_expiry,
+            popen=None, kill=None, platform: str | None = None, which=None) -> str:
     """Open the browser sign-in a lapsed login needs: one tab machine-wide,
     when the person is there to use it.
 
@@ -454,10 +478,17 @@ def sign_in(provider: str | None = None, *, env: Mapping[str, str] | None = None
         last = lg.read()
         running = not _locked(fd)
         this_lapse = last.get("lapse") == lg.fingerprint() and "opened_at" in last
+        ended = False
         if this_lapse:
             dead_at = _dead_at(last, running, now)
             if dead_at is None:
                 return "waiting"
+            if running and isinstance(last.get("pid"), int):
+                try:    # past TAB_LIFE its code is useless: don't leave its auth server up
+                    (kill or _end_signin)(last["pid"])
+                except OSError:
+                    pass
+                ended = True
             if not running and "dead_at" not in last:
                 lg.write({**last, "dead_at": dead_at})   # we hold the lock
             floor = float(last["opened_at"]) + REOPEN_FLOOR
@@ -470,7 +501,7 @@ def sign_in(provider: str | None = None, *, env: Mapping[str, str] | None = None
         if not s.expired or not s.refresh_cmd:
             return "no lapse"
         if running:     # a dead tab, or one left from an earlier lapse: end it, take its lock
-            if isinstance(last.get("pid"), int):
+            if isinstance(last.get("pid"), int) and not ended:
                 try:
                     (kill or _end_signin)(last["pid"])
                 except OSError:
@@ -480,13 +511,20 @@ def sign_in(provider: str | None = None, *, env: Mapping[str, str] | None = None
                 if time.monotonic() > deadline:
                     return "waiting"
                 time.sleep(0.1)
+        child_env = _full_env(env)
         if not _browser_here(lg.env, sys.platform if platform is None else platform):
-            return "manual"
+            # WSL2 has no Linux browser, but the Windows one can open the URL.
+            from brindle import providers
+
+            opener = None if lg.env.get("SSH_CONNECTION") or lg.env.get("SSH_TTY") else providers.windows_browser(which)
+            if not opener:
+                return "manual"
+            child_env = {**(os.environ if child_env is None else child_env), "BROWSER": opener}
         try:
             # The child inherits the locked descriptor: the lock is held until
             # the sign-in exits, however long the person takes.
             proc = (popen or subprocess.Popen)(
-                shlex.split(s.refresh_cmd), env=_full_env(env), stdin=subprocess.DEVNULL,
+                shlex.split(s.refresh_cmd), env=child_env, stdin=subprocess.DEVNULL,
                 stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL,
                 start_new_session=True, pass_fds=(fd,))
         except OSError:

{brindle-0.3.23 → brindle-0.3.24}/src/brindle/company_identity.py

@@ -43,6 +43,7 @@ CACHE_SECONDS = 30.0
 LAUNCH_CACHE_SECONDS = 300.0
 LAUNCH_CACHE_FILE = "identity-launch-cache.json"
 PROBE_TIMEOUT = 20.0
+RETRY_FACTOR = 3
 PERSONAL_PLANS = ("free", "pro", "max")
 
 # Under an enforced company identity (Enterprise), what can pick the account a
@@ -251,6 +252,8 @@ def _probe(argv: list[str], cache: bool = True) -> tuple[int, str] | None:
     if hit and now - hit[0] < CACHE_SECONDS:
         return hit[1]
     code, out = company_login.run_cmd(argv, PROBE_TIMEOUT)
+    if code == 124:     # a healthy CLI can miss the timeout on a loaded machine: once more, longer
+        code, out = company_login.run_cmd(argv, PROBE_TIMEOUT * RETRY_FACTOR)
     if code in (124, 127):
         return None
     _cache[key] = (now, (code, out))
@@ -279,7 +282,7 @@ class Identity:
 
 
 def _unknown(provider: str, tool: str, why: str = "", exe: str = "") -> Identity:
-    install = company_login.INSTALL.get(tool)
+    install = company_login.install_hint(tool) if tool in company_login.INSTALL else None
     if why:
         return Identity(provider, f"{tool}: {why}", determined=False)
     if company_login.which(exe or tool):

{brindle-0.3.23 → brindle-0.3.24}/src/brindle/company_login.py

@@ -18,6 +18,7 @@ import os
 import re
 import shutil
 import subprocess
+import sys
 import tempfile
 from pathlib import Path
 from typing import Callable
@@ -38,6 +39,28 @@ INSTALL = {
     "codex": "npm install -g @openai/codex",
 }
 
+# What to do instead on Linux (and WSL), where there is no brew and a global
+# npm install into a root-owned prefix fails with EACCES. INSTALL stays the
+# command brindle itself runs.
+NPM_PREFIX_NOTE = "on Linux, if that fails with EACCES: `npm config set prefix ~/.local`, then retry (no sudo)"
+INSTALL_LINUX = {
+    "aws": "Linux: https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html "
+           "(or `sudo snap install aws-cli --classic`)",
+    "gcloud": "Linux: `sudo snap install google-cloud-cli --classic` (or https://cloud.google.com/sdk/docs/install)",
+    "az": "Linux: `curl -sL https://aka.ms/InstallAzureCLIDeb | sudo bash` "
+          "(https://learn.microsoft.com/cli/azure/install-azure-cli-linux)",
+    "claude": NPM_PREFIX_NOTE,
+    "codex": NPM_PREFIX_NOTE,
+}
+
+
+def install_hint(tool: str) -> str:
+    """How to install ``tool``, with the Linux alternative appended on Linux."""
+    hint = INSTALL[tool]
+    if sys.platform.startswith("linux"):
+        hint += f"  [{INSTALL_LINUX[tool]}]"
+    return hint
+
 
 def which(name: str) -> str | None:
     return shutil.which(name)
@@ -50,7 +73,7 @@ def run_cmd(argv: list[str], timeout: float = CHECK_TIMEOUT, interactive: bool =
     can't run or times out is returncode 127 or 124."""
     try:
         if interactive:
-            proc = subprocess.run(argv, timeout=timeout, check=False)
+            proc = subprocess.run(argv, timeout=timeout, check=False, env=env)
             return proc.returncode, ""
         # Never hand a probe the terminal: `claude` turns newline translation
         # back on when it exits, which shifts the curses sidebar's drawing.
@@ -274,7 +297,7 @@ class Login:
     def _need(self, tool: str) -> bool:
         if which(tool):
             return True
-        self.say(f"{tool} isn't installed; install it with: {INSTALL[tool]}")
+        self.say(f"{tool} isn't installed; install it with: {install_hint(tool)}")
         return False
 
     def _ensure(self, tool: str, check: list[str], login: list[str], what: str) -> bool:
@@ -402,7 +425,7 @@ class Login:
         binary = which("claude")
         env = {**os.environ, **claude_env(self.org_id, c)}
         if models and not binary:
-            self.say(f"claude isn't installed; couldn't check model access (install: {INSTALL['claude']})")
+            self.say(f"claude isn't installed; couldn't check model access (install: {install_hint('claude')})")
             return False
         # Probe from an empty directory: a repo's own .claude settings and hooks
         # must not run while we sign in.

{brindle-0.3.23 → brindle-0.3.24}/src/brindle/cull.py

@@ -49,7 +49,7 @@ from brindle.db import DB, Agent, Workspace
 from brindle.pro import route_health
 
 # An agent this new may not have its window recorded yet.
-LAUNCH_GRACE = 60.0
+LAUNCH_GRACE = agents.LAUNCH_GRACE
 # How long a message waits for its normal delivery (a hook, the start-up
 # flush) before a sweep retries it.
 FLUSH_RETRY_AFTER = 30.0
@@ -431,7 +431,9 @@ def note_reported_stuck(db: DB, now: float, panes: dict[str, bool]) -> list[str]
     """Tell each supervisor, once per spell, about a worker that reported but
     whose work went nowhere: its branch waits in the pipeline for a review no
     reviewer is doing (none running, no verdict for its commit) for
-    UNPICKED_AFTER seconds, or twice the repo's checks if they take longer;
+    UNPICKED_AFTER seconds, or twice the repo's checks if they take longer
+    (once nothing checks it either, the review is first started again: see
+    pipeline.restart_review);
     or it's sitting idle with brindle messages it hasn't taken for
     UNDELIVERED_AFTER seconds. Nobody else would notice either: the
     supervisor waits for a message that never comes."""
@@ -467,10 +469,16 @@ def note_reported_stuck(db: DB, now: float, panes: dict[str, bool]) -> list[str]
             # later reviewer's start (a fallback review, say).
             reviewers = [r for r in db.list_agents(ws.id) if r.mode == "review"]
             since = max([a.reviewing_since] + [r.created_at for r in reviewers])
-            if (now - since < max(UNPICKED_AFTER, 2 * wait) or db.latest_review(ws.id, head)
+            if (now - since < pipeline.RESTART_REVIEW_AFTER or db.latest_review(ws.id, head)
                     or any(r.dismissed_at is None and r.status not in ("paused", "done")
                            and agents.is_alive(r, panes) for r in reviewers)):
                 continue
+            # Its check run died (#186, #190): start it again before asking anyone.
+            if pipeline.restart_review(db, a, ws, since):
+                done.append(f"restarted the review of `{ws.branch}`, which nothing was working on")
+                continue
+            if now - since < max(UNPICKED_AFTER, 2 * wait):
+                continue
             body = (f"Worker {a.id} reported on {where}, and for {int((now - since) // 60)} min no "
                     f"reviewer has been running and its commit {head[:8]} has had no verdict. Call "
                     f"request_review(\"{ws.id}\") to get it reviewed.")

{brindle-0.3.23 → brindle-0.3.24}/src/brindle/db.py

@@ -69,7 +69,9 @@ CREATE TABLE IF NOT EXISTS agents (
     tmux_server TEXT,              -- the private tmux server (BRINDLE_TMUX_SOCKET) its window is on; NULL: the default server
     reopened_at REAL,              -- when a dead reviewer's session was reopened once (pipeline.on_reviewer_unreported)
     hooks_off TEXT,                -- why its CLI runs none of brindle's hooks, shown on its sidebar row (agents.screen_status)
-    reviewing_since REAL           -- when its last report put its branch in review (pipeline.on_report)
+    reviewing_since REAL,          -- when its last report put its branch in review (pipeline.on_report)
+    review_restarted REAL,         -- the wait in review whose dead check run was started again (pipeline.restart_review)
+    merge_failed TEXT              -- why the pipeline couldn't merge its approved branch (pipeline.review_state)
 );
 CREATE TABLE IF NOT EXISTS inbox (
     id INTEGER PRIMARY KEY AUTOINCREMENT,
@@ -464,6 +466,8 @@ class Agent:
     reopened_at: float | None = None
     hooks_off: str | None = None       # why its CLI runs none of brindle's hooks (agents.screen_status)
     reviewing_since: float | None = None   # when its last report put its branch in review (pipeline.on_report)
+    review_restarted: float | None = None  # the wait in review whose review was started again (pipeline.restart_review)
+    merge_failed: str | None = None        # why the pipeline couldn't merge its approved branch (pipeline.review_state)
 
 
 @dataclass
@@ -712,7 +716,8 @@ class DB:
         for col, kind in (("plan_first", "INTEGER"), ("plan_state", "TEXT"),
                           ("tmux_server", "TEXT"), ("stop_reminded_at", "REAL"),
                           ("reopened_at", "REAL"), ("hooks_off", "TEXT"),
-                          ("reviewing_since", "REAL")):
+                          ("reviewing_since", "REAL"), ("review_restarted", "REAL"),
+                          ("merge_failed", "TEXT")):
             if col not in cols:
                 self.conn.execute(f"ALTER TABLE agents ADD COLUMN {col} {kind}")
         task_cols = {r["name"] for r in self.conn.execute("PRAGMA table_info(tasks)")}