brindle 0.5.1__tar.gz → 0.5.2__tar.gz

{brindle-0.5.1 → brindle-0.5.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: brindle
-Version: 0.5.1
+Version: 0.5.2
 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

{brindle-0.5.1 → brindle-0.5.2}/pyproject.toml

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

@@ -180,7 +180,7 @@ def worker_guidance(ws: Workspace, report_only: bool = False) -> str:
     from brindle.config import load_repo_config
 
     try:
-        checks = load_repo_config(ws.repo_root).checks
+        checks = load_repo_config(ws.repo_root, branch=ws.base_branch).checks
     except ValueError:
         checks = []
     parts = (codemap.guidance(ws), "" if report_only else test_guidance(checks),
@@ -2318,7 +2318,7 @@ def warm_checks(ws: Workspace) -> None:
     from brindle.providers import brindle_invocation
 
     try:
-        if not load_repo_config(ws.repo_root).checks or git.dirty_files(ws.path):
+        if not load_repo_config(ws.repo_root, branch=ws.base_branch).checks or git.dirty_files(ws.path):
             return
     except (ValueError, git.GitError):
         return
@@ -2906,7 +2906,7 @@ def start_review(db: DB, caller: Agent | None, ws: Workspace, profile: str | Non
     from brindle.providers import brindle_invocation
 
     _review_worktree_present(ws)
-    cfg = cfg or load_repo_config(ws.repo_root)
+    cfg = cfg or workspaces.config_for(db, ws)
     if not cfg.checks:
         return request_review(db, caller, ws, profile, focus, cfg, second=second, slot=slot)
     _review_kill_switch(ws)
@@ -3026,7 +3026,7 @@ def review_after_checks(db: DB, caller_id: str | None, ws: Workspace, profile: s
     from brindle import gates, pipeline
     from brindle.config import load_repo_config
 
-    cfg = cfg or load_repo_config(ws.repo_root)
+    cfg = cfg or workspaces.config_for(db, ws)
     slot = _review_claim_slot(profile, slot)
     profile = _review_profile(db, ws, profile, cfg)
     with _review_request_run(ws.id, profile, request_id), pipeline.review_run(ws.id):
@@ -3166,7 +3166,7 @@ def _request_review(db: DB, caller: Agent | None, ws: Workspace, profile: str |
 
     _review_worktree_present(ws)
     _review_kill_switch(ws)
-    cfg = cfg or load_repo_config(ws.repo_root)
+    cfg = cfg or workspaces.config_for(db, ws)
     slot = _review_claim_slot(profile, slot)
     profile = _review_profile(db, ws, profile, cfg)
     if second and not slot:

{brindle-0.5.1 → brindle-0.5.2}/src/brindle/autopilot.py

@@ -47,7 +47,7 @@ import time
 from dataclasses import dataclass
 from pathlib import Path
 
-from brindle.config import CONFIG_DIR, WEIGHTS, RepoConfig, config_root, load_repo_config
+from brindle.config import CONFIG_DIR, WEIGHTS, RepoConfig, config_root, load_repo_config, workspace_config
 from brindle import bus, escapes, knowledge
 from brindle.db import DB, Agent, Autopilot, Milestone, Workspace, check_state
 from brindle.profiles import load_profile
@@ -1310,7 +1310,7 @@ def check_milestones(db: DB, root_id: str, ws: Workspace, position: int | None =
     ap = db.get_autopilot(root_id)
     if ap and ap.state == "done":
         return progress(db, root_id, in_flight=False)
-    cfg = cfg or load_repo_config(ws.repo_root)
+    cfg = cfg or workspace_config(ws, session=True)
     ms = db.milestones(root_id)
     if not ms:
         raise AutopilotError("no milestones yet: record the goal with set_goal first")
@@ -1363,7 +1363,7 @@ def check_milestones(db: DB, root_id: str, ws: Workspace, position: int | None =
             # Cached by commit when the checkout is clean, so a check that
             # already passed at this HEAD (as a merge gate, say) isn't re-run.
             try:
-                ok, out = gates.run_checked(db, checkout, m.check_cmd, workspaces.workspace_env(checkout),
+                ok, out = gates.run_checked(db, checkout, m.check_cmd, workspaces.workspace_env(checkout, repo_cfg),
                                             repo_cfg.check_timeout)
             except Exception as e:
                 db.record_check(m.id, False, f"$ {m.check_cmd}\n(crashed: {e})", sha,
@@ -1569,7 +1569,7 @@ def start_audit(db: DB, root_id: str, ws: Workspace, cfg: RepoConfig | None = No
         if ap.audit_sha == head:
             return None
         agents.close(db, running.id)
-    cfg = cfg or load_repo_config(ws.repo_root)
+    cfg = cfg or workspace_config(ws, session=True)
     profile = agents.default_review_profile(cfg, db.get_agent(root_id), db, ws.repo_root, ap.goal)
     auditor = agents.spawn(db, ws, profile, prompt=audit_prompt(db, ap, head), parent_id=root_id,
                            mode="review", background_setup=True)

{brindle-0.5.1 → brindle-0.5.2}/src/brindle/check_scope.py

@@ -14,7 +14,9 @@ left its base decide what runs:
 - one matches ``INFER_FULL_WHEN`` (conftest, pytest and project config, a
   lockfile) or is under ``.brindle/``, or the scope can't be worked out: the
   command runs in full;
-- otherwise the command runs on the test files the branch touched plus the
+- otherwise changed files that aren't ``.py`` are ignored (pytest can't be
+  affected by them), and if none is left the check is skipped; the command
+  runs on the test files the branch touched plus the
   tests ``graphify affected`` reaches from each changed symbol. A changed file
   the graph can't map to a test runs the full suite instead.
 
@@ -61,10 +63,9 @@ _VALUE_OPTIONS = {"-n", "-m", "-k", "-p", "-o", "-c", "--maxfail", "--tb", "--du
                   "--deselect", "--dist", "--cov", "--timeout", "--junitxml", "-W", "--basetemp"}
 INFER_FULL_WHEN = ["**/conftest.py", "**/pyproject.toml", "**/setup.cfg", "**/pytest.ini", "**/tox.ini",
                    "**/*.lock", "**/*lock.json", "**/requirements*.txt"]
-NOTICE = ("brindle can now run only the tests a branch's changes reach for a plain pytest check (`{cmd}`), "
-          "using the code graph; it will be the default next release. Try it now with "
-          '`"scoped_checks": "infer"` in .brindle/config.json (or ~/.brindle/config.json), or keep the '
-          'current behaviour with `"scoped_checks": "off"`.')
+NOTICE = ("brindle now runs only the tests a worker branch's changes reach for a plain pytest check (`{cmd}`), "
+          "using the code graph. To always run it in full, set "
+          '`"scoped_checks": "off"` in .brindle/config.json (or ~/.brindle/config.json).')
 
 
 def pytest_selectors(cmd: str) -> bool | None:
@@ -99,7 +100,7 @@ def inferred(cmd: str, mode: str | None) -> CheckScope | None:
     """The scope ``scoped_checks: "infer"`` gives ``cmd``: pytest on the
     affected tests when it is a plain pytest command that picks no tests
     itself (appending targets would not narrow it), else None."""
-    if mode == "infer" and pytest_selectors(cmd) is False:
+    if mode in (None, "infer") and pytest_selectors(cmd) is False:
         return CheckScope(INFER_FULL_WHEN)
     return None
 
@@ -176,6 +177,9 @@ def command(ws: Workspace, cmd: str, scope: CheckScope | None, diff: tuple[str,
         return None
     if any(matches(f, ALWAYS_FULL) or matches(f, scope.full_when) for f in changed):
         return cmd
+    changed = [f for f in changed if f.endswith(".py")]   # pytest can't be affected by the rest
+    if not changed:
+        return None
     tests = pytest_targets(ws, base, changed)
     return f"{cmd} {_quoted(tests)} || [ $? -eq 5 ]" if tests else cmd   # 5: none of them selected
 

{brindle-0.5.1 → brindle-0.5.2}/src/brindle/cli.py

@@ -2333,11 +2333,10 @@ def open_cmd(
 @app.command()
 def setup(workspace: Optional[str] = typer.Argument(None)) -> None:
     """Re-run setup commands in a workspace."""
-    from brindle.config import load_repo_config
-
-    ws = _ws(DB(), workspace)
-    cmds = load_repo_config(ws.repo_root).setup
-    res = workspaces.run_commands(cmds, ws.path, workspaces.workspace_env(ws))
+    db = DB()
+    ws = _ws(db, workspace)
+    cfg = workspaces.config_for(db, ws)
+    res = workspaces.run_commands(cfg.setup, ws.path, workspaces.workspace_env(ws, cfg))
     typer.echo(res.log or "(no setup commands)")
     raise typer.Exit(0 if res.ok else 1)
 
@@ -2407,8 +2406,15 @@ def pr(
     draft: bool = typer.Option(False, "--draft"),
 ) -> None:
     """Push and open a pull request against the base branch."""
-    ws = _ws(DB(), workspace)
-    url = _run(workspaces.pull_request, ws, title, draft)
+    from brindle import gates
+
+    db = DB()
+    ws = _ws(db, workspace)
+    def open_checked() -> str:
+        with gates.pr_checked(db, ws, lambda text: typer.echo(text, err=True)) as sha:
+            return workspaces.pull_request(ws, title, draft, sha=sha)
+
+    url = _run(open_checked)
     typer.echo(url)
     _offer_delete_on_merge(ws.repo_root)
 
@@ -2453,12 +2459,12 @@ def services_cmd(
 ) -> None:
     """Per-worktree Docker services (brindle Pro): list, start or stop a workspace's."""
     from brindle import services as services_mod
-    from brindle.config import load_repo_config
 
     if action not in ("ls", "up", "down"):
         _fail("action must be ls, up or down")
-    ws = _ws(DB(), workspace)
-    cfg = load_repo_config(ws.repo_root)
+    db = DB()
+    ws = _ws(db, workspace)
+    cfg = workspaces.config_for(db, ws)
     if not cfg.services:
         _fail('no services configured; add a "services" list to .brindle/config.json')
     if action == "up":
@@ -3100,7 +3106,7 @@ def review_after_checks_cmd(workspace_id: str, caller: Optional[str] = typer.Opt
     if ws is None:
         return
     try:
-        agents.review_after_checks(db, caller, ws, profile, focus, load_repo_config(ws.repo_root),
+        agents.review_after_checks(db, caller, ws, profile, focus, workspaces.config_for(db, ws),
                                    request_id=request_id, second=second, slot=slot)
     except (agents.AgentError, ValueError) as e:
         from brindle import pipeline
@@ -3170,7 +3176,7 @@ def warm_checks_cmd(workspace_id: str) -> None:
     try:
         # A new commit makes this run's result useless (the review and the
         # gate want the new head), so give up and free the check slot.
-        gates.check_summary(db, ws, load_repo_config(ws.repo_root),
+        gates.check_summary(db, ws, workspaces.config_for(db, ws),
                             cancel=lambda: gates.head(ws) != sha)
     except gates.Abandoned:
         pass

{brindle-0.5.1 → brindle-0.5.2}/src/brindle/codex_hook.py

@@ -73,6 +73,20 @@ def _home_key(home: Path) -> str:
     return os.path.realpath(home)
 
 
+def _runnable_script(script: str) -> bool:
+    if not os.access(script, os.X_OK):
+        return False
+    try:
+        with open(script, "rb") as f:
+            first = f.readline(4096)
+    except OSError:
+        return False
+    if first.startswith(b"#!"):
+        interpreter = first[2:].split(maxsplit=1)
+        return bool(interpreter) and os.access(os.fsdecode(interpreter[0]), os.X_OK)
+    return True
+
+
 def _stable_invocation() -> list[str]:
     """brindle_invocation, with the interpreter named the same however brindle
     was started (a venv's ``python`` and ``python3`` are the same program,
@@ -87,8 +101,12 @@ def _stable_invocation() -> list[str]:
     # replaces the other's and the next launch of either stops at "Hooks need review".
     script = os.path.join(os.path.dirname(exe), "brindle")
     if len(argv) == 1:
-        return [os.path.realpath(exe)]
-    if argv[1:] == ["-P", "-m", "brindle"] and os.access(script, os.X_OK):
+        if _runnable_script(exe):
+            return [os.path.realpath(exe)]
+        # Older bundled engines carry a console script with a CI-only shebang.
+        exe = os.path.join(os.path.dirname(os.path.realpath(exe)), "python3")
+        argv = [exe, "-P", "-m", "brindle"]
+    if argv[1:] == ["-P", "-m", "brindle"] and _runnable_script(script):
         return [os.path.realpath(script)]
     plain = os.path.join(os.path.dirname(exe), "python")
     try:

{brindle-0.5.1 → brindle-0.5.2}/src/brindle/company_login.py

@@ -24,6 +24,7 @@ from pathlib import Path
 from typing import Callable
 
 from brindle import cloud_credential, config
+from brindle.pro.license import request_cached
 
 log = logging.getLogger(__name__)
 
@@ -575,6 +576,7 @@ def route_in_use(org_id: str, setup) -> bool:
     return isinstance(got, dict) and got.get("org") == org_id
 
 
+@request_cached
 def org_setup(repo_root: str | None = None, store=None, client=None, max_age: float | None = None):
     """(org id, AgentSetup) for the signed-in org; personal policies supply
     only federated Claude setup. None when there is no applicable setup;
@@ -583,8 +585,8 @@ def org_setup(repo_root: str | None = None, store=None, client=None, max_age: fl
     from brindle.pro import credentials, license, team_policy
 
     try:
-        store = store or credentials.default_store()
         ent = license.current(store=store, client=client, max_age=max_age)
+        store = store or credentials.default_store()
         personal = team_policy.FEATURE not in ent.features
         if personal and (ent.policy_version <= 0 or (store.load() or {}).get("org_id")
                          or ent.plan in ("team", "enterprise")):

{brindle-0.5.1 → brindle-0.5.2}/src/brindle/config.py

@@ -10,6 +10,7 @@ from __future__ import annotations
 
 import json
 import os
+import subprocess
 import sys
 import tempfile
 import threading
@@ -106,7 +107,7 @@ class RepoConfig:
     # Autopilot and merge gates.
     autopilot: bool = True             # `brindle` starts the supervisor with autopilot on
     checks: list[str] = field(default_factory=list)  # must pass in a branch before it merges
-    scoped_checks: str | None = None   # "off" or "infer"; None: not chosen (acts as "off" this release, see brindle.check_scope.inferred)
+    scoped_checks: str | None = None   # "off" or "infer"; None: not chosen (acts as "infer", see brindle.check_scope.inferred)
     review: bool | None = None         # require a reviewer's approval (None: only under autopilot)
     reviewer: str = "reviewer"         # agent profile that reviews branches
     review_profile: str | None = None  # force request_review's profile (skips its automatic cross-model pick)
@@ -244,11 +245,11 @@ def _merge_commands(shared: list[str], local: object) -> list[str]:
     return shared
 
 
-def _read_json(path: Path) -> dict:
-    if not path.is_file():
+def _read_json(path: Path, text: str | None = None) -> dict:
+    if text is None and not path.is_file():
         return {}
     try:
-        data = json.loads(path.read_text(encoding="utf-8"))
+        data = json.loads(path.read_text(encoding="utf-8") if text is None else text)
     except json.JSONDecodeError as e:
         raise ValueError(f"{path}: invalid JSON ({e})") from e
     if not isinstance(data, dict):
@@ -256,6 +257,30 @@ def _read_json(path: Path) -> dict:
     return data
 
 
+def _read_shared(root: Path, branch: str | None) -> dict:
+    """The shared config as committed on ``branch`` (the branch a session's
+    workers are cut from and merge into), not whatever the checkout at
+    ``root`` has checked out; the working tree's file when there's no
+    branch or it isn't committed there."""
+    path = root / CONFIG_DIR / CONFIG_FILE
+    if branch:
+        try:
+            proc = subprocess.run(["git", "show", f"{branch}:{CONFIG_DIR}/{CONFIG_FILE}"], cwd=root,
+                                  capture_output=True, text=True)
+        except OSError:
+            proc = None
+        if proc is not None and proc.returncode == 0:
+            return _read_json(Path(f"{branch}:{CONFIG_DIR}/{CONFIG_FILE}"), proc.stdout)
+    return _read_json(path)
+
+
+def workspace_config(ws, *, session: bool = False) -> RepoConfig:
+    """``load_repo_config`` for workspace ``ws``, reading the shared file
+    from its base branch (see ``_read_shared``). A session's own workspace
+    (``session``) reads its own branch; its workers' base is that branch."""
+    return load_repo_config(ws.repo_root, branch=ws.branch if session and ws.kind == "worktree" else ws.base_branch)
+
+
 def config_root(path: str | Path) -> Path:
     """The directory whose ``.brindle`` applies to ``path``: ``path`` itself when
     it has one, else (for a linked git worktree, where the git-ignored config
@@ -342,10 +367,14 @@ def kind_overrides(found: object) -> dict[str, dict[str, str]]:
     return out
 
 
-def load_repo_config(repo_root: str | Path) -> RepoConfig:
+def load_repo_config(repo_root: str | Path, *, user_only: bool = False, branch: str | None = None) -> RepoConfig:
+    """The settings for ``repo_root``: its local file over its shared one over
+    the person's ~/.brindle/config.json. ``user_only``: the person's file
+    alone, as every repo starts from it (the app's Agents tab). ``branch``:
+    read the shared file as committed there (see ``_read_shared``)."""
     base = config_root(repo_root) / CONFIG_DIR
-    shared = _read_json(base / CONFIG_FILE)
-    local = _read_json(base / LOCAL_CONFIG_FILE)
+    shared = {} if user_only else _read_shared(base.parent, branch)
+    local = {} if user_only else _read_json(base / LOCAL_CONFIG_FILE)
     user = user_settings()
 
     cfg = RepoConfig()
@@ -402,7 +431,8 @@ def load_repo_config(repo_root: str | Path) -> RepoConfig:
             cfg.routing_overrides.setdefault(kind, {}).update(fields)
     from brindle import worker_models
 
-    worker_models.apply(cfg, user, str(repo_root))   # the models picked on the picker's workers screen
+    # The models picked on the picker's workers screen (the person's own profiles, for user_only).
+    worker_models.apply(cfg, user, str(repo_root), user_library=user_only)
     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):
@@ -520,15 +550,33 @@ def _sync_setting(key: str) -> None:
         pass
 
 
+_REPO_WRITE = threading.Lock()
+
+
+def _change_json(path: Path, change) -> None:
+    """Read ``path``, apply ``change`` to its dict and replace the file, one at a
+    time (daemon actions run in threads) through a unique temp file in the same
+    directory, so a reader never sees half a file and no write is lost."""
+    with _REPO_WRITE:
+        data = _read_json(path)
+        change(data)
+        fd, tmp = tempfile.mkstemp(dir=path.parent, prefix=path.name + ".", suffix=".tmp")
+        try:
+            with os.fdopen(fd, "w", encoding="utf-8") as f:
+                f.write(json.dumps(data, indent=2) + "\n")
+            os.replace(tmp, path)
+        except BaseException:
+            Path(tmp).unlink(missing_ok=True)
+            raise
+
+
 def set_local(repo_root: str | Path, key: str, value: object) -> Path:
     """Set one key in ``.brindle/config.local.json`` (gitignored: this person's
     own settings; other keys are kept)."""
     base = config_root(repo_root) / CONFIG_DIR
     base.mkdir(parents=True, exist_ok=True)
     path = base / LOCAL_CONFIG_FILE
-    data = _read_json(path)
-    data[key] = value
-    path.write_text(json.dumps(data, indent=2) + "\n", encoding="utf-8")
+    _change_json(path, lambda data: data.__setitem__(key, value))
     ignore = base / ".gitignore"
     if not ignore.exists():
         ignore.write_text(f"{LOCAL_CONFIG_FILE}\n", encoding="utf-8")
@@ -540,9 +588,24 @@ def set_repo(repo_root: str | Path, key: str, value: object) -> Path:
     everyone's settings; other keys are kept)."""
     path = scope_paths(repo_root)["repo"]
     path.parent.mkdir(parents=True, exist_ok=True)
-    data = _read_json(path)
-    data[key] = value
-    path.write_text(json.dumps(data, indent=2) + "\n", encoding="utf-8")
+    _change_json(path, lambda data: data.__setitem__(key, value))
+    return path
+
+
+def unset_local(repo_root: str | Path, key: str) -> Path:
+    """Remove one key from ``.brindle/config.local.json`` (other keys are kept),
+    so the repo's shared file or the person's own value reads through again."""
+    path = scope_paths(repo_root)["local"]
+    if path.exists():
+        _change_json(path, lambda data: data.pop(key, None))
+    return path
+
+
+def unset_repo(repo_root: str | Path, key: str) -> Path:
+    """Remove one key from the repo's committed ``.brindle/config.json``."""
+    path = scope_paths(repo_root)["repo"]
+    if path.exists():
+        _change_json(path, lambda data: data.pop(key, None))
     return path
 
 

{brindle-0.5.1 → brindle-0.5.2}/src/brindle/daemon/api-schema.json

@@ -5487,6 +5487,18 @@
           "title": "Mode",
           "type": "string"
         },
+        "name": {
+          "anyOf": [
+            {
+              "type": "string"
+            },
+            {
+              "type": "null"
+            }
+          ],
+          "default": null,
+          "title": "Name"
+        },
         "profile": {
           "title": "Profile",
           "type": "string"
@@ -6136,6 +6148,10 @@
       "method": "POST",
       "path": "/v1/providers/{provider}/login"
     },
+    {
+      "method": "POST",
+      "path": "/v1/providers/{provider}/logout"
+    },
     {
       "method": "GET",
       "path": "/v1/providers/{provider}/preflight"
@@ -6228,6 +6244,10 @@
       "method": "POST",
       "path": "/v1/sessions/{root}/pause"
     },
+    {
+      "method": "POST",
+      "path": "/v1/sessions/{root}/rename"
+    },
     {
       "method": "POST",
       "path": "/v1/sessions/{root}/transfer"

{brindle-0.5.1 → brindle-0.5.2}/src/brindle/daemon/routes_actions.py

@@ -36,7 +36,7 @@ from starlette.requests import Request
 from starlette.responses import JSONResponse
 from starlette.routing import Route
 
-from brindle import agents, autopilot, bus, git, identity_lock, knowledge, pipeline, preflight, scratch, tmux, workspaces
+from brindle import agents, autopilot, bus, gates, git, identity_lock, knowledge, pipeline, preflight, scratch, tmux, workspaces
 from brindle import sessions as sessions_mod
 from brindle.daemon import session_review as review
 from brindle.daemon import terminal
@@ -227,6 +227,7 @@ def start_session(db: DB, params: dict, body: Body) -> Any:
     sign-in or first-run screen (see brindle.preflight). Only opening a
     session that is running now launches nothing, so only that isn't checked."""
     repo, choice, session_id = _get(body, "repo", required=True), _get(body, "choice"), _get(body, "session_id")
+    name = _session_name(_get(body, "name"))     # checked with the rest, before anything launches
     opening = (choice == "o" and not _get(body, "branch") and not _get(body, "worktree")
                and any(s.root.id == session_id
                        for s in sessions_mod.live(db, workspaces.adopt_root(db, repo).repo_root)))
@@ -242,6 +243,9 @@ def start_session(db: DB, params: dict, body: Body) -> Any:
     if isinstance(got, svc.Opened):
         return {"opened": SessionDTO.from_agent(got.root).to_json()}
     if isinstance(got, svc.Started):
+        got.agent.name = name
+        if name:
+            db.update_agent(got.agent.id, name=name)
         return {**got.to_json(), "notes": _notes(got.notes)}
     return got
 
@@ -267,6 +271,19 @@ def close_session(db: DB, params: dict, body: Body) -> Any:
     return {"closed": [a.id for a, _ in closed], "stopped": [a.id for a, was in closed if was]}
 
 
+def _session_name(raw: str | None) -> str | None:
+    """A session's name as kept: whitespace collapsed, at most 80 characters, None when empty."""
+    return " ".join((raw or "").split())[:80] or None
+
+
+def rename_session(db: DB, params: dict, body: Body) -> Any:
+    """``name``: the session's new name; empty clears it (listed by its goal again)."""
+    root, _ = _root(db, params["root"])
+    name = _session_name(_get(body, "name"))
+    db.update_agent(root.id, name=name)
+    return {"id": root.id, "name": name}
+
+
 def handover_session(db: DB, params: dict, body: Body) -> Any:
     root, ws = _root(db, params["root"])
     dest = workspaces.checkout_for_target(db, ws.path, _get(body, "to", required=True))
@@ -414,7 +431,7 @@ def review_workspace(db: DB, params: dict, body: Body) -> Any:
         raise ServiceError("invalid", "only a worker's workspace (its own branch and worktree) can be reviewed")
     # With checks, a detached helper runs them first; review.submitted ends it.
     reviewer = agents.start_review(db, None, ws, _get(body, "profile"), _get(body, "focus"),
-                                   load_repo_config(ws.repo_root))
+                                   load_repo_config(ws.repo_root, branch=ws.base_branch))
     return {"reviewer": reviewer.id if reviewer else None, "checks_running": reviewer is None}
 
 
@@ -741,8 +758,8 @@ def open_session_pr(db: DB, params: dict, body: Body, auto: bool = False) -> Any
     def work(db: DB, job: Job) -> Any:
         try:
             identity_lock.ensure(root)      # again: the person signed in may have changed since
-            head = git.out(["rev-parse", "HEAD"], ws.path)
-            url = workspaces.open_pull_request(ws, title, draft, body=text)
+            with gates.pr_checked(db, ws, lambda t: bus.publish(db, "job.progress", job=job.id, text=t)) as head:
+                url = workspaces.open_pull_request(ws, title, draft, body=text, sha=head)
             if url is None and auto:
                 raise workspaces.WorkspaceError("pushed, but gh couldn't open the PR")
             if url is None:     # the person opens it from the compare page: no PR to record yet
@@ -935,17 +952,26 @@ def _fits(value: Any, default: Any) -> bool:
 def patch_config(db: DB, params: dict, body: Body) -> Any:
     """``values`` into ~/.brindle/config.json (scope "user") or the repo's
     .brindle/config.local.json (scope "repo"). Only the repo config's own
-    keys, each with a value of its default's type (or null)."""
+    keys, each with a value of its default's type (or null). Scope "shared"
+    is the repo's committed .brindle/config.json. ``unset`` (scope "repo" or
+    "shared") lists keys to remove from that file, clearing a project's
+    override."""
     from brindle import config
 
     scope = _get(body, "scope", default="user")
-    if scope not in ("user", "repo"):
-        raise ServiceError("invalid", "scope must be user or repo")
-    repo = _get(body, "repo", required=scope == "repo")
-    values = _get(body, "values", dict, required=True)
+    if scope not in ("user", "repo", "shared"):
+        raise ServiceError("invalid", "scope must be user, repo or shared")
+    repo = _get(body, "repo", required=scope != "user")
+    values = _get(body, "values", dict, default={})
+    unset = _get(body, "unset", list, default=[])
+    if unset and scope == "user":
+        raise ServiceError("invalid", "unset needs scope repo or shared")
+    if not values and not unset:
+        raise ServiceError("invalid", "values is required")
+    path = None
     defaults = config.RepoConfig()
     known = {f.name for f in dataclasses.fields(config.RepoConfig)}
-    if unknown := sorted(set(values) - known):
+    if unknown := sorted((set(values) | set(unset)) - known):
         raise ServiceError("invalid", f"unknown setting(s): {', '.join(unknown)}")
     for key, value in values.items():
         if not _fits(value, getattr(defaults, key)):
@@ -953,9 +979,13 @@ def patch_config(db: DB, params: dict, body: Body) -> Any:
     for key, value in values.items():
         if scope == "user":
             path = config.set_user(key, value)
+        elif scope == "shared":
+            path = config.set_repo(repo, key, value)
         else:
             path = config.set_local(repo, key, value)
-    return {"updated": sorted(values), "path": str(path)}
+    for key in unset:
+        path = config.unset_repo(repo, key) if scope == "shared" else config.unset_local(repo, key)
+    return {"updated": sorted({*values, *unset}), "path": str(path)}
 
 
 # -- knowledge sources (brindle kb add / sync / remove) -----------------------------
@@ -1093,7 +1123,8 @@ def put_routing(db: DB, params: dict, body: Body) -> Any:
     lock_changes: dict[str, bool] = {}
     overrides: dict[str, dict[str, str | None]] = {}    # kind -> effort / instructions (None clears)
     extra: dict[str, Any] = {}      # supervisor and reviewer settings the kinds ask for
-    current = config.load_repo_config(repo).routing
+    # A user-scope change builds on the person's own lists and library, never this repo's.
+    current = config.load_repo_config(repo, user_only=scope == "user").routing
     for kind, spec in kinds.items():
         if kind not in config.ROUTING_KINDS or not isinstance(spec, dict):
             raise ServiceError("invalid", f"kind must be one of {', '.join(config.ROUTING_KINDS)}, not {kind!r}")
@@ -1131,7 +1162,7 @@ def put_routing(db: DB, params: dict, body: Body) -> Any:
                 extra["supervisor_profile"] = model
             if fallbacks is not None:
                 extra["supervisor_fallbacks"] = list(dict.fromkeys(fallbacks))
-    by_name = {p.name: p for p in profiles.list_profiles(repo)}
+    by_name = {p.name: p for p in profiles.list_profiles(None if scope == "user" else repo)}
     known = set(by_name)
     named = [reviewer] if reviewer is not None else []
     for value in extra.values():     # supervisor and reviewer choices and fallbacks are profiles too
@@ -1146,7 +1177,7 @@ def put_routing(db: DB, params: dict, body: Body) -> Any:
         raise ServiceError("invalid", f"no such profile(s): {', '.join(unknown)}")
     if excluded is not None and (bad := sorted(set(map(str, excluded)) - set(providers.PROVIDERS))):
         raise ServiceError("invalid", f"no such provider(s): {', '.join(bad)}")
-    policy = RoutingPolicy.load(repo)
+    policy = RoutingPolicy.load(repo, user_library=scope == "user")
     if policy.applies and policy.access.error:
         raise ServiceError("forbidden", f"routing can't be changed now: {policy.access.error}", 403)
     for name in dict.fromkeys(named):
@@ -1694,6 +1725,20 @@ def turn_off_provider(db: DB, params: dict, body: Body) -> Any:
     return providers_install.turn_off(_known_provider(params))
 
 
+def provider_logout(db: DB, params: dict, body: Body) -> Any:
+    """Sign brindle's own copy of the provider out (Claude Code, Codex only);
+    the person's own CLI login is not touched. Answers the provider's row."""
+    from brindle import providers_install
+
+    provider = _known_provider(params)
+    if provider not in providers_install.SIGN_OUT:
+        raise ServiceError("invalid", f"sign out is offered for {', '.join(providers_install.SIGN_OUT)}")
+    try:
+        return providers_install.sign_out(provider)
+    except providers_install.InstallError as e:
+        raise ServiceError("logout_failed", str(e), 422) from None
+
+
 def terminal_input(db: DB, params: dict, body: Body) -> Any:
     """Type ``text``, one line the person typed or pasted in the app (a
     sign-in's code), into the action terminal ``id``, then Enter unless
@@ -1922,6 +1967,7 @@ ROUTES = [
     _post("/sessions/{root}/continue", continue_session),
     _post("/sessions/{root}/pause", pause_session),
     _post("/sessions/{root}/close", close_session),
+    _post("/sessions/{root}/rename", rename_session),
     _post("/sessions/{root}/handover", handover_session),
     _post("/sessions/{root}/transfer", transfer_session),
     # GET on the file path reads (routes_read); agent callers are refused by the guard.
@@ -1977,6 +2023,7 @@ ROUTES = [
     # Like every route, refused to agent callers by the guard.
     _post("/providers/{provider}/login", provider_login),
     _post("/providers/{provider}/preflight", profile_preflight),
+    _post("/providers/{provider}/logout", provider_logout),
     _post("/providers/{provider}/trust", provider_trust),
     _post("/providers/{provider}/consent", provider_consent),
     _post("/providers/{provider}/install", install_provider),