brindle 0.1.0__tar.gz → 0.2.0__tar.gz

{brindle-0.1.0 → brindle-0.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: brindle
-Version: 0.1.0
+Version: 0.2.0
 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
@@ -89,7 +89,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.1.0`). A session started before an upgrade keeps
+session shows it too (`brindle 0.2.0`). A session started before an upgrade keeps
 running the old code, and shows the old number, until you restart it.
 
 ## Quick start
@@ -389,12 +389,13 @@ knowing them helps when you tell the supervisor how to work.
 
 | Tool | Used by | |
 |---|---|---|
-| `assign` / `handoff` / `wait_for_worker` | supervisor | start a worker (return now / wait for its result / keep waiting) |
+| `assign` / `handoff` / `wait_for_worker` | supervisor | start a worker (return now / wait for its result / keep waiting); `dry_run=true` on `assign`/`handoff` starts nothing and reports the profile, what each `files` glob matches, overlaps and whether it would queue |
 | `send_message` | any agent | message another agent; delivered when it's idle |
 | `read_messages` | supervisor | read the messages agents and brindle sent you and mark them read; with `message_delivery` `"pull"` (the default) you get a one-line "N new messages" notice instead of each message |
-| `list_agents` / `list_tasks` / `list_agent_profiles` | supervisor | who's running, what's queued, which profiles exist |
+| `list_agents` / `list_tasks` / `list_agent_profiles` | supervisor | who's running, what's queued, which profiles exist; `list_tasks(full=true)` also shows each task's brief and `done_when` |
 | `list_repos` | supervisor | the repos attached to the session (brindle Pro); `repo=<alias>` on `assign`/`handoff` puts a worker there |
 | `cancel_task` | supervisor | cancel a queued task (and its dependents) to re-plan |
+| `requeue` | supervisor | queue a cancelled task again with the same brief, files and profile; `depends_on` replaces its dependencies |
 | `workspace_diff` | supervisor | a worker branch's changes against its base |
 | `request_review` / `submit_review` | supervisor / reviewer | start a reviewer on a branch / record its verdict |
 | `merge_workspace` / `remove_workspace` | supervisor | merge through the gates / delete the worktree |
@@ -437,8 +438,10 @@ count as unknown.
 `brindle cost` prices the last 30 days of history at each model's list price
 (per million tokens: input, output, cache write, cache read), copied from
 Anthropic's and OpenAI's pricing pages and dated; brindle warns when they're
-more than 90 days old. Local models cost $0. A model brindle has no price
-for is shown as unpriced tokens, never guessed. Add or correct prices under
+more than 90 days old. Local models cost $0, and usage on a model known to be
+free reads "Free" (its tokens still count; a mix reads "$1.20 (+40k tokens
+free)"). A model brindle has no price for is shown as unpriced tokens, never
+guessed. Add or correct prices under
 `pricing` in `~/.brindle/config.json` or `.brindle/config.json`:
 
 ```json
@@ -538,7 +541,7 @@ Autopilot, merge gates and cleanup:
 | `protected_paths` | `[]` | paths or globs (`"migrations/"`, `"*.lock"`) whose merge conflicts brindle never hands to a worker to resolve: the branch waits for you instead (see "Conflict-aware merging") |
 | `pool_size` | `1` if `setup` is set, else `0` | pre-built worktrees (checked out, files copied, setup run) kept ready so a new worker doesn't wait on `setup`; `0` disables it |
 | `add_dirs` | `[]` | directories outside the worktree that Claude Code agents may use (`--add-dir`; full tool access, see "Directories outside the workspace") |
-| `local_models` | `false` | `true`: when a native profile points at Ollama on this machine and it isn't running, `brindle` starts `ollama serve` in the background (with the context length the profiles need) and loads their models. Off, brindle uses a server that's already running and never starts or preloads one |
+| `local_models` | `true` | When a native profile points at Ollama on this machine and it isn't running, `brindle` starts `ollama serve` in the background (with the context length the profiles need) and loads their models, then stops it when the last session closes. `false`: brindle uses a server that's already running and never starts or preloads one |
 | `sidebar` | `"left"` | where the dashboard sits in each window: `"left"` of the chat, or `"bottom"` (full-width rows under it) |
 | `delegation` | `"balanced"` | how readily the supervisor hands work to workers. `"conservative"` does most work in its own chat (fewest tokens), `"fast"` splits any multi-part request across parallel workers straight away (quickest, most tokens). `brindle delegation fast` saves it for every repo and session (in `~/.brindle/config.json`; `--repo` for this repo only) and tells a running supervisor |
 | `delete_merged_branches` | `true` | removing a worktree (after a merge, `brindle rm`, `brindle prune`, session cleanup) also deletes its branch once every commit is in its base, so finished branches don't pile up. An unmerged branch is always kept; `false` keeps them all. If GitHub keeps merged PR branches, the first `brindle pr` in a repo offers to turn on its automatic deletion with your `gh` login (repo admins only) |
@@ -742,10 +745,11 @@ how to use them, and the next step to get the rest:
 | Brindle-CI (fixes builds, issues into verified pull requests, validation) | Team | `brindle ci init` |
 | org profile and rule-pack library, pinned so a repo can't loosen it | Team | `brindle account org profiles` |
 | org budgets and protected paths | Team | `budget`, `protected_paths` in your org policy (`brindle account org policy`) |
+| per-member budgets, pause, and admin messages (sidebar "Messages", the bottom bar, `brindle org messages`) | Team | `brindle org messages [--keep]` lists and marks read the notices your admins sent you; a pause refuses new workers and stops running ones |
 | audit log, air-gap | Enterprise | `brindle audit verify`, `"airgap": true` |
 | audit export | Enterprise | `"audit_export"` in `~/.brindle/config.json`, `brindle audit ship` |
 | managed models | Enterprise | `provider_config`, `deny_personal_keys` in your org policy (see "Managed models" below) |
-| wider CI, cost centers, managed rollout | Enterprise | `brindle ci init --host gitlab`, `brindle cost request`, and `min_version`, required packs and the kill switch in your org policy |
+| wider CI, cost centers, managed rollout | Enterprise | `brindle ci init --host gitlab`, `brindle cost request`, and `min_version`, required packs and the kill switch in your org policy; admins can also shut down or throttle a member, role or org remotely (it arrives within about a minute) |
 
 `brindle ci init` checks your plan before it changes anything: it refuses
 without Brindle-CI on the org you're using, and on Pro it sets up only the fix
@@ -1548,9 +1552,9 @@ ollama pull qwen3-coder:30b
 brindle doctor                   # "model qwen3-coder:30b ... is available"
 ```
 
-Run `ollama serve` yourself, or let brindle do it: a 30B model holds about 20 GB
-of GPU memory, so brindle doesn't start or preload one unless you set
-`"local_models": true`. Then, when `brindle` (or `brindle continue`)
+Run `ollama serve` yourself, or let brindle do it, with no setup. A 30B model holds
+about 20 GB of GPU memory, so set `"local_models": false` if you don't want brindle
+to start or preload one. When `brindle` (or `brindle continue`)
 starts and a native profile points at Ollama on this machine that isn't answering,
 brindle starts it in the background with `OLLAMA_CONTEXT_LENGTH` set to the largest
 `context_tokens` any profile asks of it plus room for the reply (40960 for the

{brindle-0.1.0 → brindle-0.2.0}/README.md

@@ -59,7 +59,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.1.0`). A session started before an upgrade keeps
+session shows it too (`brindle 0.2.0`). A session started before an upgrade keeps
 running the old code, and shows the old number, until you restart it.
 
 ## Quick start
@@ -359,12 +359,13 @@ knowing them helps when you tell the supervisor how to work.
 
 | Tool | Used by | |
 |---|---|---|
-| `assign` / `handoff` / `wait_for_worker` | supervisor | start a worker (return now / wait for its result / keep waiting) |
+| `assign` / `handoff` / `wait_for_worker` | supervisor | start a worker (return now / wait for its result / keep waiting); `dry_run=true` on `assign`/`handoff` starts nothing and reports the profile, what each `files` glob matches, overlaps and whether it would queue |
 | `send_message` | any agent | message another agent; delivered when it's idle |
 | `read_messages` | supervisor | read the messages agents and brindle sent you and mark them read; with `message_delivery` `"pull"` (the default) you get a one-line "N new messages" notice instead of each message |
-| `list_agents` / `list_tasks` / `list_agent_profiles` | supervisor | who's running, what's queued, which profiles exist |
+| `list_agents` / `list_tasks` / `list_agent_profiles` | supervisor | who's running, what's queued, which profiles exist; `list_tasks(full=true)` also shows each task's brief and `done_when` |
 | `list_repos` | supervisor | the repos attached to the session (brindle Pro); `repo=<alias>` on `assign`/`handoff` puts a worker there |
 | `cancel_task` | supervisor | cancel a queued task (and its dependents) to re-plan |
+| `requeue` | supervisor | queue a cancelled task again with the same brief, files and profile; `depends_on` replaces its dependencies |
 | `workspace_diff` | supervisor | a worker branch's changes against its base |
 | `request_review` / `submit_review` | supervisor / reviewer | start a reviewer on a branch / record its verdict |
 | `merge_workspace` / `remove_workspace` | supervisor | merge through the gates / delete the worktree |
@@ -407,8 +408,10 @@ count as unknown.
 `brindle cost` prices the last 30 days of history at each model's list price
 (per million tokens: input, output, cache write, cache read), copied from
 Anthropic's and OpenAI's pricing pages and dated; brindle warns when they're
-more than 90 days old. Local models cost $0. A model brindle has no price
-for is shown as unpriced tokens, never guessed. Add or correct prices under
+more than 90 days old. Local models cost $0, and usage on a model known to be
+free reads "Free" (its tokens still count; a mix reads "$1.20 (+40k tokens
+free)"). A model brindle has no price for is shown as unpriced tokens, never
+guessed. Add or correct prices under
 `pricing` in `~/.brindle/config.json` or `.brindle/config.json`:
 
 ```json
@@ -508,7 +511,7 @@ Autopilot, merge gates and cleanup:
 | `protected_paths` | `[]` | paths or globs (`"migrations/"`, `"*.lock"`) whose merge conflicts brindle never hands to a worker to resolve: the branch waits for you instead (see "Conflict-aware merging") |
 | `pool_size` | `1` if `setup` is set, else `0` | pre-built worktrees (checked out, files copied, setup run) kept ready so a new worker doesn't wait on `setup`; `0` disables it |
 | `add_dirs` | `[]` | directories outside the worktree that Claude Code agents may use (`--add-dir`; full tool access, see "Directories outside the workspace") |
-| `local_models` | `false` | `true`: when a native profile points at Ollama on this machine and it isn't running, `brindle` starts `ollama serve` in the background (with the context length the profiles need) and loads their models. Off, brindle uses a server that's already running and never starts or preloads one |
+| `local_models` | `true` | When a native profile points at Ollama on this machine and it isn't running, `brindle` starts `ollama serve` in the background (with the context length the profiles need) and loads their models, then stops it when the last session closes. `false`: brindle uses a server that's already running and never starts or preloads one |
 | `sidebar` | `"left"` | where the dashboard sits in each window: `"left"` of the chat, or `"bottom"` (full-width rows under it) |
 | `delegation` | `"balanced"` | how readily the supervisor hands work to workers. `"conservative"` does most work in its own chat (fewest tokens), `"fast"` splits any multi-part request across parallel workers straight away (quickest, most tokens). `brindle delegation fast` saves it for every repo and session (in `~/.brindle/config.json`; `--repo` for this repo only) and tells a running supervisor |
 | `delete_merged_branches` | `true` | removing a worktree (after a merge, `brindle rm`, `brindle prune`, session cleanup) also deletes its branch once every commit is in its base, so finished branches don't pile up. An unmerged branch is always kept; `false` keeps them all. If GitHub keeps merged PR branches, the first `brindle pr` in a repo offers to turn on its automatic deletion with your `gh` login (repo admins only) |
@@ -712,10 +715,11 @@ how to use them, and the next step to get the rest:
 | Brindle-CI (fixes builds, issues into verified pull requests, validation) | Team | `brindle ci init` |
 | org profile and rule-pack library, pinned so a repo can't loosen it | Team | `brindle account org profiles` |
 | org budgets and protected paths | Team | `budget`, `protected_paths` in your org policy (`brindle account org policy`) |
+| per-member budgets, pause, and admin messages (sidebar "Messages", the bottom bar, `brindle org messages`) | Team | `brindle org messages [--keep]` lists and marks read the notices your admins sent you; a pause refuses new workers and stops running ones |
 | audit log, air-gap | Enterprise | `brindle audit verify`, `"airgap": true` |
 | audit export | Enterprise | `"audit_export"` in `~/.brindle/config.json`, `brindle audit ship` |
 | managed models | Enterprise | `provider_config`, `deny_personal_keys` in your org policy (see "Managed models" below) |
-| wider CI, cost centers, managed rollout | Enterprise | `brindle ci init --host gitlab`, `brindle cost request`, and `min_version`, required packs and the kill switch in your org policy |
+| wider CI, cost centers, managed rollout | Enterprise | `brindle ci init --host gitlab`, `brindle cost request`, and `min_version`, required packs and the kill switch in your org policy; admins can also shut down or throttle a member, role or org remotely (it arrives within about a minute) |
 
 `brindle ci init` checks your plan before it changes anything: it refuses
 without Brindle-CI on the org you're using, and on Pro it sets up only the fix
@@ -1518,9 +1522,9 @@ ollama pull qwen3-coder:30b
 brindle doctor                   # "model qwen3-coder:30b ... is available"
 ```
 
-Run `ollama serve` yourself, or let brindle do it: a 30B model holds about 20 GB
-of GPU memory, so brindle doesn't start or preload one unless you set
-`"local_models": true`. Then, when `brindle` (or `brindle continue`)
+Run `ollama serve` yourself, or let brindle do it, with no setup. A 30B model holds
+about 20 GB of GPU memory, so set `"local_models": false` if you don't want brindle
+to start or preload one. When `brindle` (or `brindle continue`)
 starts and a native profile points at Ollama on this machine that isn't answering,
 brindle starts it in the background with `OLLAMA_CONTEXT_LENGTH` set to the largest
 `context_tokens` any profile asks of it plus room for the reply (40960 for the

{brindle-0.1.0 → brindle-0.2.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "brindle"
-version = "0.1.0"
+version = "0.2.0"
 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"
@@ -49,7 +49,10 @@ audit = "brindle.pro.audit_chain:make"
 audit_export = "brindle.pro.audit_export:make"
 
 [dependency-groups]
-dev = ["pytest>=8"]
+dev = [
+    "pytest>=8",
+    "pytest-xdist>=3.8.0",
+]
 
 [build-system]
 requires = ["hatchling>=1.27"]
@@ -69,3 +72,4 @@ only-include = ["src", "README.md", "LICENSE", "SCHEDULE-A", "pyproject.toml"]
 [tool.pytest.ini_options]
 testpaths = ["tests"]
 pythonpath = ["tests"]
+markers = ["serial: run outside xdist (`pytest -m serial`); the parallel pass skips these"]

{brindle-0.1.0 → brindle-0.2.0}/src/brindle/agents.py

@@ -1358,11 +1358,16 @@ def report_result(db: DB, agent_id: str, result: str, forward: bool = True,
             agent=agent, usage=u, branch=ws.branch, task=agent.task, result=result,
         )
     if u and u.total:
+        free = False
         try:
-            dollars = usage_mod.usage_cost(u, pricing.repo_overrides(ws.repo_root if ws else None))
+            root = ws.repo_root if ws else None
+            extra = pricing.repo_overrides(root)
+            price = pricing.price_for(u.model, extra) or pricing.profile_price(agent.profile, root, extra)
+            dollars = usage_mod.usage_cost(u, extra, fallback=price)
+            free = price == pricing.FREE
         except Exception:  # noqa: BLE001 - a price is an extra too
             dollars = None
-        forwarded = f"{result}\n\n{usage_mod.summary_line(u, dollars)}"
+        forwarded = f"{result}\n\n{usage_mod.summary_line(u, dollars, free)}"
     else:
         forwarded = result
     if ws and agent.mode in ("handoff", "handoff_detached", "assign"):
@@ -1609,6 +1614,7 @@ def delegate(
         start = base if git.branch_exists(caller_ws.repo_root, base) else "HEAD"
         created = workspaces.create(
             db, caller_ws.path, branch, base, fetch=False, start=start,
+            reuse_registered=True,
         )
         if created.setup and not created.setup.ok:
             raise AgentError(f"workspace setup failed:\n{created.setup.log}")

{brindle-0.1.0 → brindle-0.2.0}/src/brindle/autopilot.py

@@ -334,6 +334,30 @@ def sync_goals_file(db: DB, root_id: str) -> None:
         log.exception("brindle: couldn't sync milestone status to goals.md")
 
 
+def clear_finished_goal(db: DB, root_id: str) -> None:
+    """The goal is reached: empty the goals.md it was loaded from (when that
+    file is still this goal's) and clear the session's goal, so the next
+    session doesn't reload a finished goal. Never raises: a file we can't
+    write must not fail the verdict."""
+    try:
+        ap = db.get_autopilot(root_id)
+        if not ap or not ap.goal:
+            return
+        if ap.goals_file:
+            path = Path(ap.goals_file)
+            try:
+                plan = parse_goals(path.read_bytes().decode("utf-8"))
+            except OSError:
+                plan = None
+            if plan is not None and plan.goal == ap.goal:
+                path.write_bytes(b"")
+        db.set_milestones(root_id, [])
+        db.update_autopilot(root_id, goal=None, detail=None, goals_file=None, goal_sha=None,
+                            audit_sha=None, audit_ok=None, auditor_id=None, note=None)
+    except Exception:  # noqa: BLE001
+        log.exception("brindle: couldn't clear the finished goal")
+
+
 # -- sessions ----------------------------------------------------------------
 
 
@@ -729,6 +753,7 @@ def check_milestones(db: DB, root_id: str, ws: Workspace, position: int | None =
             lines.append(f"\nMilestone {m.position} check output:\n{m.output}")
     if done and audit is None:
         lines.append("\nEvery milestone's check passes: the goal is reached. Tell the user.")
+        clear_finished_goal(db, root_id)
     elif done:
         lines.append("\n" + AUDIT_HOLD[audit].format(note=(ap.note if ap else None) or ""))
     return "\n".join(lines)
@@ -853,7 +878,7 @@ def record_audit(db: DB, root_id: str, approved: bool, summary: str) -> str:
     if approved:
         db.update_autopilot(root_id, state="done", note=None, audit_ok=1, auditor_id=None)
         db.bump_progress(root_id)
-        sync_goals_file(db, root_id)
+        clear_finished_goal(db, root_id)
         return (f"[brindle] Completion audit of {sha}: APPROVED. Every milestone passes and the "
                 f"auditor found the goal fully delivered: the goal is reached. Tell the user."
                 f"\n\n{summary}")

{brindle-0.1.0 → brindle-0.2.0}/src/brindle/budget.py

@@ -101,7 +101,8 @@ def org_limits(repo_root: str | None) -> Limits | None:
     spent = p.spend_seat_usd
     if spent is not None and p.spend_month != time.strftime("%Y-%m", time.gmtime()):
         spent = None                      # last month's number
-    lim = Limits(goal_usd=p.budget_goal_usd, month_usd=p.budget_seat_month_usd, seat_spent_usd=spent)
+    lim = Limits(task_usd=p.budget_task_usd, goal_usd=p.budget_goal_usd,
+                 month_usd=p.budget_seat_month_usd, seat_spent_usd=spent)
     return lim if lim.any() else None
 
 
@@ -125,6 +126,7 @@ def limits(cfg, repo_root: str | None = None) -> Limits | None:
         org = Limits(month_usd=0.0, goal_usd=0.0)
     if org is not None:
         lim.org = True
+        lim.task_usd = _tighter(lim.task_usd, org.task_usd)
         lim.goal_usd = _tighter(lim.goal_usd, org.goal_usd)
         lim.month_usd = _tighter(lim.month_usd, org.month_usd)
         lim.seat_spent_usd = org.seat_spent_usd

{brindle-0.1.0 → brindle-0.2.0}/src/brindle/ci_adapters.py

@@ -66,7 +66,7 @@ LOOPBACK = frozenset({"localhost", "127.0.0.1"})
 HOST_RE = re.compile(r"^[a-z0-9]([a-z0-9-]*[a-z0-9])?(\.[a-z0-9]([a-z0-9-]*[a-z0-9])?)*$")
 # A base_url written plainly: scheme, host, optional port, optional plain path.
 BASE_URL_RE = re.compile(r"^(?P<scheme>https?)://(?P<host>[A-Za-z0-9]([A-Za-z0-9-]*[A-Za-z0-9])?"
-                         r"(\.[A-Za-z0-9]([A-Za-z0-9-]*[A-Za-z0-9])?)*)(:[0-9]{1,5})?(/[A-Za-z0-9._~/-]*)?$")
+                         r"(\.[A-Za-z0-9]([A-Za-z0-9-]*[A-Za-z0-9])?)*)(:[0-9]{1,5})?(/[A-Za-z0-9._~/-]*)?\Z")
 # Every known provider credential: what a check must not see, and what a
 # repo-supplied native profile may not point at its own endpoint.
 PROVIDER_KEYS = frozenset((*CLAUDE_API_KEYS, *CLAUDE_SUBSCRIPTION, *CODEX_API_KEYS,

{brindle-0.1.0 → brindle-0.2.0}/src/brindle/ci_client.py

@@ -1139,6 +1139,15 @@ def _run_session(plan: dict, run_token: str, *, repo: str, cwd: str, env: Mutabl
     deadline = started + (plan["limits"]["timeout_min"] + TIMEOUT_MARGIN_MIN) * 60
     final: str | None = None
     event: dict = {"state": "working", "milestones": [], "usage": {}}
+    spent_before = 0.0   # what earlier attempts (before an escalation) cost: the limit is for the whole run
+
+    def over_limit() -> bool:
+        limit = plan.get("budget_usd")
+        if limit is None or usage_usd(event["usage"], cwd) + spent_before < limit:
+            return False
+        say(f"the run has spent the org's {pricing.money(limit)} limit")
+        return True
+
     while final is None:
         sleep(plan["limits"]["heartbeat_s"])
         event = session_event(db, root.id, adapter, cwd=cwd, base_sha=base_sha, branch=branch,
@@ -1151,6 +1160,8 @@ def _run_session(plan: dict, run_token: str, *, repo: str, cwd: str, env: Mutabl
             log.warning("brindle ci: heartbeat failed (%s): %s", e.code, e)
             if clock() > deadline:
                 final = "timeout"
+            elif over_limit():   # the org's limit is checked here, so an unreachable server can't lift it
+                final = "budget"
             continue
         action = answer.get("action")
         if action == "continue":
@@ -1170,6 +1181,8 @@ def _run_session(plan: dict, run_token: str, *, repo: str, cwd: str, env: Mutabl
                     or new["branch"] != branch:
                 raise CIError("the escalation plan is for another run", code="bad_plan")
             adapter.stop(db, root.id)
+            spent_before += usage_usd(event["usage"], cwd)
+            event = {**event, "usage": {}}   # the new supervisor starts its own count
             # An escalation may only tighten the org's limits, never drop or raise them.
             paths = list(dict.fromkeys((plan.get("protected_paths") or []) + (new.get("protected_paths") or [])))
             if paths:
@@ -1183,10 +1196,8 @@ def _run_session(plan: dict, run_token: str, *, repo: str, cwd: str, env: Mutabl
         else:
             raise CIError("the server sent an unknown action", code="bad_response")
         # The org's dollar limit for the run (Team org_budgets), on top of the server's tokens.
-        limit = plan.get("budget_usd")
-        if final is None and limit is not None and usage_usd(event["usage"], cwd) >= limit:
+        if final is None and over_limit():
             final = "budget"
-            say(f"the run has spent the org's {pricing.money(limit)} limit")
     adapter.stop(db, root.id)
     event = session_event(db, root.id, adapter, cwd=cwd, base_sha=base_sha, branch=branch,
                           milestone_ids=[m["id"] for m in plan.get("milestones") or []])

{brindle-0.1.0 → brindle-0.2.0}/src/brindle/cli.py

@@ -92,6 +92,7 @@ def _after_detach(ws: Workspace) -> None:
     if tmux.has_session(ws.tmux_session):
         typer.echo("Detached; everything is still running. Run `brindle` here to reopen.")
         return
+    agents._stop_local_models(DB())  # the Ollama brindle started, if nothing else uses it
     typer.echo("brindle session paused: nothing is running, and all work is saved.")
     typer.echo("  `brindle continue` picks it up where you left off; `brindle` starts fresh.")
     if scratch.is_scratch(ws.path) and not scratch.transferred_to(ws.path):
@@ -385,12 +386,20 @@ def _say_autopilot(db: DB, root_id: str) -> None:
     typer.echo("  `brindle autopilot off` hands the wheel back to you.")
 
 
+def _live_sessions(db: DB, ws: Workspace) -> list:
+    """The live sessions (interactive agents) in this checkout. An agent whose
+    recorded pane id a newer agent has since taken (tmux reuses ids) isn't
+    live: that pane is the newer agent's."""
+    owners = agents.pane_owners(db)
+    return [a for a in db.list_agents(ws.id)
+            if a.mode == "interactive" and a.status not in ("paused", "done")
+            and agents.is_alive(a) and agents.owns_pane(db, a, owners)]
+
+
 def _running_session(db: DB, ws: Workspace):
     """The live session (its interactive agent) in this checkout, if any."""
-    for a in db.list_agents(ws.id):
-        if a.mode == "interactive" and a.status not in ("paused", "done") and agents.is_alive(a):
-            return a
-    return None
+    live = _live_sessions(db, ws)
+    return live[0] if live else None
 
 
 def _ask_about_running(running) -> str:
@@ -415,12 +424,17 @@ def _session_worktree(db: DB, ws: Workspace) -> Workspace:
 def _pause_running(db: DB, ws: Workspace, stop_procs: bool = True) -> None:
     """At most one live session per checkout: pause any that's still running.
     ``stop_procs=False`` when a detached cull follows (see agents.pause)."""
-    for a in db.list_agents(ws.id):
-        if a.mode == "interactive" and a.status not in ("paused", "done") and agents.is_alive(a):
-            # 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}); "
-                       f"`brindle continue {a.id}` brings it back.")
+    from brindle import scratch
+
+    for a in _live_sessions(db, ws):
+        # 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}); "
+                   f"`brindle continue {a.id}` brings it back.")
+    # Chats left running in scratch sessions whose work moved into this repo.
+    for aid in scratch.pause_transferred_to(db, ws.repo_root):
+        typer.echo(f"Paused scratch session chat {aid}: its work moved into this repo; "
+                   f"`brindle continue {aid}` brings it back.")
 
 
 def _describe(s) -> str:
@@ -1578,7 +1592,8 @@ def learning() -> None:
     typer.echo(p.report())
 
 
-@app.command(context_settings={"allow_extra_args": True, "ignore_unknown_options": True})
+@app.command(context_settings={"allow_extra_args": True, "ignore_unknown_options": True,
+                               "help_option_names": []})   # --help is the plugin's: it lists every subcommand
 def account(ctx: typer.Context) -> None:
     """brindle Pro/Team: paid features, login, upgrade, billing, orgs. Bare `brindle account` shows what you have."""
     from brindle import account as account_mod
@@ -1614,6 +1629,30 @@ def _audit_repo(repo: Optional[str]) -> str:
         return os.path.abspath(start)
 
 
+org_app = typer.Typer(help="Your org's messages (brindle Pro Team).")
+app.add_typer(org_app, name="org")
+
+
+@org_app.command("messages")
+def org_messages(
+    keep: bool = typer.Option(False, "--keep", help="Don't mark the messages read."),
+) -> None:
+    """List the notices your org's admins sent you, and mark them read."""
+    from brindle.pro import status
+
+    notes, fresh = status.fetch_messages()
+    if not notes:
+        typer.echo("No new messages." if fresh else "No messages (couldn't reach the org; "
+                   "these are the last ones seen).")
+        return
+    for n in notes:
+        when = time.strftime("%Y-%m-%d %H:%M", time.localtime(n["at"])) if n["at"] else ""
+        who = n["from_role"] + (" (to everyone)" if n["scope"] == "org" else "")
+        typer.echo(f"{when}  {who}: {n['text']}".strip())
+    if fresh and not keep:
+        status.mark_read([n["id"] for n in notes])
+
+
 @audit_app.command("verify")
 def audit_verify(
     repo: Optional[str] = typer.Option(None, "--repo", help="The repo whose log to verify (default: here)."),
@@ -1675,8 +1714,17 @@ def audit_ship(
     if not exporter.entitled():
         typer.echo("audit: your plan doesn't include audit export (brindle Enterprise)")
         raise typer.Exit(2)
+    from brindle import airgap
+
+    if airgap.enabled():
+        typer.echo(f"audit: air-gap mode is on via {airgap.source()}: nothing is sent")
+        raise typer.Exit(2)
+    results = exporter.flush(force=force)
+    if not results:
+        typer.echo("audit: another brindle process is sending right now; run this again in a moment")
+        raise typer.Exit(1)
     failed = False
-    for name, res in exporter.flush(force=force).items():
+    for name, res in results.items():
         failed = failed or bool(res.error)
         typer.echo(f"{name}: sent {res.sent}" + (f", dropped {res.dropped}" if res.dropped else "")
                    + (f"; FAILED: {res.error}" if res.error else ""))
@@ -2204,11 +2252,16 @@ def ci_doctor(
     repo: Optional[str] = typer.Option(None, "--repo", help="owner/name (default: GITHUB_REPOSITORY)."),
 ) -> None:
     """Which provider CLIs and credential names are here, and which providers CI may use on this repository."""
-    from brindle import ci_client
+    from brindle import ci_client, ci_hosts
 
     def go():
-        full = os.environ.get("GITHUB_REPOSITORY") or repo
-        typer.echo(ci_client.doctor(os.environ, full, os.getcwd()))
+        env = os.environ
+        if ci_hosts.GitLabHost.detect(env) and not ci_hosts.GitHubHost.detect(env):
+            # the job's own project and the host's owner rule, not `gh`
+            full, org = env.get("CI_PROJECT_PATH") or repo, ci_hosts.GitLabHost.org_hint
+        else:
+            full, org = env.get("GITHUB_REPOSITORY") or repo, None
+        typer.echo(ci_client.doctor(env, full, os.getcwd(), org=org))
 
     _ci_call(go)
 

{brindle-0.1.0 → brindle-0.2.0}/src/brindle/config.py

@@ -102,10 +102,11 @@ class RepoConfig:
     services: list[dict] = field(default_factory=list)
     # Start Ollama in the background when a native profile points at it on
     # this machine and it isn't running, and preload the models (see
-    # brindle.native.serve). Off by default: a 30B model holds ~20 GB of GPU
-    # memory, so brindle uses a server that's already running and leaves
-    # starting one to the person.
-    local_models: bool = False
+    # brindle.native.serve). On by default, and only ever does anything for a
+    # native profile pointing at Ollama on a loopback address; the server
+    # brindle started is stopped again when the last session closes. Set
+    # false to never start or preload one.
+    local_models: bool = True
     delete_merged_branches: bool = True  # removing a worktree deletes its branch once fully merged into its base
     pr_footer: bool = True             # `brindle pr` ends the PR body with one "built with brindle" line
     sidebar: str = "left"              # where the dashboard sits: "left" of the chat or "bottom"

{brindle-0.1.0 → brindle-0.2.0}/src/brindle/cost.py

@@ -41,22 +41,36 @@ class NotEntitled(Exception):
 @dataclass
 class Bucket:
     dollars: float = 0.0
-    tokens: int = 0            # tokens priced into ``dollars``
+    tokens: int = 0            # tokens priced into ``dollars`` (not the free ones)
     unknown: int = 0           # tokens with no known price
+    free: int = 0              # tokens on models known to be free (priced at exactly zero)
 
-    def add(self, dollars: float | None, tokens: int) -> None:
+    def add(self, dollars: float | None, tokens: int, free: bool = False) -> None:
         if dollars is None:
             self.unknown += tokens
+        elif free:
+            self.free += tokens
         else:
             self.dollars += dollars
             self.tokens += tokens
 
+    @property
+    def all_tokens(self) -> int:
+        return self.tokens + self.free + self.unknown
+
     def show(self) -> str:
-        text = pricing.money(self.dollars) if self.tokens or not self.unknown else "unknown"
+        if self.tokens:
+            text = pricing.money(self.dollars)
+            if self.free:
+                text += f" (+{format_tokens(self.free)} tokens free)"
+            if self.unknown:
+                text += f" (+{format_tokens(self.unknown)} tokens unpriced)"
+            return text
+        if self.free:
+            return "Free" + (f" (+{format_tokens(self.unknown)} tokens unpriced)" if self.unknown else "")
         if self.unknown:
-            text += f" (+{format_tokens(self.unknown)} tokens unpriced)" if self.tokens else \
-                f" ({format_tokens(self.unknown)} tokens unpriced)"
-        return text
+            return f"unknown ({format_tokens(self.unknown)} tokens unpriced)"
+        return pricing.money(self.dollars)
 
 
 @dataclass
@@ -66,6 +80,7 @@ class Priced:
     model: str | None
     tokens: int
     dollars: float | None      # None: no price known
+    free: bool = False         # priced at exactly zero (a local model)
 
 
 class Pricer:
@@ -100,7 +115,7 @@ class Pricer:
         if price is not None:
             dollars = price.cost(int(d.get("input") or 0), int(d.get("output") or 0),
                                  int(d.get("cache_creation") or 0), int(d.get("cache_read") or 0))
-        return Priced(row, model, total, dollars)
+        return Priced(row, model, total, dollars, price is not None and price == pricing.FREE)
 
 
 def rows_since(db: DB, repo_root: str | None, since: float) -> list[HistoryEntry]:
@@ -129,13 +144,16 @@ class Summary:
     by_model: dict[str, Bucket] = field(default_factory=dict)
 
 
+def model_label(p: Priced) -> str:
+    return p.model or (f"profile {p.row.profile}" if p.row.profile else "unknown model")
+
+
 def summary(db: DB, repo_root: str | None, now: float | None = None, days: int = DAYS) -> Summary:
     now = time.time() if now is None else now
     s = Summary(days)
     for p in priced_rows(db, repo_root, now - days * 86400):
-        s.total.add(p.dollars, p.tokens)
-        label = p.model or (f"profile {p.row.profile}" if p.row.profile else "unknown model")
-        s.by_model.setdefault(label, Bucket()).add(p.dollars, p.tokens)
+        s.total.add(p.dollars, p.tokens, p.free)
+        s.by_model.setdefault(model_label(p), Bucket()).add(p.dollars, p.tokens, p.free)
     return s
 
 
@@ -157,7 +175,7 @@ def describe_summary(s: Summary, repo_root: str | None) -> str:
     if not s.by_model:
         lines.append("  no agent usage on record")
     for label, b in sorted(s.by_model.items(), key=lambda kv: (-kv[1].dollars, kv[0])):
-        lines.append(f"  {label:<28} {b.show():<24} {format_tokens(b.tokens + b.unknown)} tokens")
+        lines.append(f"  {label:<28} {b.show():<24} {format_tokens(b.all_tokens)} tokens")
     lines += _footer()
     lines.append("By day, profile and goal, cost per merged branch and review pass rates: "
                  "`brindle cost report` (brindle Pro).")
@@ -243,18 +261,18 @@ def report(db: DB, repo_root: str | None, now: float | None = None, days: int =
     rep = Report(days)
     goals: dict = {}
     for p in priced_rows(db, repo_root, since):
-        rep.total.add(p.dollars, p.tokens)
+        rep.total.add(p.dollars, p.tokens, p.free)
         day = time.strftime("%Y-%m-%d", time.localtime(p.row.ts))
-        rep.by_day.setdefault(day, Bucket()).add(p.dollars, p.tokens)
-        rep.by_profile.setdefault(p.row.profile or "?", Bucket()).add(p.dollars, p.tokens)
-        rep.by_goal.setdefault(_goal_of(db, p.row.agent_id, goals), Bucket()).add(p.dollars, p.tokens)
+        rep.by_day.setdefault(day, Bucket()).add(p.dollars, p.tokens, p.free)
+        rep.by_profile.setdefault(p.row.profile or "?", Bucket()).add(p.dollars, p.tokens, p.free)
+        rep.by_goal.setdefault(_goal_of(db, p.row.agent_id, goals), Bucket()).add(p.dollars, p.tokens, p.free)
     rows = rows_since(db, repo_root, since)
     merged = {(r.repo_root, r.branch) for r in rows if r.kind == "merge" and r.branch}
     rep.merged = len(merged)
     # every row of a merged branch counts toward it, back to before the window began
     for p in priced_rows(db, repo_root, 0):
         if (p.row.repo_root, p.row.branch) in merged:
-            rep.merged_spend.add(p.dollars, p.tokens)
+            rep.merged_spend.add(p.dollars, p.tokens, p.free)
     worker_profile = {(r.repo_root, r.branch): r.profile for r in db.list_history(repo_root, "worker_result", ALL_ROWS)
                       if r.branch and r.profile}   # newest first: keep the oldest (the worker's own)
     for r in rows:
@@ -375,11 +393,17 @@ def describe_report(rep: Report, repo_root: str | None) -> str:
     lines.append("")
     per = rep.per_merged_branch
     if per is None:
-        lines.append(f"Merged branches: {rep.merged}, no priced spend on them" if rep.merged
-                     else "Merged branches: none in this period")
+        if rep.merged and rep.merged_spend.free and not rep.merged_spend.tokens:
+            lines.append(f"Merged branches: {rep.merged}, Free"
+                         + (f" (+{format_tokens(rep.merged_spend.unknown)} tokens unpriced)"
+                            if rep.merged_spend.unknown else ""))
+        else:
+            lines.append(f"Merged branches: {rep.merged}, no priced spend on them" if rep.merged
+                         else "Merged branches: none in this period")
     else:
-        unpriced = (f" (+{format_tokens(rep.merged_spend.unknown)} tokens unpriced)"
-                    if rep.merged_spend.unknown else "")
+        unpriced = ((f" (+{format_tokens(rep.merged_spend.free)} tokens free)" if rep.merged_spend.free else "")
+                    + (f" (+{format_tokens(rep.merged_spend.unknown)} tokens unpriced)"
+                       if rep.merged_spend.unknown else ""))
         lines.append(f"Merged branches: {rep.merged}, {pricing.money(per)} each on average "
                      f"(every row on the branch: worker, reviews, merge){unpriced}")
     lines.append("")