brindle 0.3.4__tar.gz → 0.3.5__tar.gz

{brindle-0.3.4 → brindle-0.3.5}/.gitignore

@@ -12,3 +12,5 @@ docs/
 .brindle/bench.json
 .DS_Store
 commit_msg.txt
+model_routing_plan.*
+open_plan.py

{brindle-0.3.4 → brindle-0.3.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: brindle
-Version: 0.3.4
+Version: 0.3.5
 Summary: Run coding agents in parallel, each on its own git branch, with a supervisor that delegates, reviews, and merges
 Project-URL: Homepage, https://pawdelta.com/brindle/
 Project-URL: Documentation, https://pawdelta.com/brindle/docs/recommended-use
@@ -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.3.4`). A session started before an upgrade keeps
+session shows it too (`brindle 0.3.5`). 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:
 | `max_agents` | `4` | workers running at once per session (`0`: no cap) |
 | `check_timeout` | `900` | seconds each check may take |
 | `check_concurrency` | `2` | 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` (Fable) before handing it to you; `true` turns it on for a cloud account, `false` off |
+| `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 |
 | `graphify` | if the graph is there | point agents at the repo's [graphify](https://github.com/safishamsi/graphify) code map (`false` turns it off) |
@@ -584,27 +584,30 @@ When a workspace is created (including from the pool), brindle starts one contai
 
 ### Routing by weight
 
-The supervisor sizes a task and passes `weight` (`"light"`, `"medium"` or
-`"heavy"`) to `assign`/`handoff`; brindle picks an available profile for that tier.
+The supervisor sizes a task and passes `weight` (`"light"`, `"medium"`,
+`"heavy"` or `"advanced"`, with `"reasoning"` and `"complex"` accepted as aliases) to
+`assign`/`handoff`; brindle picks an available profile for that tier.
 Light is small, well-specified, mechanical work (docs, renames, simple tests);
-medium is a normal feature or bugfix in one area; heavy is design-heavy,
-cross-cutting work, subtle bugs or hard reasoning. The `routing` config maps each
-tier to profile names: the first is the tier's baseline, the rest are candidates
-hosted learning may pick instead (defaults shown; set one tier and the others
-keep theirs):
+medium is a normal feature or bugfix in one area; heavy is architecture design,
+broad cross-cutting refactors, or subtle bugs; advanced is complex, long-running
+system-design and implementation tasks. The `routing`
+config maps each tier to profile names: the first is the tier's baseline, the
+rest are candidates hosted learning may pick instead (defaults shown; set one
+tier and the others keep theirs):
 
 ```json
 {
   "routing": {
-    "light":  ["developer-light", "developer", "developer-codex", "developer-local"],
-    "medium": ["developer", "developer-codex", "developer-heavy"],
-    "heavy":  ["developer", "developer-heavy", "developer-codex"]
+    "light":    ["developer-light", "developer", "developer-codex", "developer-local"],
+    "medium":   ["developer", "developer-codex", "developer-heavy"],
+    "heavy":    ["developer-heavy", "developer-gemini", "developer", "developer-codex"],
+    "advanced": ["developer-fable", "developer-heavy", "developer-gemini"]
   }
 }
 ```
 
-No tier prefers another provider for its own sake: all-Claude or all-Codex may
-be what works best for you, and that's for the learner to find out.
+No tier prefers another provider for its own sake: all-Claude, all-Codex or
+all-Gemini may be what works best for you, and that's for the learner to find out.
 
 Routing merges per tier in this order: built-in defaults, `~/.brindle/config.json`
 (every repo), the repo's `.brindle/config.json` (shared with the team), then
@@ -622,8 +625,9 @@ each tier. Unknown profile names are skipped; doctor and the routing reply
 report the missing name and the file that supplied it.
 
 `developer-light` runs on Claude Haiku at low effort; `developer` on your Claude
-Code default model; `developer-codex` on Codex; `developer-heavy` on Claude Fable
-at high effort.
+Code default model; `developer-codex` on Codex; `developer-heavy` on Claude Opus
+at high effort; `developer-gemini` on Google Antigravity (Gemini) with high effort
+(Tier 3); `developer-fable` on Claude Fable at high effort (Tier 4 advanced).
 A profile is skipped when its CLI isn't installed (`claude`, `codex`, `agy`), the
 local model server isn't answering, or its provider is at your `usage_limit`. If
 hosted learning is on it chooses among the profiles left; otherwise the first

{brindle-0.3.4 → brindle-0.3.5}/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.3.4`). A session started before an upgrade keeps
+session shows it too (`brindle 0.3.5`). A session started before an upgrade keeps
 running the old code, and shows the old number, until you restart it.
 
 ## Quick start
@@ -501,7 +501,7 @@ Autopilot, merge gates and cleanup:
 | `max_agents` | `4` | workers running at once per session (`0`: no cap) |
 | `check_timeout` | `900` | seconds each check may take |
 | `check_concurrency` | `2` | 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` (Fable) before handing it to you; `true` turns it on for a cloud account, `false` off |
+| `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 |
 | `graphify` | if the graph is there | point agents at the repo's [graphify](https://github.com/safishamsi/graphify) code map (`false` turns it off) |
@@ -554,27 +554,30 @@ When a workspace is created (including from the pool), brindle starts one contai
 
 ### Routing by weight
 
-The supervisor sizes a task and passes `weight` (`"light"`, `"medium"` or
-`"heavy"`) to `assign`/`handoff`; brindle picks an available profile for that tier.
+The supervisor sizes a task and passes `weight` (`"light"`, `"medium"`,
+`"heavy"` or `"advanced"`, with `"reasoning"` and `"complex"` accepted as aliases) to
+`assign`/`handoff`; brindle picks an available profile for that tier.
 Light is small, well-specified, mechanical work (docs, renames, simple tests);
-medium is a normal feature or bugfix in one area; heavy is design-heavy,
-cross-cutting work, subtle bugs or hard reasoning. The `routing` config maps each
-tier to profile names: the first is the tier's baseline, the rest are candidates
-hosted learning may pick instead (defaults shown; set one tier and the others
-keep theirs):
+medium is a normal feature or bugfix in one area; heavy is architecture design,
+broad cross-cutting refactors, or subtle bugs; advanced is complex, long-running
+system-design and implementation tasks. The `routing`
+config maps each tier to profile names: the first is the tier's baseline, the
+rest are candidates hosted learning may pick instead (defaults shown; set one
+tier and the others keep theirs):
 
 ```json
 {
   "routing": {
-    "light":  ["developer-light", "developer", "developer-codex", "developer-local"],
-    "medium": ["developer", "developer-codex", "developer-heavy"],
-    "heavy":  ["developer", "developer-heavy", "developer-codex"]
+    "light":    ["developer-light", "developer", "developer-codex", "developer-local"],
+    "medium":   ["developer", "developer-codex", "developer-heavy"],
+    "heavy":    ["developer-heavy", "developer-gemini", "developer", "developer-codex"],
+    "advanced": ["developer-fable", "developer-heavy", "developer-gemini"]
   }
 }
 ```
 
-No tier prefers another provider for its own sake: all-Claude or all-Codex may
-be what works best for you, and that's for the learner to find out.
+No tier prefers another provider for its own sake: all-Claude, all-Codex or
+all-Gemini may be what works best for you, and that's for the learner to find out.
 
 Routing merges per tier in this order: built-in defaults, `~/.brindle/config.json`
 (every repo), the repo's `.brindle/config.json` (shared with the team), then
@@ -592,8 +595,9 @@ each tier. Unknown profile names are skipped; doctor and the routing reply
 report the missing name and the file that supplied it.
 
 `developer-light` runs on Claude Haiku at low effort; `developer` on your Claude
-Code default model; `developer-codex` on Codex; `developer-heavy` on Claude Fable
-at high effort.
+Code default model; `developer-codex` on Codex; `developer-heavy` on Claude Opus
+at high effort; `developer-gemini` on Google Antigravity (Gemini) with high effort
+(Tier 3); `developer-fable` on Claude Fable at high effort (Tier 4 advanced).
 A profile is skipped when its CLI isn't installed (`claude`, `codex`, `agy`), the
 local model server isn't answering, or its provider is at your `usage_limit`. If
 hosted learning is on it chooses among the profiles left; otherwise the first

{brindle-0.3.4 → brindle-0.3.5}/pyproject.toml

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

{brindle-0.3.4 → brindle-0.3.5}/src/brindle/agents.py

@@ -2052,6 +2052,24 @@ def _review_profile(db: DB, ws: Workspace, profile: str | None, cfg: RepoConfig)
             f"reviewer profile {profile!r} can't run: {why}. "
             "Fix that, or set review_profile (or pass profile) to a different reviewer"
         )
+    try:
+        from brindle import policy as pol
+        d = pol.check_assign(cfg, ws.repo_root, profile, "code review", "review")
+        if not d.allowed:
+            for fallback in (cfg.reviewer, "reviewer", "reviewer-gemini", "reviewer-local"):
+                if fallback != profile:
+                    try:
+                        load_profile(fallback, ws.repo_root)
+                        fb_d = pol.check_assign(cfg, ws.repo_root, fallback, "code review", "review")
+                        if fb_d.allowed:
+                            return fallback
+                    except Exception:
+                        continue
+            raise AgentError(f"reviewer profile {profile!r} refused by policy: {d.reason}")
+    except AgentError:
+        raise
+    except Exception:
+        pass
     return profile
 
 

{brindle-0.3.4 → brindle-0.3.5}/src/brindle/autopilot.py

@@ -81,9 +81,9 @@ to be asked each step.
   task's work must merge before another starts; brindle queues it until then.
 - Unless you need a specific profile, pass `weight` on every `assign`:
   "light" (small, well-specified, mechanical: docs, renames, simple tests),
-  "medium" (normal feature work, refactors, cross-cutting edits, or bugfixes) or
-  "heavy" (reserved for exceptionally complex algorithmic work, subtle bugs that
-  failed earlier fix rounds, or deep reasoning). brindle picks an available
+  "medium" (normal feature work or bugfixes in one area),
+  "heavy" (architecture design, broad cross-cutting refactors, or subtle bugs that failed earlier fix rounds), or
+  "advanced" (complex, long-running system-design and implementation tasks). brindle picks an available
   profile for that tier.
 - Keep task briefs short: the goal in a sentence or two, the files, and the
   test that proves it done. Workers read the tests and code themselves;
@@ -506,7 +506,7 @@ def _route_by_weight(db: DB, cfg: RepoConfig, repo_root: str, weight: str, task:
     skipped: list[str] = []
     remaining: list[str] = []
     over: dict[str, str] = {}
-    weight_order = {"light": 0, "medium": 1, "heavy": 2}
+    weight_order = {"light": 0, "medium": 1, "heavy": 2, "advanced": 3, "reasoning": 3, "complex": 3}
     effective_ceiling = ceiling or (cfg.max_weight if (cfg.max_weight and cfg.max_weight in weight_order) else None)
     order = cfg.routing.get(weight, [])
     if effective_ceiling:
@@ -597,6 +597,7 @@ def effective_profile_model(p, repo_root: str | None = None) -> str:
     return m.strip()
 
 
+
 def model_cost_info(name: str, cfg: RepoConfig | None = None, repo_root: str | None = None) -> str:
     """Format model name, effort, and cost tier as a cost signal string."""
     try:
@@ -608,7 +609,7 @@ def model_cost_info(name: str, cfg: RepoConfig | None = None, repo_root: str | N
         if p.effort:
             model_info.append(f"{p.effort} effort")
         pw = profile_weight(name, cfg, repo_root)
-        if pw == "heavy":
+        if pw in ("heavy", "advanced", "reasoning"):
             cost_tier = "most expensive tier"
         elif pw == "light":
             cost_tier = "lowest cost tier"
@@ -621,7 +622,9 @@ def model_cost_info(name: str, cfg: RepoConfig | None = None, repo_root: str | N
 
 
 def profile_weight(name: str, cfg: RepoConfig | None = None, repo_root: str | None = None) -> str:
-    """The tier/weight of a profile ('light', 'medium', 'heavy')."""
+    """The tier/weight of a profile ('light', 'medium', 'heavy', 'advanced')."""
+    if "-fable" in name or "-advanced" in name or "-reasoning" in name:
+        return "advanced"
     try:
         p = load_profile(name, repo_root)
         m = effective_profile_model(p, repo_root).lower()
@@ -647,6 +650,9 @@ def profile_weight(name: str, cfg: RepoConfig | None = None, repo_root: str | No
         in_light = name in cfg.routing.get("light", [])
         in_med = name in cfg.routing.get("medium", [])
         in_heavy = name in cfg.routing.get("heavy", [])
+        in_advanced = name in cfg.routing.get("advanced", []) or name in cfg.routing.get("reasoning", [])
+        if in_advanced and not in_heavy and not in_med and not in_light:
+            return "advanced"
         if in_heavy and not in_med and not in_light:
             return "heavy"
         if in_light and not in_med and not in_heavy:
@@ -670,7 +676,7 @@ def choose_profile(db: DB, caller_id: str, repo_root: str, requested: str | None
     filled with what ``brindle.savings`` records: the ``profile``, the
     ``baseline`` (the pick without learning), ``learned`` and the ``weight``."""
     cfg = load_repo_config(repo_root)
-    weight_order = {"light": 0, "medium": 1, "heavy": 2}
+    weight_order = {"light": 0, "medium": 1, "heavy": 2, "advanced": 3, "reasoning": 3, "complex": 3}
     ceiling = cfg.max_weight if (cfg.max_weight and cfg.max_weight in weight_order) else None
 
     if requested:
@@ -700,20 +706,24 @@ def choose_profile(db: DB, caller_id: str, repo_root: str, requested: str | None
                     why.append(f"milestone profile -> {name}{model_cost_info(name, cfg, repo_root)}")
     if not name:
         from brindle import learning
+        from brindle.config import normalize_weight
 
         if weight:
-            if weight not in WEIGHTS:
+            norm_weight = normalize_weight(weight)
+            if norm_weight not in WEIGHTS:
                 raise AutopilotError(f"weight must be one of {', '.join(WEIGHTS)}, not {weight!r}")
+            weight = norm_weight
             if ceiling and weight_order[weight] > weight_order[ceiling]:
                 orig_weight = weight
                 weight = ceiling
                 if why is not None:
                     why.append(f"weight {orig_weight} capped to {weight} by max_weight")
             if files and all(f.startswith("docs/") or f.endswith(".md") for f in files):
-                if weight == "heavy":
+                if weight in ("advanced", "reasoning", "heavy"):
+                    orig_demote = weight
                     weight = "medium"
                     if why is not None:
-                        why.append("weight demoted from heavy to medium (docs only)")
+                        why.append(f"weight demoted from {orig_demote} to medium (docs only)")
                 elif weight == "medium":
                     weight = "light"
                     if why is not None:

brindle-0.3.5/src/brindle/builtin_agents/developer-fable.md

@@ -0,0 +1,7 @@
+---
+name: developer-fable
+description: Implements a complex, long-running system-design or implementation task on its own branch, on Fable with high effort (the advanced tier of weight routing)
+extends: developer
+model: fable
+effort: high
+---

brindle-0.3.5/src/brindle/builtin_agents/developer-gemini.md

@@ -0,0 +1,7 @@
+---
+name: developer-gemini
+description: Implements a heavy coding or architectural task on its own branch, using Google Antigravity (Gemini) with high effort (the heavy tier of weight routing)
+extends: developer
+provider: antigravity
+effort: high
+---

{brindle-0.3.4 → brindle-0.3.5}/src/brindle/builtin_agents/developer-heavy.md

@@ -1,7 +1,7 @@
 ---
 name: developer-heavy
-description: Implements a design-heavy or subtle task on its own branch, on Fable with high effort (the heavy tier of weight routing)
+description: Implements a design-heavy or subtle task on its own branch, on Opus with high effort (the heavy tier of weight routing)
 extends: developer
-model: claude-fable-5-1
+model: opus
 effort: high
 ---

{brindle-0.3.4 → brindle-0.3.5}/src/brindle/config.py

@@ -43,15 +43,32 @@ def user_config_path() -> Path:
     return brindle_home() / CONFIG_FILE
 
 
-WEIGHTS = ("light", "medium", "heavy")
+WEIGHTS = ("light", "medium", "heavy", "advanced")
+WEIGHT_ALIASES = {
+    "reasoning": "advanced",
+    "complex": "advanced",
+    "complex reasoning": "advanced",
+    "deep": "advanced",
+}
+
+
+def normalize_weight(weight: str | None) -> str | None:
+    """Normalize a weight string, resolving aliases like 'reasoning' or 'complex' to 'advanced'."""
+    if not weight:
+        return None
+    w = weight.strip().lower()
+    return WEIGHT_ALIASES.get(w, w)
+
+
 # The first profile of each tier is its baseline; the rest are candidates
 # brindle Pro's learner may pick instead when its evidence says they do better.
-# Nothing here prefers another provider for its own sake: all-Claude or
-# all-Codex may well be best, and that's the learner's call.
+# Nothing here prefers another provider for its own sake: all-Claude, all-Codex
+# or all-Gemini may well be best, and that's the learner's call.
 DEFAULT_ROUTING = {
     "light": ["developer-light", "developer", "developer-codex", "developer-local"],
     "medium": ["developer", "developer-codex", "developer-heavy"],
-    "heavy": ["developer", "developer-heavy", "developer-codex"],
+    "heavy": ["developer-heavy", "developer-gemini", "developer", "developer-codex"],
+    "advanced": ["developer-fable", "developer-heavy", "developer-gemini"],
 }
 
 
@@ -91,7 +108,7 @@ class RepoConfig:
     merge_into: str | None = None      # branch worker branches are cut from and merge into (None: the supervisor's / default branch)
     auto_merge_default_branch: bool = False  # let the pipeline merge into the repo's default branch on its own
     delegation: str = "balanced"      # how readily a supervisor hands work to workers: "conservative" (save tokens), "balanced" or "fast" (save time)
-    max_weight: str | None = None      # ceiling for weight routing: "light", "medium", or None (unlimited)
+    max_weight: str | None = None      # ceiling for weight routing: "light", "medium", "heavy", "advanced", or None (unlimited)
     plan_first: bool = False           # workers propose a plan and wait for approval before editing
     # "on": brindle answers workers' permission requests by its rules (see
     # brindle.permissions). Unset, it's "on" for Pro and up and "off" on Free.
@@ -245,15 +262,17 @@ def load_repo_config(repo_root: str | Path) -> RepoConfig:
         routing = source.get("routing")
         if isinstance(routing, dict):
             for tier, names in routing.items():
-                if tier in WEIGHTS and isinstance(names, list):
-                    cfg.routing[tier] = [n for n in names if isinstance(n, str)]
-                    cfg.routing_sources[tier] = str(path)
+                norm_tier = normalize_weight(tier)
+                if norm_tier in WEIGHTS and isinstance(names, list):
+                    cfg.routing[norm_tier] = [n for n in names if isinstance(n, str)]
+                    cfg.routing_sources[norm_tier] = str(path)
     for source in (shared, local):  # per weight, so a repo can override one and keep the rest
         second = source.get("second_review")
         if isinstance(second, dict):
             for tier, name in second.items():
-                if tier in WEIGHTS and isinstance(name, str) and name:
-                    cfg.second_review[tier] = name
+                norm_tier = normalize_weight(tier)
+                if norm_tier in WEIGHTS and isinstance(name, str) and name:
+                    cfg.second_review[norm_tier] = name
     for source in (user, shared, local):  # per model, so a repo can override one and keep the rest
         pricing = source.get("pricing")
         if isinstance(pricing, dict):

{brindle-0.3.4 → brindle-0.3.5}/src/brindle/cost_estimate.py

@@ -62,12 +62,20 @@ PRIOR: dict[tuple[str, str], tuple[Tokens, Tokens]] = {
                            Tokens(120_000, 80_000, 800_000, 10_000_000)),
     ("worker", "heavy"): (Tokens(120_000, 90_000, 900_000, 12_000_000),
                           Tokens(250_000, 180_000, 1_800_000, 25_000_000)),
+    ("worker", "advanced"): (Tokens(200_000, 150_000, 1_500_000, 20_000_000),
+                             Tokens(450_000, 300_000, 3_000_000, 40_000_000)),
+    ("worker", "reasoning"): (Tokens(200_000, 150_000, 1_500_000, 20_000_000),
+                              Tokens(450_000, 300_000, 3_000_000, 40_000_000)),
     ("review", "light"): (Tokens(15_000, 6_000, 80_000, 600_000),
                           Tokens(30_000, 12_000, 160_000, 1_200_000)),
     ("review", "medium"): (Tokens(20_000, 10_000, 100_000, 1_000_000),
                            Tokens(40_000, 20_000, 200_000, 2_000_000)),
     ("review", "heavy"): (Tokens(40_000, 20_000, 200_000, 2_500_000),
                           Tokens(80_000, 40_000, 400_000, 5_000_000)),
+    ("review", "advanced"): (Tokens(60_000, 30_000, 300_000, 4_000_000),
+                             Tokens(120_000, 60_000, 600_000, 8_000_000)),
+    ("review", "reasoning"): (Tokens(60_000, 30_000, 300_000, 4_000_000),
+                              Tokens(120_000, 60_000, 600_000, 8_000_000)),
 }
 PRIOR_LOW, PRIOR_HIGH = 0.5, 1.5   # how far a prior's range is widened
 

{brindle-0.3.4 → brindle-0.3.5}/src/brindle/cull.py

@@ -143,6 +143,17 @@ def sweep(db: DB, now: float | None = None) -> list[str]:
 
     done.extend(signin_pause.sweep(db, now))
 
+    # 1g. Periodic cost events (Team org_budgets): report delta spend for supervisor and workers.
+    from brindle import events
+
+    roots = {ws.repo_root for ws in db.find_workspaces() if ws.repo_root}
+    for r in roots:
+        try:
+            cfg = load_repo_config(r)
+            done.extend(events.emit_periodic_cost(cfg, r))
+        except Exception:
+            pass
+
     # 2. Workers nobody needs any more.
     limits: dict[str, float] = {}
     for a in db.list_agents():

{brindle-0.3.4 → brindle-0.3.5}/src/brindle/db.py

@@ -374,6 +374,11 @@ CREATE TABLE IF NOT EXISTS launch_health (
     baseline TEXT NOT NULL DEFAULT '',
     outcome TEXT
 );
+CREATE TABLE IF NOT EXISTS agent_reported_spend (
+    agent_id TEXT PRIMARY KEY,
+    reported_usd REAL NOT NULL,
+    updated_at REAL NOT NULL
+);
 """
 
 
@@ -1677,3 +1682,15 @@ class DB:
         cols = ", ".join(f"{k}=?" for k in fields)
         with self.tx() as c:
             c.execute(f"UPDATE tasks SET {cols} WHERE id=?", (*fields.values(), task_id))
+
+    def get_reported_spend(self, agent_id: str) -> float:
+        row = self.conn.execute("SELECT reported_usd FROM agent_reported_spend WHERE agent_id=?", (agent_id,)).fetchone()
+        return float(row[0]) if row else 0.0
+
+    def set_reported_spend(self, agent_id: str, reported_usd: float) -> None:
+        with self.tx() as c:
+            c.execute(
+                "INSERT INTO agent_reported_spend (agent_id, reported_usd, updated_at) VALUES (?, ?, ?) "
+                "ON CONFLICT(agent_id) DO UPDATE SET reported_usd=excluded.reported_usd, updated_at=excluded.updated_at",
+                (agent_id, reported_usd, time.time())
+            )

{brindle-0.3.4 → brindle-0.3.5}/src/brindle/events.py

@@ -34,7 +34,7 @@ log = logging.getLogger(__name__)
 
 GROUP = plugins.EVENTS
 KINDS = ("assign", "handoff", "review", "escalated", "merge", "remove", "deny_assign",
-         "deny_merge")
+         "deny_merge", "cost")
 
 
 @dataclass(frozen=True)
@@ -100,9 +100,9 @@ def _model(profile: str | None, repo_root: str) -> str | None:
 
 
 def _cost(kind: str, worker: Agent | None, repo_root: str) -> float | None:
-    """What ``worker`` spent, for the ``remove`` event that ends it, when the
+    """What ``worker`` spent, for the ``remove`` or ``cost`` event that ends it or tracks spend, when the
     org counts spend (Team ``org_budgets``); None otherwise or when it can't be priced."""
-    if kind != "remove" or worker is None:
+    if kind not in ("remove", "cost") or worker is None:
         return None
     try:
         from brindle import budget
@@ -111,8 +111,14 @@ def _cost(kind: str, worker: Agent | None, repo_root: str) -> float | None:
 
         if not license.has("org_budgets"):
             return None
-        spent = budget.worker_spend(DB(), worker, repo_root)
-        return round(spent, 4) if spent else None
+        db = DB()
+        spent = budget.worker_spend(db, worker, repo_root)
+        if spent is None:
+            return None
+        get_rep = getattr(db, "get_reported_spend", None)
+        reported = get_rep(worker.id) if callable(get_rep) else 0.0
+        delta = round(spent - (reported or 0.0), 4)
+        return delta if delta > 0 else None
     except Exception:
         log.debug("brindle: couldn't price %s for the event", worker.id, exc_info=True)
         return None
@@ -125,7 +131,7 @@ def _by_model(kind: str, worker: Agent | None, repo_root: str,
     (which can include live usage) exceeds what the history rows add up to,
     the remainder is an "unknown model" entry with no tokens, so the split
     sums to ``cost_usd``."""
-    if kind != "remove" or worker is None:
+    if kind not in ("remove", "cost") or worker is None:
         return None
     try:
         from brindle import cost
@@ -146,10 +152,20 @@ def _by_model(kind: str, worker: Agent | None, repo_root: str,
             slot = out.setdefault(cost.model_label(p), {"tokens": 0, "usd": 0.0})
             slot["tokens"] += p.tokens
             slot["usd"] += p.dollars or 0.0
-        rest = round((cost_usd or 0.0) - sum(b["usd"] for b in out.values()), 4)
-        if rest > 0:
-            slot = out.setdefault("unknown model", {"tokens": 0, "usd": 0.0})
-            slot["usd"] += rest
+        total_usd = sum(b["usd"] for b in out.values())
+        if cost_usd is not None and total_usd > cost_usd > 0:
+            factor = cost_usd / total_usd
+            for b in out.values():
+                b["usd"] = round(b["usd"] * factor, 4)
+            diff = round(cost_usd - sum(b["usd"] for b in out.values()), 4)
+            if diff:
+                first = next(iter(out.values()))
+                first["usd"] = round(first["usd"] + diff, 4)
+        else:
+            rest = round((cost_usd or 0.0) - total_usd, 4)
+            if rest > 0:
+                slot = out.setdefault("unknown model", {"tokens": 0, "usd": 0.0})
+                slot["usd"] += rest
         return out or None
     except Exception:
         log.debug("brindle: couldn't split %s by model for the event", worker.id, exc_info=True)
@@ -173,10 +189,59 @@ def emit(cfg: RepoConfig, kind: str, ws: Workspace, worker: Agent | None = None,
             cost_usd=cost_usd,
             by_model=_by_model(kind, worker, ws.repo_root, cost_usd),
         ))
+        if cost_usd and worker and kind in ("remove", "cost"):
+            try:
+                from brindle.db import DB
+                db = DB()
+                set_rep = getattr(db, "set_reported_spend", None)
+                get_rep = getattr(db, "get_reported_spend", None)
+                if callable(set_rep) and callable(get_rep):
+                    old_reported = get_rep(worker.id) or 0.0
+                    set_rep(worker.id, round(old_reported + cost_usd, 4))
+            except Exception:
+                pass
     except Exception:
         log.exception("brindle: the events plugin failed on a %s event", kind)
 
 
+def emit_periodic_cost(cfg: RepoConfig, repo_root: str) -> list[str]:
+    """Check active agents (workers and supervisor sessions) in ``repo_root``,
+    compute their delta spend since last report, and emit a 'cost' event
+    if delta >= 0.01."""
+    from brindle import budget
+    from brindle.db import DB
+    from brindle.pro import license
+
+    done: list[str] = []
+    try:
+        if not license.has("org_budgets"):
+            return done
+    except Exception:
+        return done
+
+    try:
+        db = DB()
+        for a in db.list_agents():
+            if a.dismissed_at is not None:
+                continue
+            ws = db.get_workspace(a.workspace_id)
+            if ws is None or ws.repo_root != repo_root:
+                continue
+            spent = budget.worker_spend(db, a, repo_root)
+            if spent is None:
+                continue
+            get_rep = getattr(db, "get_reported_spend", None)
+            reported = get_rep(a.id) if callable(get_rep) else 0.0
+            delta = round(spent - (reported or 0.0), 4)
+            if delta < 0.01:
+                continue
+            emit(cfg, "cost", ws, worker=a)
+            done.append(f"emitted periodic cost ${delta:.2f} for agent {a.id}")
+    except Exception:
+        log.exception("brindle: periodic cost check failed for %s", repo_root)
+    return done
+
+
 def emit_denial(cfg: RepoConfig, repo_root: str, what: str, reason: str, *,
                 branch: str | None = None, profile: str | None = None,
                 provider: str | None = None, model: str | None = None,
@@ -194,5 +259,5 @@ def emit_denial(cfg: RepoConfig, repo_root: str, what: str, reason: str, *,
         log.exception("brindle: the events plugin failed on a deny_%s event", what)
 
 
-__all__ = ["GROUP", "KINDS", "Event", "EventsPlugin", "emit", "emit_denial", "plugin",
+__all__ = ["GROUP", "KINDS", "Event", "EventsPlugin", "emit", "emit_denial", "emit_periodic_cost", "plugin",
            "plugins_for"]

{brindle-0.3.4 → brindle-0.3.5}/src/brindle/mcp_server.py

@@ -247,12 +247,12 @@ async def handoff(
     profile is used, else `weight` routes to an available profile, else the
     repo's default agent.
 
-    weight: "light", "medium" or "heavy" (when you don't need a specific
+    weight: "light", "medium", "heavy" or "advanced" (when you don't need a specific
     profile): brindle picks an available profile for the tier and the reply says
     which and why. light = small, well-specified, mechanical (docs, renames,
-    simple tests); medium = normal feature work, refactors, cross-cutting edits,
-    or bugfixes; heavy = reserved for exceptionally complex algorithmic work,
-    subtle bugs that failed earlier fix rounds, or deep reasoning.
+    simple tests); medium = normal feature work or bugfixes; heavy = system
+    architecture, broad refactoring; advanced = complex, long-running
+    system-design and implementation tasks.
 
     Waits up to wait_seconds (default 4 minutes). If the worker isn't done by
     then, this returns "still running": call wait_for_worker to keep waiting,
@@ -384,12 +384,12 @@ async def assign(
     profile is used, else `weight` routes to an available profile, else the
     repo's default agent.
 
-    weight: "light", "medium" or "heavy" (when you don't need a specific
+    weight: "light", "medium", "heavy" or "advanced" (when you don't need a specific
     profile): brindle picks an available profile for the tier and the reply says
     which and why. light = small, well-specified, mechanical (docs, renames,
-    simple tests); medium = normal feature work, refactors, cross-cutting edits,
-    or bugfixes; heavy = reserved for exceptionally complex algorithmic work,
-    subtle bugs that failed earlier fix rounds, or deep reasoning.
+    simple tests); medium = normal feature work or bugfixes; heavy = system
+    architecture, broad refactoring; advanced = complex, long-running
+    system-design and implementation tasks.
 
     When it finishes, its result arrives in your conversation as a message.
     Isolation works as for handoff. Use this to run several workers in parallel.