brindle 0.3.22__tar.gz → 0.3.23__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: brindle
-Version: 0.3.22
+Version: 0.3.23
 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.22`). A session started before an upgrade keeps
+session shows it too (`brindle 0.3.23`). A session started before an upgrade keeps
 running the old code, and shows the old number, until you restart it.
 
 ## Quick start
@@ -562,7 +562,7 @@ Autopilot, merge gates and cleanup:
 | `pre_commit` | `true` | run [pre-commit](https://pre-commit.com) over the branch, if the repo uses it |
 | `max_agents` | `4` | workers running at once per session (`0`: no cap) |
 | `check_timeout` | `900` | seconds each check may take |
-| `check_concurrency` | `4` | check runs at once on this machine, across branches; the rest wait their turn (`0`: no cap). A run far past its last duration is reported to the supervisor |
+| `check_concurrency` | half the logical cores, at least 2, at most 6 and 2 GB of RAM per run | check runs at once on this machine, across branches; the rest wait their turn (`0`: no cap). A run far past its last duration is reported to the supervisor |
 | `fable_escalation` | on, unless the worker runs on a cloud account (Bedrock, Vertex or Foundry) | retry a failed heavy task once on `developer-heavy` before handing it to you; `true` turns it on for a cloud account, `false` off |
 | `usage_limit` | `90` | autopilot stops pushing on at this % of your Claude usage limit |
 | `limit_cooldown_minutes` | `300` for Antigravity | how long a provider that hit its limit counts as unavailable |
@@ -1844,6 +1844,13 @@ in the same checkout keeps it running for the new one.
 
 Then a supervisor can `assign` a task to `developer-local`, or the repo config
 can make the free model the reviewer: `"review_profile": "reviewer-local"`.
+When the local model isn't served (Ollama isn't running, or the model isn't
+pulled), the worker starts as the profile's `fallback:` instead, and is recorded
+as that profile: `developer-light` (Haiku) for `developer-local`, `reviewer` for
+`reviewer-local`. A native worker on a hosted model that refuses a request
+retries it on `developer-local`'s model, when that is served on this machine or
+the private network, and keeps the rest of the conversation there; the transcript
+records which model gave each reply.
 Other endpoints, same fields:
 
 | Backend | `api` | `base_url` | Notes |

{brindle-0.3.22 → brindle-0.3.23}/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.22`). A session started before an upgrade keeps
+session shows it too (`brindle 0.3.23`). A session started before an upgrade keeps
 running the old code, and shows the old number, until you restart it.
 
 ## Quick start
@@ -531,7 +531,7 @@ Autopilot, merge gates and cleanup:
 | `pre_commit` | `true` | run [pre-commit](https://pre-commit.com) over the branch, if the repo uses it |
 | `max_agents` | `4` | workers running at once per session (`0`: no cap) |
 | `check_timeout` | `900` | seconds each check may take |
-| `check_concurrency` | `4` | check runs at once on this machine, across branches; the rest wait their turn (`0`: no cap). A run far past its last duration is reported to the supervisor |
+| `check_concurrency` | half the logical cores, at least 2, at most 6 and 2 GB of RAM per run | check runs at once on this machine, across branches; the rest wait their turn (`0`: no cap). A run far past its last duration is reported to the supervisor |
 | `fable_escalation` | on, unless the worker runs on a cloud account (Bedrock, Vertex or Foundry) | retry a failed heavy task once on `developer-heavy` before handing it to you; `true` turns it on for a cloud account, `false` off |
 | `usage_limit` | `90` | autopilot stops pushing on at this % of your Claude usage limit |
 | `limit_cooldown_minutes` | `300` for Antigravity | how long a provider that hit its limit counts as unavailable |
@@ -1813,6 +1813,13 @@ in the same checkout keeps it running for the new one.
 
 Then a supervisor can `assign` a task to `developer-local`, or the repo config
 can make the free model the reviewer: `"review_profile": "reviewer-local"`.
+When the local model isn't served (Ollama isn't running, or the model isn't
+pulled), the worker starts as the profile's `fallback:` instead, and is recorded
+as that profile: `developer-light` (Haiku) for `developer-local`, `reviewer` for
+`reviewer-local`. A native worker on a hosted model that refuses a request
+retries it on `developer-local`'s model, when that is served on this machine or
+the private network, and keeps the rest of the conversation there; the transcript
+records which model gave each reply.
 Other endpoints, same fields:
 
 | Backend | `api` | `base_url` | Notes |

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

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

@@ -26,7 +26,7 @@ from brindle.config import RepoConfig
 from brindle.db import DB, Agent, Workspace
 from brindle.model_availability import ModelAvailabilityChecker, PROVISIONING_TIMEOUT, provisioning_context
 from brindle.pro import route_health
-from brindle.profiles import load_profile, missing_add_dirs
+from brindle.profiles import load_profile, local_fallback, missing_add_dirs
 from brindle.providers import LaunchContext, get_provider, signed_out, unusable
 from brindle.sidebar_follow import (
     SIDEBAR_COLUMNS,
@@ -336,6 +336,9 @@ def spawn(
 
     identity_lock.ensure_workspace(db, ws)   # no new agent in another identity's worktree
     profile = load_profile(profile_name, ws.repo_root)
+    hosted = local_fallback(profile, ws.repo_root)   # its local model isn't up
+    if hosted:
+        profile_name, profile = hosted, load_profile(hosted, ws.repo_root)
     provider = get_provider(provider_name or profile.provider)
     agent_id = new_id()
     # Headless is a Claude Code mode; other CLIs ignore the profile field.
@@ -1462,7 +1465,9 @@ def one_line(db: DB, message_id: int, body: str, sender_id: str | None) -> str:
         who = f"{sender.profile} {sender_id}" if sender else sender_id
     else:
         who = "brindle"
-    head = first_line(body, 300)
+    # A stuck-worker notice (cull.note_stuck) carries the prompt it waits on in
+    # its first line, which has to arrive whole.
+    head = first_line(body, 1500 if "has been waiting on a prompt for" in body[:200] else 300)
     if not sender_id:
         head = head.removeprefix("[brindle] ")  # the sender tag already says it
     return (f"[{who}] {head} "
@@ -1982,28 +1987,30 @@ def submit_review(db: DB, caller_id: str, approved: bool, summary: str) -> str:
         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."
+    # whatever the verdict set off is 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 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."
+        return "Your review was already recorded. You're done."
+    # Recorded without the branch's merge lock: a merge holds it while the
+    # repo's checks run, for minutes, and a verdict waiting on it left the
+    # reviewer's call hanging until its CLI gave up on it, never recorded.
+    # Acting on the verdict (finish_review) takes the lock, apart from the
+    # reviewer, and finds whatever a merge in progress did: a second
+    # reviewer's verdict for a branch that merged meanwhile is dropped there.
+    gone = "The branch is already merged or removed. You're done."
+    if db.get_workspace(ws.id) is None or not os.path.isdir(ws.path):
+        close_later(caller_id)
+        return gone
+    try:
         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"
-        db.set_result(caller.id, _review_text(ws, sha, approved, summary))
+    except git.GitError:   # removed just now
+        close_later(caller_id)
+        return gone
+    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"
+    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."
 
@@ -2273,14 +2280,12 @@ def default_review_profile(cfg: RepoConfig, worker: Agent | None, db: DB | None
 def _local_reviewer_available() -> bool:
     """Whether the built-in ``reviewer-local`` profile's model is served
     right now. Any failure counts as not available."""
-    try:
-        from brindle.native import runner
+    from brindle.native import runner
 
-        endpoint = runner.endpoint_for(load_profile("reviewer-local"))
-        ok, detail = runner.probe(endpoint, timeout=1.0)
+    try:
+        return runner.served(load_profile("reviewer-local"))
     except Exception:
         return False
-    return bool(ok) and "is available" in detail
 
 
 def _review_kill_switch(ws: Workspace) -> None:
@@ -2397,30 +2402,45 @@ def expected_check_wait(db: DB, ws: Workspace, cfg: RepoConfig) -> float | None:
     return total if cfg.checks else None
 
 
+MOVED_RETRIES = 2   # check runs a branch that keeps moving under them gets again (review_after_checks)
+
+
 def review_after_checks(db: DB, caller_id: str | None, ws: Workspace, profile: str | None = None,
                         focus: str | None = None, cfg: RepoConfig | None = None) -> Agent | None:
     """Run ``cfg.checks`` for ``ws`` (through ``gates.check_summary``: its
     lock and the by-sha cache, so a result a worker's report already warmed
     is instant), then start the reviewer with the results in its prompt.
     Meant to run from a detached process, which outlives the call that
-    started it. Gives up quietly when the branch moves on (the new commit
-    gets its own review), the workspace is gone, or a reviewer is already at
-    work on this commit. Raises ``AgentError`` when the reviewer can't
+    started it. Gives up quietly when the workspace is gone, a reviewer is
+    already at work on this commit, or the branch moves on to a commit a new
+    report hands to a run of its own. A piped branch that moves on without
+    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."""
-    from brindle import gates
+    from brindle import gates, pipeline
     from brindle.config import load_repo_config
 
     cfg = cfg or load_repo_config(ws.repo_root)
-    sha = gates.head(ws)
-    if _live_reviewer(db, ws, sha, profile):
-        return None
-    try:
-        summary = gates.check_summary(db, ws, cfg, cancel=lambda: gates.head(ws) != sha)
-    except gates.Abandoned:
-        return 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 or gates.head(ws) != sha:
+    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
     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
@@ -3322,7 +3342,9 @@ def tell_parent_unreported(db: DB, agent: Agent) -> bool:
     if agent.mode == "review" and ws is not None and os.path.isdir(ws.path):
         from brindle import gates
 
-        if db.latest_review(ws.id, gates.head(ws)):
+        # Its own verdict only: another reviewer's (a second review's) says
+        # nothing about whether this one's call got through.
+        if any(r.reviewer_id == agent.id for r in db.reviews_at(ws.id, gates.head(ws))):
             return False  # its verdict for the current commit is already recorded
     if agent.unreported_noted:
         return False  # the supervisor was told about this stop; cleared once it resumes

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

@@ -54,6 +54,7 @@ log = logging.getLogger(__name__)
 GOALS_FILE = "goals.md"
 GOALS_DIR = "goals"          # .brindle/goals/<session id>.md: each session's own goal
 MAX_NUDGES = 3
+NUDGE_BACKOFF = 900.0        # seconds before the same reminder is repeated when nothing has changed
 MAX_GOAL_CHARS = 4000        # Claude Code's limit for a /goal condition
 OUTPUT_TAIL_LINES = 30
 
@@ -1817,6 +1818,8 @@ def on_stop(db: DB, agent: Agent, payload: dict) -> dict | None:
 
     if login_pause.paused(db, agent.id):
         return None  # only the person can renew the login; a nudge would just fail
+    if proposing(ap):
+        return None  # brindle's own dialog is asking the user to approve checks
     if ap.state == "auditing":
         if ap.auditor_id:
             auditor = db.get_agent(ap.auditor_id)
@@ -1856,12 +1859,16 @@ def on_stop(db: DB, agent: Agent, payload: dict) -> dict | None:
         # One reminder per step: never counts toward stalling.
         db.update_autopilot(agent.id, nudges=0, nudged_at=ap.progress)
         return {"decision": "block", "reason": nudge(db, ap, cfg, working, stalled)}
+    now = time.time()
+    if (ap.nudged_at == ap.progress and ap.nudged_time is not None
+            and now - ap.nudged_time < NUDGE_BACKOFF):
+        return None  # (#177) already reminded since the last step: it's legitimately waiting
     nudges = ap.nudges if ap.nudged_at == ap.progress else 0
     if nudges >= MAX_NUDGES:
         db.update_autopilot(agent.id, state="stalled", nudges=0,
                             note=f"no progress after {MAX_NUDGES} reminders to keep going")
         return None
-    db.update_autopilot(agent.id, nudges=nudges + 1, nudged_at=ap.progress)
+    db.update_autopilot(agent.id, nudges=nudges + 1, nudged_at=ap.progress, nudged_time=now)
     return {"decision": "block", "reason": nudge(db, ap, cfg, working, stalled)}
 
 
@@ -1911,12 +1918,112 @@ def nudge(db: DB, ap: Autopilot, cfg: RepoConfig,
 
 
 NO_CHECKS = """- This repo has no `checks` in .brindle/config.json, so nothing verifies a
-  branch before it merges. Before the first `assign`, propose a check command
-  to the user{suggestion}, and once they agree add it to `checks` in
-  .brindle/config.json (create the file if needed) and commit it.
+  branch before it merges. Before the first `assign`, call `add_checks` with
+  the check command you propose{suggestion}. brindle itself asks the user to
+  approve it (and to allow its commands in .claude/settings.local.json) and
+  writes what they accept; don't ask them yourself. Then commit
+  .brindle/config.json.
 """
 
 
+PROPOSAL_TTL = 30 * 60   # seconds a check proposal may hold autopilot (see proposing)
+
+
+SAFE_ALLOW = re.compile(r"[A-Za-z0-9_./ =,@+-]+")   # no wildcard, quote, $, &, redirect or newline
+# Programs whose only job is checking code. Exact, case-sensitive matches: anything
+# else (wrappers, shells, package runners, interpreters) is refused.
+CHECK_PROGRAMS = {"pytest", "ruff", "mypy", "shellcheck", "eslint", "tsc",
+                  "flake8", "pyright", "golangci-lint"}
+# Toolchains run code through many subcommands (go run, cargo install, ...): only these.
+CHECK_SUBCOMMANDS = {"go": {"test", "vet"}, "cargo": {"test", "check", "clippy", "fmt"}}
+# Flags allowed on those subcommands; any other flag can name a program to run (-exec, -toolexec, --config ...).
+HARMLESS_FLAGS = {"-v", "-q", "-race", "--check", "--all-targets", "--workspace"}
+CHECK_MODULES = {"pytest", "mypy", "ruff", "unittest"}   # the only `python -m` targets allowed
+
+
+def _runs_arbitrary(c: str) -> bool:
+    """True unless the command runs a known check program. ``NAME=VALUE`` prefixes
+    and paths are refused; ``uv run`` is looked through to the program it runs."""
+    argv = c.split()
+    if argv[:1] == ["uv"] and argv[1:2] == ["run"]:
+        argv = argv[2:]
+    if not argv or "=" in argv[0] or argv[0] not in {*CHECK_PROGRAMS, *CHECK_SUBCOMMANDS, "python", "python3"}:
+        return True
+    if argv[0] in CHECK_SUBCOMMANDS:
+        return (argv[1:2] == [] or argv[1] not in CHECK_SUBCOMMANDS[argv[0]]
+                or any(a.startswith("-") and a not in HARMLESS_FLAGS for a in argv[2:]))
+    if argv[0] in CHECK_PROGRAMS:
+        return False
+    return argv[1:2] != ["-m"] or argv[2:3] == [] or argv[2] not in CHECK_MODULES
+
+
+def allow_rules(checks: list[str]) -> tuple[list[str], str | None]:
+    """One narrow Bash allow rule per command in ``checks``, or none and why."""
+    commands = [c.strip() for check in checks for c in re.split(r"&&|\|\||;|\|", check)]
+    unsafe = [c for c in commands if c and (
+        not SAFE_ALLOW.fullmatch(c) or _runs_arbitrary(c))]
+    if unsafe:
+        return [], (f"{unsafe[0]!r} has a wildcard, substitution, redirect or a binary "
+                    "that runs arbitrary code")
+    return list(dict.fromkeys(f"Bash({c})" for c in commands if c)), None
+
+
+def propose_checks(db: DB, root_id: str, checks: list[str]) -> tuple[str, list[str]]:
+    """Record ``checks`` as awaiting the user's answer in brindle's dialog (no
+    nudge meanwhile, see on_stop). Returns the dialog's text and the allow
+    rules it offers."""
+    rules, refusal = allow_rules(checks)
+    db.update_autopilot(root_id, proposal=json.dumps(
+        {"checks": checks, "rules": rules, "at": time.time()}))
+    text = ("brindle: run these checks on every branch before it merges "
+            "(saved to .brindle/config.json)?\n" + "\n".join(f"  {c}" for c in checks))
+    if rules:
+        text += ("\n\nAlso allow their commands without a permission prompt "
+                 "(.claude/settings.local.json):\n" + "\n".join(f"  {r}" for r in rules))
+    else:
+        text += f"\n\nbrindle won't offer to allow their commands: {refusal}."
+    return text, rules
+
+
+def proposing(ap: Autopilot) -> bool:
+    """A check proposal is waiting on the user. One older than PROPOSAL_TTL
+    is a dialog whose server died: it no longer holds autopilot."""
+    try:
+        at = float(json.loads(ap.proposal or "{}").get("at") or 0)
+    except (ValueError, TypeError, AttributeError):
+        return False
+    return time.time() - at < PROPOSAL_TTL
+
+
+def add_checks(repo_root: str, checks: list[str], allow: bool = False) -> str:
+    """Add approved ``checks`` to .brindle/config.json and, with ``allow``, one
+    narrow Bash allow rule per command in them to .claude/settings.local.json."""
+    from brindle.config import CONFIG_FILE, _read_json
+
+    root = Path(config_root(repo_root))
+    path = root / CONFIG_DIR / CONFIG_FILE
+    data = _read_json(path)
+    data["checks"] = [*(c for c in data.get("checks") or [] if c not in checks), *checks]
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text(json.dumps(data, indent=2) + "\n", encoding="utf-8")
+    text = f"Added {len(checks)} check(s) to {path}."
+    if not allow:
+        return text
+    rules, refusal = allow_rules(checks)
+    if refusal:
+        return f"{text} Did not allow any commands: {refusal}. The user can add rules themselves."
+    settings_path = root / ".claude" / "settings.local.json"
+    settings = _read_json(settings_path)
+    perms = settings.setdefault("permissions", {})
+    allowed = perms.setdefault("allow", [])
+    for rule in rules:
+        if rule not in allowed:
+            allowed.append(rule)
+    settings_path.parent.mkdir(parents=True, exist_ok=True)
+    settings_path.write_text(json.dumps(settings, indent=2) + "\n", encoding="utf-8")
+    return f"{text} Allowed their commands in {settings_path}."
+
+
 def guide(cfg: RepoConfig, repo_root: str | None = None) -> str:
     text = GUIDE.format(max_agents=cfg.max_agents or "any number of")
     if repo_root and not cfg.checks:

{brindle-0.3.22 → brindle-0.3.23}/src/brindle/builtin_agents/developer-local.md

@@ -6,6 +6,7 @@ api: openai                        # Ollama's OpenAI-compatible endpoint
 base_url: http://localhost:11434/v1
 model: qwen3-coder:30b             # ollama pull qwen3-coder:30b (19 GB; needs ~24 GB of memory)
 context_tokens: 32k                # Ollama's default window is smaller: set OLLAMA_CONTEXT_LENGTH=40960 for `ollama serve`
+fallback: developer-light          # hosted Haiku, when Ollama isn't running or the model isn't pulled
 permission_mode: acceptEdits       # edits are free; commands need a rule below
 allowed_tools: Bash(git add:*), Bash(git commit:*), Bash(git status:*), Bash(git ls-files:*), Bash(git diff:*), Bash(git log:*), Bash(git show:*), Bash(git rev-parse:*), Bash(git branch:*), Bash(pytest:*), Bash(python -m pytest:*), Bash(python3 -m pytest:*), Bash(python -m unittest:*), Bash(python3 -m unittest:*), Bash(uv run:*), Bash(uv sync:*), Bash(npm test:*), Bash(npm run:*), Bash(npm ci:*), Bash(pnpm test:*), Bash(pnpm run:*), Bash(pnpm install:*), Bash(yarn test:*), Bash(yarn run:*), Bash(cargo build:*), Bash(cargo test:*), Bash(cargo check:*), Bash(cargo clippy:*), Bash(go build:*), Bash(go test:*), Bash(go vet:*), Bash(make:*), Bash(swift build:*), Bash(swift test:*), Bash(ls:*), Bash(pwd), Bash(cat:*), Bash(tail:*), Bash(head:*), Bash(grep:*), Bash(wc:*)
 ---

{brindle-0.3.22 → brindle-0.3.23}/src/brindle/builtin_agents/reviewer-local.md

@@ -6,6 +6,7 @@ api: openai
 base_url: http://localhost:11434/v1
 model: qwen3-coder:30b
 context_tokens: 32k
+fallback: reviewer                 # hosted, when Ollama isn't running or the model isn't pulled
 permission_mode: dontAsk           # nobody watches a reviewer: refuse what allowed_tools doesn't cover
 allowed_tools: Bash(git status:*), Bash(git ls-files:*), Bash(git stash list), Bash(git diff:*), Bash(git log:*), Bash(git show:*), Bash(git merge-base:*), Bash(pytest:*), Bash(python -m pytest:*), Bash(python3 -m pytest:*), Bash(python -m unittest:*), Bash(python3 -m unittest:*), Bash(uv run:*), Bash(npm test:*), Bash(npm run:*), Bash(pnpm test:*), Bash(pnpm run:*), Bash(yarn test:*), Bash(yarn run:*), Bash(cargo test:*), Bash(cargo check:*), Bash(cargo clippy:*), Bash(go test:*), Bash(go vet:*), Bash(make:*), Bash(swift test:*), Bash(ls:*), Bash(pwd), Bash(cat:*), Bash(tail:*), Bash(head:*), Bash(grep:*), Bash(wc:*)
 ---

{brindle-0.3.22 → brindle-0.3.23}/src/brindle/config.py

@@ -30,8 +30,22 @@ def db_path() -> Path:
     return brindle_home() / "brindle.db"
 
 
+WORKTREES_DIR = "worktrees"
+
+
 def worktrees_dir() -> Path:
-    return brindle_home() / "worktrees"
+    """``~/.brindle/worktrees``, where worktrees went before they moved under
+    each repo (see ``worktree_root``). Existing ones there keep working."""
+    return brindle_home() / WORKTREES_DIR
+
+
+def worktree_root(repo_root: str | Path, cfg: RepoConfig | None = None) -> Path:
+    """Where ``repo_root``'s new worktrees go: ``<repo>/.brindle/worktrees``,
+    or the repo's ``worktree_root`` (``~`` expanded; relative to the repo)."""
+    configured = (cfg or load_repo_config(repo_root)).worktree_root
+    if not configured:
+        return Path(repo_root) / CONFIG_DIR / WORKTREES_DIR
+    return Path(repo_root) / os.path.expanduser(configured)
 
 
 def user_profiles_dir() -> Path:
@@ -80,6 +94,7 @@ class RepoConfig:
     copy: list[str] = field(default_factory=list)
     base_branch: str | None = None
     branch_prefix: str = ""
+    worktree_root: str | None = None   # where new worktrees go (None: <repo>/.brindle/worktrees; see worktree_root())
     default_agent: str = "developer"
     fetch: bool = True
     auto_update: bool = False          # upgrade the PyPI tool at session start
@@ -130,6 +145,9 @@ class RepoConfig:
     # already fast). 0 disables the pool.
     pool_size: int | None = None
     add_dirs: list[str] = field(default_factory=list)
+    # Directories outside the worktree that workers may read (not write), e.g. a
+    # gitignored results/ folder in the main checkout.
+    worker_extra_read_dirs: list[str] = field(default_factory=list)
     # Per-worktree Docker services (brindle Pro): [{"name", "preset"?, "image"?, "port"?, "env"?}]
     # -- see brindle.services.
     services: list[dict] = field(default_factory=list)
@@ -199,13 +217,22 @@ def config_root(path: str | Path) -> Path:
     path = Path(path)
     if (path / CONFIG_DIR).is_dir():
         return path
+    main = linked_main(path)
+    return main if main is not None and (main / CONFIG_DIR).is_dir() else path
+
+
+def linked_main(path: str | Path) -> Path | None:
+    """The main checkout of the linked worktree at ``path``, or None when
+    ``path`` isn't one. A linked worktree's ``.git`` is a file saying
+    ``gitdir: <main>/.git/worktrees/<name>``, and that folder's ``commondir``
+    names ``<main>/.git`` (relative to it), so no git process runs."""
+    path = Path(path)
     try:
-        gitdir = Path((path / ".git").read_text(encoding="utf-8").split("gitdir:", 1)[1].strip())
+        gitdir = path / (path / ".git").read_text(encoding="utf-8").split("gitdir:", 1)[1].strip()
         common = (gitdir / (gitdir / "commondir").read_text(encoding="utf-8").strip()).resolve()
-    except (OSError, IndexError):  # not a linked worktree: nothing to discover
-        return path
-    main = common.parent
-    return main if common.name == ".git" and (main / CONFIG_DIR).is_dir() else path
+    except (OSError, IndexError):  # no .git file, or not a worktree's gitdir
+        return None
+    return common.parent if common.name == ".git" else None
 
 
 def _default_permission_policy() -> str:
@@ -219,6 +246,25 @@ def _default_permission_policy() -> str:
         return "off"
 
 
+CHECK_RAM_GB = 2        # RAM budgeted per concurrent check run
+CHECK_CONCURRENCY_CAP = 6
+
+
+def _memory_gb() -> float:
+    try:
+        return os.sysconf("SC_PAGE_SIZE") * os.sysconf("SC_PHYS_PAGES") / 2**30
+    except (ValueError, OSError):
+        return 0.0
+
+
+def host_check_concurrency() -> int:
+    """Check runs at once when the repo doesn't say: half the logical cores and
+    RAM for ``CHECK_RAM_GB`` per run, never below 2 or above the cap (#169)."""
+    cores = os.cpu_count() or 1
+    by_ram = int(_memory_gb() // CHECK_RAM_GB)
+    return max(2, min(cores // 2, by_ram, CHECK_CONCURRENCY_CAP))
+
+
 def load_repo_config(repo_root: str | Path) -> RepoConfig:
     base = config_root(repo_root) / CONFIG_DIR
     shared = _read_json(base / CONFIG_FILE)
@@ -226,10 +272,10 @@ def load_repo_config(repo_root: str | Path) -> RepoConfig:
     user = user_settings()
 
     cfg = RepoConfig()
-    for key in ("setup", "teardown", "copy", "checks", "add_dirs", "protected_paths"):
+    for key in ("setup", "teardown", "copy", "checks", "add_dirs", "worker_extra_read_dirs", "protected_paths"):
         merged = _merge_commands(list(shared.get(key, [])), local.get(key))
         setattr(cfg, key, merged)
-    for key in ("base_branch", "branch_prefix", "default_agent", "fetch", "auto_update", "autopilot", "review",
+    for key in ("base_branch", "branch_prefix", "worktree_root", "default_agent", "fetch", "auto_update", "autopilot", "review",
                 "reviewer", "review_profile", "pre_commit", "max_agents", "check_timeout",
                 "check_concurrency",
                 "usage_limit", "pool_size", "graphify", "stale_after", "pipeline",
@@ -248,6 +294,8 @@ def load_repo_config(repo_root: str | Path) -> RepoConfig:
             if isinstance(rule, str) and rule.strip() and rule.strip() not in rules:
                 rules.append(rule.strip())
     cfg.rules = rules
+    if not any("check_concurrency" in source for source in (local, shared, user)):
+        cfg.check_concurrency = host_check_concurrency()
     if not any("permission_policy" in source for source in (local, shared, user)):
         cfg.permission_policy = _default_permission_policy()
     services = local["services"] if "services" in local else shared.get("services")