graphban-cli 0.8.8__tar.gz → 0.8.10__tar.gz

{graphban_cli-0.8.8 → graphban_cli-0.8.10}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: graphban-cli
-Version: 0.8.8
+Version: 0.8.10
 Summary: gban — a Graphban client for the human at a terminal
 Project-URL: Homepage, https://github.com/asc-me/graphban
 Project-URL: Repository, https://github.com/asc-me/graphban

{graphban_cli-0.8.8 → graphban_cli-0.8.10}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "graphban-cli"
-version = "0.8.8"
+version = "0.8.10"
 description = "gban — a Graphban client for the human at a terminal"
 readme = "README.md"
 requires-python = ">=3.12"

{graphban_cli-0.8.8 → graphban_cli-0.8.10}/src/gban/cli.py

@@ -551,6 +551,30 @@ def cmd_stack(args) -> int:
     return 0
 
 
+ADAPTER_ENV = "GBAN_ADAPTER"
+
+
+def _until_with_adapter(rest: list[str]) -> list[str] | None:
+    """`gbfleet until` requires --adapter; Triage's drain note shows the command without it.
+
+    Fill it from the flag (already there), $GBAN_ADAPTER, the settings file's `adapter`, or
+    `claude` when that binary is on PATH. Otherwise say which value is missing and how to set
+    it, rather than letting argparse print usage. Only args before a `--` are ours to read.
+    """
+    own = rest[:rest.index("--")] if "--" in rest else rest
+    if any(a == "--adapter" or a.startswith("--adapter=") for a in own):
+        return rest
+    adapter = (os.environ.get(ADAPTER_ENV) or config.settings().get("adapter") or "").strip()
+    if not adapter and shutil.which("claude"):
+        adapter = "claude"
+    if not adapter:
+        print(f"{PROG}: `{PROG} fleet until` needs --adapter (the agent vendor to run, e.g. "
+              f"claude) and none is configured. Pass --adapter <vendor>, set ${ADAPTER_ENV}, "
+              f"or add \"adapter\" to {config.home() / config.SETTINGS_FILE}.", file=sys.stderr)
+        return None
+    return [rest[0], "--adapter", adapter, *rest[1:]]
+
+
 def cmd_fleet(args) -> int:
     """A subprocess, never an import (D5).
 
@@ -576,6 +600,10 @@ def cmd_fleet(args) -> int:
     rest = list(args.rest)
     if rest[:1] == ["--"]:
         rest = rest[1:]
+    if rest[:1] == ["until"]:
+        rest = _until_with_adapter(rest)
+        if rest is None:
+            return EXIT_REFUSED
     argv = [binary, *rest]
     url = config.resolve(args.server, config.URL_ENV, "url")
     if url and "--server" not in argv:

{graphban_cli-0.8.8 → graphban_cli-0.8.10}/src/gban/doctor.py

@@ -11,6 +11,7 @@ the same reason: "we could not tell" must never render as "nothing is wrong".
 """
 from __future__ import annotations
 
+import json
 import os
 import shutil
 import subprocess
@@ -408,10 +409,51 @@ def playbooks_line(result: dict | None) -> dict | None:
     return _line("local", PASS, "playbooks", f"polled just now — {note}")
 
 
+def harness_entries(repo: Path) -> list[dict]:
+    """Does each harness config that exists still declare the graphban MCP entry?
+
+    `gban setup` writes the entry and says so once; nothing re-reads it. Remove it and Claude
+    Code can no longer reach the ledger while every server-side check stays PASS. A harness
+    counts as configured when one of its files exists; a missing file is not checked (never
+    set up here), a file without the entry is a FAIL named after the file.
+    """
+    import tomllib
+    from gban import setup  # lazy: setup imports this module
+
+    server = setup.LEDGER_SERVER
+    key = str(repo.resolve())
+
+    def read(path: Path, toml: bool):
+        try:
+            text = path.read_text(encoding="utf-8")
+            return tomllib.loads(text) if toml else json.loads(text)
+        except (OSError, ValueError):
+            return None  # unreadable counts as lacking the entry
+
+    claude = [(setup.claude_home(), lambda b: (((b.get("projects") or {}).get(key) or {})
+                                                .get("mcpServers") or {})),
+              (repo / ".mcp.json", lambda b: b.get("mcpServers") or {})]
+    grok = [(setup.grok_home(), lambda b: b.get("mcp_servers") or {}),
+            (repo / ".grok" / "config.toml", lambda b: b.get("mcp_servers") or {})]
+    out: list[dict] = []
+    for harness, files, toml in (("claude", claude, False), ("grok", grok, True)):
+        present = [(p, pick) for p, pick in files if p.exists()]
+        if not present:
+            continue
+        if any(server in pick(read(p, toml) or {}) for p, pick in present):
+            out.append(_line("local", PASS, f"{harness} mcp", f"{server} entry present"))
+        else:
+            names = ", ".join(str(p) for p, _ in present)
+            out.append(_line("local", FAIL, f"{harness} mcp",
+                             f"no {server} entry for this project in {names} — "
+                             f"{harness} cannot reach the ledger; run `gban setup`"))
+    return out
+
+
 def run(url: str, project: str, api_key: str = "",
         repo: Path | None = None) -> tuple[list[dict], int]:
     lines = (ledger(url, project) + local(url, project, api_key)
-             + gitignore.check(repo or Path.cwd()))
+             + gitignore.check(repo or Path.cwd()) + harness_entries(repo or Path.cwd()))
     worst = max((SEVERITY[l["status"]] for l in lines), default=0)
     # FAIL exits 1, UNKNOWN exits 0: "could not check" is not "broken", and a doctor that
     # failed a script because a laptop lacked `gbfleet` would stop being run.

{graphban_cli-0.8.8 → graphban_cli-0.8.10}/src/gban/playbooks.py

@@ -6,6 +6,7 @@ Every `gban` command may poll `/health`; `gban update` always does. The receipt
 """
 from __future__ import annotations
 
+import fnmatch
 import hashlib
 import json
 import os
@@ -24,6 +25,31 @@ INTERVAL = 3600
 SKILL_DIRS = (".claude/skills", ".grok/skills", ".agents/skills")
 
 
+#: What a pack entry may write, per `kind` (GRPH-P65 table). `*` is one path segment. Anything
+#: else (settings, AGENTS.md, MCP config, .git/hooks) is refused and the whole pack is dropped.
+ALLOWED = {
+    "skill": tuple(f"{b}/*/SKILL.md" for b in SKILL_DIRS),
+    "loop": (".cursor/agents/*", ".claude/agents/*", ".codex/agents/*", ".cursor/rules/*.mdc"),
+    "playbook": (".cursor/plugins/graphban/skills/*/SKILL.md",),
+    "hook": (".cursor/hooks.json", ".cursor/hooks/gb_after_file_edit.py",
+             ".cursor/hooks/gb_claim_manifest.py", ".cursor/hooks/gb_session_start.py",
+             ".cursor/hooks/gb_stop.py", ".grok/hooks/graphban-claim-manifest.json"),
+}
+
+
+def allowed(kind: object, rel: object) -> bool:
+    """True when `rel` is a path the pack may write for this `kind`."""
+    if not isinstance(kind, str) or kind not in ALLOWED or not isinstance(rel, str):
+        return False
+    parts = rel.split("/")
+    for pat in ALLOWED[kind]:
+        want = pat.split("/")
+        if len(want) == len(parts) and all(
+                fnmatch.fnmatchcase(g, w) and (w != "*" or g) for g, w in zip(parts, want)):
+            return True
+    return False
+
+
 def targets(entry: dict) -> list[str]:
     """Every checkout path one pack entry is written to."""
     rel = entry.get("path")
@@ -61,6 +87,17 @@ def _sha(data: bytes) -> str:
     return hashlib.sha256(data).hexdigest()
 
 
+def record(repo: Path, written: dict[str, bytes]) -> None:
+    """Note files this tool wrote outside a poll (setup's skills), so a later pack replaces them
+    like any file we wrote. Keeps every other receipt field."""
+    receipt = _read(repo)
+    files = dict(receipt.get("files") or {})
+    for rel, data in written.items():
+        files[rel] = _sha(data)
+    receipt["files"] = files
+    _save(repo, receipt)
+
+
 def when(ts: float) -> str:
     return time.strftime("%Y-%m-%d %H:%M:%SZ", time.gmtime(ts))
 
@@ -128,14 +165,17 @@ def poll(url: str, repo: Path, *, force: bool = False, client: Client | None = N
     if not isinstance(health, dict):
         return {"polled": False, "failed": True, "note": "unreadable /health"}
     sha = str(health.get("git_sha") or "").strip()
-    # A different server never inherits the old server's applied sha or file hashes.
-    base = receipt if receipt.get("server") == url else {}
-    new = {"server": url, "polled_at": now, "git_sha": base.get("git_sha", ""),
-           "files": base.get("files", {})}
+    # A different server never inherits the old server's stamp or applied sha. File hashes
+    # describe what this tool wrote to disk, whichever server sent it, so they stay owned.
+    same = receipt.get("server") in (url, None)
+    base = {"git_sha": receipt.get("git_sha", "") if same else "",
+            "files": receipt.get("files", {})}
+    new = {"server": url, "polled_at": now, "git_sha": base["git_sha"],
+           "files": base["files"]}
     if not sha:
         _save(repo, new)
         return {"polled": True, "polled_at": now, "note": "deployment is unstamped (empty git_sha)"}
-    if sha == base.get("git_sha"):
+    if sha == base.get("git_sha") and not force:
         _save(repo, new)
         return {"polled": True, "polled_at": now, "git_sha": sha, "note": f"current at {sha[:12]}"}
     try:
@@ -170,6 +210,10 @@ def poll(url: str, repo: Path, *, force: bool = False, client: Client | None = N
                     or ".." in Path(rel).parts or Path(rel).is_absolute():
                 return {"polled": False, "failed": True,
                         "note": "unreadable pack; wrote nothing"}
+            if not allowed(entry.get("kind"), rel):
+                return {"polled": False, "failed": True,
+                        "note": f"pack names a path outside its allowed directories: {rel}; "
+                                "wrote nothing"}
             plan[rel] = body.encode("utf-8")
     applied = apply(repo, plan, dict(base.get("files", {})))
     owned, written, kept = applied["files"], applied["written"], applied["kept"]

{graphban_cli-0.8.8 → graphban_cli-0.8.10}/src/gban/setup.py

@@ -425,6 +425,12 @@ def verify(url: str, key: str, project: str) -> list[dict]:
                      f"{project} is writable" if project in writable else
                      f"the key cannot write {project} — you can read it but not write it, so "
                      "an agent on this key can claim nothing"))
+    if "key_project_id" in ctx and ctx["key_project_id"] != project:
+        # `gbfleet until` refuses a key with no project to bind its minted-by check to
+        # (GRPH-1658), so a reused cross-project key fails the Triage drain command.
+        out.append(_line("ledger", FAIL, "scope",
+                         "the key is not scoped to this project, and `gban fleet until` "
+                         "refuses an unscoped key"))
     missing = {_tier_id(t) for t in (ctx.get("missing_tiers") or [])}
     out.append(_line("ledger", PASS if "fleet" not in missing else FAIL, "fleet tools",
                      "delegate and mint_enrolment are in the manifest" if "fleet" not in missing
@@ -495,9 +501,10 @@ def run(client: Client, url: str, project: str, repo: Path, *, scope: str = "use
         # A key that cannot do the job is replaced, never patched: `tool_tiers` are fixed at
         # mint and there is no route that changes them.
         lines.append(_line("config", UNKNOWN, "credential",
-                           "the configured credential no longer works (revoked, or it cannot "
-                           "delegate), so a new one is being minted; if the old one still "
-                           "works, remove it in Settings → API keys"))
+                           "the configured credential no longer works (revoked, cannot "
+                           "delegate, or not scoped to this project), so a project-scoped "
+                           "one is being minted; if the old one still works, remove it in "
+                           "Settings → API keys"))
     if not key:
         try:
             minted = mint(client, project)
@@ -651,13 +658,29 @@ def install_skill(repo: Path, slug: str = SKILL_SLUG) -> list[tuple[str, Path]]:
     saying so. A dest that differs does not block the other directories."""
     body = skill_source(slug).read_text(encoding="utf-8")
     out = []
+    from . import playbooks
+    owned = playbooks._read(repo).get("files") or {}
     for dest in skill_dests(repo, slug):
         if dest.exists():
-            out.append(("same" if dest.read_text(encoding="utf-8") == body else "differs", dest))
+            if dest.read_text(encoding="utf-8") == body:
+                status = "same"
+            elif dest.is_file() and owned.get(dest.relative_to(repo).as_posix()) == \
+                    playbooks._sha(dest.read_bytes()):
+                # The server pack wrote this exact body (the receipt says so): it is newer
+                # than the wheel's copy, not a local edit, and the pack keeps it fresh.
+                status = "same"
+            else:
+                status = "differs"
+            out.append((status, dest))
             continue
         dest.parent.mkdir(parents=True, exist_ok=True)
         dest.write_text(body, encoding="utf-8")
         out.append(("written", dest))
+    # Receipt the files we planted, so the pack refreshes them instead of freezing them as edits.
+    planted = {d.relative_to(repo).as_posix(): d.read_bytes() for st, d in out if st == "written"}
+    if planted:
+        from . import playbooks
+        playbooks.record(repo, planted)
     return out
 
 

{graphban_cli-0.8.8 → graphban_cli-0.8.10}/src/gban/skills/graphban-answer/SKILL.md

@@ -41,10 +41,10 @@ Sources, in order. A later source does not override an earlier one. Quote the se
 
 Leave wait:secret, wait:access, wait:deploy, and wait:merge blocked. Name them.
 
-A quote: evidence on the wait, kind note, the sentence and where it came from. update_item status=done on the wait only.
+A quote: answer_wait(wait, answer, source={kind: session|prd|memory|decision, ref, quote}). ref is the PRD key, shard id or decision key; it must resolve. It stores the answer and releases the original. Never update_item the wait to done: that is refused without a stored answer.
 Do not update_prd. Do not answer_grill. Do not move the original item. Do not publish_memory.
 
-No quote: print the question, your recommendation, and one line on why the sources do not decide. Leave the wait blocked.
+No quote: answer_wait(wait, needs_person=true), then print the question, your recommendation, and one line on why the sources do not decide. The wait stays blocked.
 
 Do not spawn, merge, sign_off, bounce, or claim.
 ```
@@ -82,11 +82,11 @@ Silence is ask. A conflict is ask. Two reasonable readings are ask. A new contra
 
 A `--prd` drain answers a wait whose `prd_id` matches, or whose dependency link has `b` this wait and `a` an item on that PRD. Leave every other wait.
 
-The original is `a` on that dependency link. You are not its builder. Leave it blocked. Marking the wait `done` returns it to `next` when no other unmet dependency remains.
+The original is `a` on that dependency link. You are not its builder. Leave it blocked. `answer_wait` returns it to `next` when no other unmet dependency remains. You cannot answer a wait your own agent filed.
 
 ## Quote
 
-The answer is the quoted sentence and where it came from. When the quote is a related decision, the note also names the one step. `update_item` on the wait: evidence `kind` `note` with that sentence, then `status=done`.
+The answer is the quoted sentence and where it came from. When the quote is a related decision, the note also names the one step. `answer_wait` with `answer` (or `option`) and `source` `{kind, ref, quote}`: `kind` is `session`, `prd`, `memory` or `decision`; `ref` must resolve for the last three; `quote` is the sentence. Never move a wait to done with `update_item`.
 
 A decision that should outlive the item: `add_memory`, scope `global`. Read the returned `status`. Leave a `candidate`. Do not `publish_memory`.
 
@@ -94,7 +94,7 @@ A decision that should outlive the item: `add_memory`, scope `global`. Read the
 
 One question. The question, your recommendation, and one line on why the sources do not decide it.
 
-Record nothing until the user answers. Their words are the evidence, then the wait is `done`. The recommendation alone is not the answer.
+Call `answer_wait` with `needs_person=true`; it records no answer. When the user answers, call `answer_wait` with their words and `source` kind `session`. The recommendation alone is not the answer.
 
 A scheduler fire that must ask prints that question and leaves the wait blocked. The parent session puts it to the user.
 

{graphban_cli-0.8.8 → graphban_cli-0.8.10}/tests/test_doctor.py

@@ -724,7 +724,7 @@ def test_doctor_passes_when_the_paths_are_ignored(home, monkeypatch, tmp_path):
     repo = tmp_path / "repo"
     _git_init(repo)
     gitignore.ensure(repo)
-    (repo / ".mcp.json").write_text("{}\n", encoding="utf-8")
+    (repo / ".mcp.json").write_text('{"mcpServers": {"graphban": {}}}\n', encoding="utf-8")
     monkeypatch.setattr(doctor, "authenticated", lambda url: _Server())
     monkeypatch.setattr(doctor, "find_supervisor", lambda: "")
 
@@ -815,3 +815,21 @@ def test_can_supervise_posts_a_validating_probe_and_reads_only_403_and_404(monke
         answer["code"] = code
         assert doctor.can_supervise("http://gb.invalid", "gb_sk_X") is want, code
     assert doctor.can_supervise("file:///etc/passwd", "gb_sk_X") is None
+
+
+def test_doctor_fails_when_the_graphban_entry_is_gone_from_claude_json(home, monkeypatch):
+    """gban setup wrote the entry; removing it must not leave doctor all-PASS."""
+    monkeypatch.setattr(doctor, "authenticated", lambda url: _Server())
+    monkeypatch.setattr(doctor, "find_supervisor", lambda: "")
+    cfg = home / "claude.json"
+    cfg.write_text(json.dumps({"projects": {str(home.resolve()): {
+        "mcpServers": {"graphban": {"command": "x"}}}}}), encoding="utf-8")
+    lines, code = doctor.run("http://gb.invalid", "core", "", repo=home)
+    assert [l["status"] for l in lines if l["name"] == "claude mcp"] == ["PASS"]
+
+    cfg.write_text(json.dumps({"projects": {str(home.resolve()): {"mcpServers": {}}}}),
+                   encoding="utf-8")
+    lines, code = doctor.run("http://gb.invalid", "core", "", repo=home)
+    found = [l for l in lines if l["name"] == "claude mcp"]
+    assert code == 1 and found[0]["status"] == "FAIL"
+    assert str(cfg) in found[0]["detail"]

graphban_cli-0.8.10/tests/test_fleet_until.py

@@ -0,0 +1,54 @@
+"""GRPH-1656 — the command Triage's drain note shows must start a drain as copied."""
+from __future__ import annotations
+
+import shlex
+
+import pytest
+
+from gban import config
+from gban.cli import main
+
+
+@pytest.fixture()
+def seen(tmp_path, monkeypatch):
+    monkeypatch.setenv(config.HOME_ENV, str(tmp_path))
+    monkeypatch.delenv("GBAN_ADAPTER", raising=False)
+    monkeypatch.delenv("GBFLEET_API_KEY", raising=False)
+    monkeypatch.setattr("gban.cli.doctor_mod.find_supervisor", lambda: "/usr/bin/gbfleet")
+    out = {}
+
+    class Done:
+        returncode = 0
+
+    monkeypatch.setattr("gban.cli.subprocess.run",
+                        lambda argv, **kw: (out.update(argv=argv), Done())[1])
+    return out
+
+
+def test_drain_note_command_reaches_until_with_an_adapter(seen, monkeypatch):
+    monkeypatch.setenv("GBAN_ADAPTER", "claude")
+    cmd = "gban fleet until --prd P75W-P1"  # the string waits.drain_note emits
+    assert main(shlex.split(cmd)[1:]) == 0
+    argv = seen["argv"]
+    assert argv[1] == "until" and argv[argv.index("--adapter") + 1] == "claude"
+    assert "--prd" in argv
+
+
+def test_adapter_falls_back_to_claude_on_path(seen, monkeypatch):
+    monkeypatch.setattr("gban.cli.shutil.which", lambda n: "/bin/claude" if n == "claude" else None)
+    assert main(["fleet", "until", "--prd", "X"]) == 0
+    assert "claude" in seen["argv"]
+
+
+def test_explicit_adapter_is_left_alone(seen, monkeypatch):
+    monkeypatch.setenv("GBAN_ADAPTER", "claude")
+    assert main(["fleet", "until", "--adapter", "grok", "--prd", "X"]) == 0
+    assert seen["argv"].count("--adapter") == 1 and "grok" in seen["argv"]
+
+
+def test_unknown_adapter_names_what_to_set(seen, monkeypatch, capsys):
+    monkeypatch.setattr("gban.cli.shutil.which", lambda n: None)
+    assert main(["fleet", "until", "--prd", "X"]) != 0
+    err = capsys.readouterr().err
+    assert "--adapter" in err and "GBAN_ADAPTER" in err
+    assert "argv" not in seen

{graphban_cli-0.8.8 → graphban_cli-0.8.10}/tests/test_playbooks.py

@@ -82,21 +82,21 @@ def test_same_sha_does_not_download(tmp_path):
 
 def test_ownership(tmp_path):
     def pack(sha_, body):
-        return {"git_sha": sha_, "files": [{"path": "s/a.md", "body": body},
-                                           {"path": "s/b.md", "body": "B"}]}
+        return {"git_sha": sha_, "files": [{"path": ".claude/agents/a.md", "kind": "loop", "body": body},
+                                           {"path": ".claude/agents/b.md", "kind": "loop", "body": "B"}]}
     poll(URL, tmp_path, client=Fake({"git_sha": "1"}, pack("1", "A1")), now=0)
-    (tmp_path / "s/b.md").write_text("edited")
+    (tmp_path / ".claude/agents/b.md").write_text("edited")
     r = poll(URL, tmp_path, client=Fake({"git_sha": "2"}, pack("2", "A2")), now=5000)
-    assert (tmp_path / "s/a.md").read_text() == "A2"
-    assert (tmp_path / "s/b.md").read_text() == "edited" and "s/b.md" in r["note"]
+    assert (tmp_path / ".claude/agents/a.md").read_text() == "A2"
+    assert (tmp_path / ".claude/agents/b.md").read_text() == "edited" and ".claude/agents/b.md" in r["note"]
 
 
 def test_pack_is_fetched_with_the_credential_not_the_bare_client(tmp_path):
     bare = Fake({"git_sha": "a"}, Refused(401, "authentication required"))
-    authed = Fake(None, {"git_sha": "a", "files": [{"path": "s/a.md", "body": "A"}]})
+    authed = Fake(None, {"git_sha": "a", "files": [{"path": ".claude/agents/a.md", "kind": "loop", "body": "A"}]})
     r = playbooks.poll(URL, tmp_path, client=bare, auth=lambda: authed, now=1000)
     assert bare.calls == ["/health"] and authed.calls == ["/api/playbooks"]
-    assert (tmp_path / "s/a.md").read_text() == "A"
+    assert (tmp_path / ".claude/agents/a.md").read_text() == "A"
     assert r["polled"] and receipt(tmp_path)["git_sha"] == "a"
 
 
@@ -248,6 +248,22 @@ def test_restoring_an_edit_is_delete_and_update(tmp_path):
     assert (tmp_path / LOOP).read_text() == "L1" and LOOP in r["written"]
 
 
+def test_update_restores_a_deleted_edit_when_the_sha_is_unchanged(tmp_path):
+    _apply(tmp_path, "1", 0)
+    (tmp_path / LOOP).write_text("mine")
+    r = _apply(tmp_path, "2", 5000, loop="L2")
+    assert r["kept"] == [LOOP] and (tmp_path / LOOP).read_text() == "mine"
+    (tmp_path / LOOP).unlink()
+    # An ordinary poll past the hour at the same sha downloads nothing.
+    fake = Fake({"git_sha": "2"}, _pack("2", loop="L2"))
+    poll(URL, tmp_path, client=fake, now=10000)
+    assert not (tmp_path / LOOP).exists()
+    # `gban update` (force) applies even though the sha is unchanged.
+    r = poll(URL, tmp_path, client=fake, now=10001, force=True)
+    assert (tmp_path / LOOP).read_text() == "L2" and LOOP in r["written"]
+    assert receipt(tmp_path)["files"][LOOP] == sha("L2")
+
+
 def test_a_path_the_pack_dropped_is_left_on_disk_and_named(tmp_path):
     extra = [{"path": ".claude/agents/gb-old.md", "kind": "loop", "body": "old"}]
     _apply(tmp_path, "1", 0, extra=extra)
@@ -323,3 +339,79 @@ def test_a_foreign_hooks_json_is_left_and_named_while_the_scripts_are_written(tm
     assert HOOKS_JSON in r["kept"] and HOOKS_JSON in r["note"]
     assert HOOKS_JSON not in receipt(tmp_path)["files"]
     assert (tmp_path / HOOK).read_text() == "H1"
+
+
+def _planted(tmp_path, monkeypatch):
+    from gban import setup as setup_mod
+    src = tmp_path / "wheel" / "SKILL.md"
+    src.parent.mkdir()
+    src.write_text("wheel v1")
+    monkeypatch.setattr(setup_mod, "skill_source", lambda slug="graphban-work": src)
+    repo = tmp_path / "repo"
+    repo.mkdir()
+    setup_mod.install_skill(repo, "graphban-work")
+    return repo
+
+
+def test_a_skill_setup_planted_is_refreshed_by_the_pack(tmp_path, monkeypatch):
+    repo = _planted(tmp_path, monkeypatch)
+    assert receipt(repo)["files"][SKILL] == sha("wheel v1")
+    r = _apply(repo, "2", 5000, skill="S2")
+    assert r["kept"] == []
+    for rel in COPIES:
+        assert (repo / rel).read_text() == "S2"
+        assert receipt(repo)["files"][rel] == sha("S2")
+
+
+def test_a_skill_setup_planted_then_edited_is_left_and_named(tmp_path, monkeypatch):
+    repo = _planted(tmp_path, monkeypatch)
+    (repo / SKILL).write_text("mine")
+    r = _apply(repo, "2", 5000, skill="S2")
+    assert r["kept"] == [SKILL]
+    assert (repo / SKILL).read_text() == "mine"
+    assert (repo / COPIES[2]).read_text() == "S2"
+
+
+def test_switching_server_keeps_file_ownership(tmp_path):
+    other = "http://other.example"
+    poll(URL, tmp_path, client=Fake({"git_sha": "1"}, _pack("1")), now=0)
+    poll(other, tmp_path, client=Fake({"git_sha": "1"}, _pack("1")), now=10)
+    r = poll(URL, tmp_path, client=Fake({"git_sha": "2"}, _pack("2", skill="S2")), now=20)
+    assert r["polled"] is True and not r.get("kept")
+    for rel in COPIES:
+        assert (tmp_path / rel).read_text() == "S2"
+
+
+def test_switching_server_still_leaves_a_local_edit(tmp_path):
+    other = "http://other.example"
+    poll(URL, tmp_path, client=Fake({"git_sha": "1"}, _pack("1")), now=0)
+    (tmp_path / LOOP).write_text("mine")
+    poll(other, tmp_path, client=Fake({"git_sha": "1"}, _pack("1")), now=10)
+    r = poll(URL, tmp_path, client=Fake({"git_sha": "2"}, _pack("2", loop="L2")), now=20)
+    assert (tmp_path / LOOP).read_text() == "mine" and r["kept"] == [LOOP]
+
+
+# --- GRPH-1534: the client only writes the pack's allowed directories ----------------------
+
+@pytest.mark.parametrize("kind,path", [
+    ("loop", ".claude/settings.json"), ("loop", "AGENTS.md"), ("loop", "CLAUDE.md"),
+    ("loop", ".git/hooks/pre-commit"), ("loop", ".mcp.json"),
+    ("skill", ".claude/skills/x/other.md"), ("loop", ".claude/agents/a/b.md"),
+    ("hook", ".git/hooks/pre-commit"), ("bogus", ".claude/agents/ok.md"), (None, LOOP),
+])
+def test_a_path_outside_the_allowlist_writes_nothing(tmp_path, kind, path):
+    pack = _pack("1")
+    pack["files"].append({"path": path, "kind": kind, "body": "x"})
+    r = poll(URL, tmp_path, client=Fake({"git_sha": "1"}, pack), now=0)
+    assert r.get("failed")
+    if kind in ("loop", "hook"):
+        assert path in r["note"]
+    assert not any(p.is_file() for p in tmp_path.rglob("*"))
+
+
+def test_the_real_pack_passes_the_allowlist():
+    from pathlib import Path
+    real = Path(__file__).resolve().parents[2] / "backend/scripts/gban_playbooks.json"
+    for e in json.loads(real.read_text())["files"]:
+        for rel in playbooks.targets(e):
+            assert playbooks.allowed(e["kind"], rel), (e["kind"], rel)

{graphban_cli-0.8.8 → graphban_cli-0.8.10}/tests/test_setup.py

@@ -59,7 +59,8 @@ class Server:
     """Mints, and answers `get_context` as the deployed one does."""
 
     def __init__(self, *, writable=("core",), missing=(), refuse=None, issued=(),
-                 missing_for=None):
+                 missing_for=None, scope_for=None):
+        self.scope_for = dict(scope_for or {})
         self.writable, self.missing, self.refuse = list(writable), list(missing), refuse
         self.missing_for = dict(missing_for or {})
         self.minted = []
@@ -92,6 +93,7 @@ def _context(server):
             raise Refused(401, "invalid api key", "")
         missing = server.missing_for.get(self.api_key, server.missing)
         ctx = {"project_id": "core", "writable_projects": server.writable,
+               "key_project_id": server.scope_for.get(self.api_key, "core"),
                "missing_tiers": [{"tier": t} for t in missing]}
         return {"result": {"content": [{"text": json.dumps(ctx)}]}}
     return call
@@ -571,6 +573,27 @@ def test_an_edited_skill_is_left_alone(tmp_path, wired):
     assert other.read_text() == setup_mod.skill_source("watch-wave").read_text()
 
 
+def test_a_pack_written_skill_that_differs_from_the_bundled_one_is_not_unknown(tmp_path, wired):
+    """GRPH-1543: the pack just wrote a newer skill than the wheel carries. Setup must not
+    flag a file the same command wrote."""
+    from gban import playbooks
+    repo, home = tmp_path / "repo", tmp_path / ".claude.json"
+    repo.mkdir()
+    planted = {}
+    for rel in setup_mod.SKILL_DEST_DIRS:
+        dest = repo / rel / "graphban-delegation" / "SKILL.md"
+        dest.parent.mkdir(parents=True)
+        dest.write_bytes(b"newer pack copy\n")
+        planted[dest.relative_to(repo).as_posix()] = b"newer pack copy\n"
+    playbooks.record(repo, planted)
+
+    lines, _, _ = _run(Server(), repo, home, wired=wired)
+
+    assert not any("left alone" in l["detail"] for l in lines)
+    assert not any(l.get("name") == "skill" and l.get("status") == "UNKNOWN" for l in lines)
+    assert dest.read_bytes() == b"newer pack copy\n"
+
+
 def test_the_skill_tells_the_agent_the_two_things_it_cannot_work_out(tmp_path):
     """Both are failures that read as something else. A missing tier reads as the tool not
     existing; a missing session reads as something to retry, when the remedy is a person at a
@@ -1434,3 +1457,27 @@ def test_the_image_manifest_lists_the_shipped_skills():
     manifest = json.loads((root / "backend/scripts/gban_skills.json").read_text())
     shipped = {p.name for p in (root / "cli/src/gban/skills").iterdir() if p.is_dir()}
     assert set(manifest["skills"]) == shipped
+
+
+def test_unscoped_configured_key_is_replaced_by_a_project_scoped_mint(tmp_path, wired):
+    """GRPH-1658: `until` refuses an unscoped key, so setup must not reuse one."""
+    repo, home = tmp_path / "repo", tmp_path / ".claude.json"
+    repo.mkdir()
+    server = Server(issued={"gb_sk_old"}, scope_for={"gb_sk_old": None})
+    home.write_text(json.dumps({"projects": {str(repo.resolve()): {"mcpServers": {
+        "graphban": {"type": "http", "url": URL, "headers": {"X-API-Key": "gb_sk_old"}}}}}}))
+    lines, code, made = _run(server, repo, home, wired=wired)
+    assert code == 0, lines
+    assert len(server.minted) == 1 and server.minted[0]["project_id"] == "core"
+    assert config.stored_supervisor_key("core") == "gb_sk_new1"
+
+
+def test_project_scoped_configured_key_is_still_reused(tmp_path, wired):
+    repo, home = tmp_path / "repo", tmp_path / ".claude.json"
+    repo.mkdir()
+    server = Server(issued={"gb_sk_old"})
+    home.write_text(json.dumps({"projects": {str(repo.resolve()): {"mcpServers": {
+        "graphban": {"type": "http", "url": URL, "headers": {"X-API-Key": "gb_sk_old"}}}}}}))
+    lines, code, made = _run(server, repo, home, wired=wired)
+    assert code == 0, lines
+    assert server.minted == [] and made.get("reused")

{graphban_cli-0.8.8 → graphban_cli-0.8.10}/uv.lock

@@ -124,7 +124,7 @@ wheels = [
 
 [[package]]
 name = "graphban-cli"
-version = "0.8.8"
+version = "0.8.10"
 source = { editable = "." }
 
 [package.optional-dependencies]