ccherd 0.1.0__tar.gz

ccherd-0.1.0/.github/workflows/release.yml

@@ -0,0 +1,21 @@
+name: release
+
+# Publishes to PyPI when a version tag is pushed. Uses PyPI trusted publishing:
+# register this repo and workflow once under the project's "Publishing" settings
+# on pypi.org; no token is stored here.
+on:
+  push:
+    tags: ["v*"]
+
+jobs:
+  pypi:
+    runs-on: ubuntu-latest
+    environment: pypi
+    permissions:
+      contents: read
+      id-token: write
+    steps:
+      - uses: actions/checkout@v4
+      - uses: astral-sh/setup-uv@v6
+      - run: uv build
+      - run: uv publish

ccherd-0.1.0/.github/workflows/test.yml

@@ -0,0 +1,21 @@
+name: test
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+
+jobs:
+  test:
+    strategy:
+      matrix:
+        os: [ubuntu-latest, macos-latest]
+        python: ["3.10", "3.13"]
+    runs-on: ${{ matrix.os }}
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-python@v5
+        with:
+          python-version: ${{ matrix.python }}
+      - run: PYTHONPATH=src python -m unittest discover -s tests -v
+      - run: pip install . && ccherd --version

ccherd-0.1.0/.gitignore

@@ -0,0 +1,5 @@
+__pycache__/
+*.egg-info/
+dist/
+build/
+.venv/

ccherd-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 bocode labs
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

ccherd-0.1.0/PKG-INFO

@@ -0,0 +1,123 @@
+Metadata-Version: 2.5
+Name: ccherd
+Version: 0.1.0
+Summary: Claude Code sessions and subagents across several Claude accounts
+Author: bocode labs
+License-Expression: MIT
+License-File: LICENSE
+Classifier: Environment :: Console
+Classifier: Operating System :: MacOS
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+
+# ccherd
+
+![A herd of Claude Code sheep](docs/herd.png)
+
+Run Claude Code subagents across several Claude accounts.
+
+If you have more than one Claude subscription, each lives in its own
+`CLAUDE_CONFIG_DIR` (`~/.claude`, `~/.claude-work`, ...). Claude Code only sees
+the sessions of the account it runs under, and a subagent always spends the
+quota of its parent. ccherd fixes both:
+
+- it lists and messages sessions across all your accounts, and
+- it starts background subagents on the account whose weekly quota is most
+  likely to expire unused, so you use what you pay for before paying extra.
+
+macOS and Linux. Needs Python 3.10+ and the `claude` CLI.
+
+## Install
+
+```sh
+uv tool install ccherd
+# or
+pipx install ccherd
+```
+
+## Setup
+
+Run this inside the repo where you want to use ccherd:
+
+```sh
+ccherd setup
+```
+
+It asks:
+
+0. **Whether each subscription already has its own config dir.** If not, it asks
+   how many subscriptions you have, creates numbered dirs next to your current
+   one (`~/.claude`, `~/.claude-2`, ...), prints the command to log in to each,
+   and stops. Log in, then run `ccherd setup` again.
+1. **Which organization.** If your dirs are logged in to more than one (say a
+   private plan and a company team), ccherd uses one of them: subagents should
+   run with the same skills and memories as their caller. Dirs of other
+   organizations are left out, even if a pattern matches them.
+2. **Which config dirs are your accounts.** It lists every `~/.claude*` dir.
+   A numbered family like `~/.claude-work`, `~/.claude-work2`, `~/.claude-work3`
+   gets one extra line: tick it to save the pattern, so `~/.claude-work4` is
+   picked up later without running setup again. Or tick single dirs. Anything
+   elsewhere goes into the "Other" line.
+3. **Where to put the Claude skill:** in this repo (`.claude/skills/ccherd`) or in
+   every account's config dir.
+4. **Whether to add a short note to `CLAUDE.local.md`.** Creates the file if needed and
+   adds it to `.gitignore`.
+
+At the end it runs `ccherd doctor`.
+
+## Shared skills and memories
+
+A subagent should behave like the session that started it. So all accounts
+should share `skills`, `projects` (memories and conversations), `agents`,
+`plugins`, `settings.json` and `CLAUDE.md`: one account holds them, the others
+symlink to it. `ccherd doctor` shows what is linked; `ccherd doctor --fix`
+links the rest. An account's own copy is merged into the shared one first;
+files that differ stay in a `*.ccherd-backup-*` dir next to it. Nothing is
+deleted.
+
+Non-interactive: `ccherd setup --new 3`, or `ccherd setup --organization "Acme" --schema ~/.claude-work --dir ~/.claude --skill repo --claude-local`.
+
+Config is stored in `~/.config/ccherd/config.json`.
+
+## Commands
+
+| Command | What it does |
+| --- | --- |
+| `ccherd setup` | Pick accounts, install the skill |
+| `ccherd doctor` | Per account: login, organization, token, shared config |
+| `ccherd doctor --fix` | Symlink every account's skills, memories etc. to one shared place |
+| `ccherd accounts` | 5-hour and weekly usage per account, and which one `auto` picks |
+| `ccherd sessions` | Live Claude sessions of all accounts |
+| `ccherd spawn NAME "task" --model M` | Start a background subagent on the best account |
+| `ccherd agents` | Subagents started by the current session |
+| `ccherd send TARGET "text"` | Message a subagent (resumes it if idle) or any live session |
+| `ccherd result NAME` | A subagent's last answer |
+| `ccherd log NAME` | A subagent's transcript |
+| `ccherd kill NAME` | Stop a subagent |
+
+`spawn`, `agents`, `send`, `result`, `log` and `kill` are meant to be run by
+Claude from inside a session; the skill tells it how. A finished subagent
+reports back to the session that started it as a message.
+
+## How `auto` picks an account
+
+Score = weekly % left ÷ hours until the weekly reset × free share of the 5-hour
+window. The highest score wins. Accounts at ≥ 90 % of their 5-hour window or
+≥ 98 % of their week are skipped.
+
+ccherd never refreshes an OAuth token itself - the refresh token rotates, so
+that would log out the Claude Code instance that owns the account. When an
+access token has expired and no session runs on that account, it lets Claude
+Code renew it (`claude auth status`).
+
+## Development
+
+```sh
+PYTHONPATH=src python3 -m unittest discover -s tests
+```
+
+## License
+
+MIT

ccherd-0.1.0/README.md

@@ -0,0 +1,109 @@
+# ccherd
+
+![A herd of Claude Code sheep](docs/herd.png)
+
+Run Claude Code subagents across several Claude accounts.
+
+If you have more than one Claude subscription, each lives in its own
+`CLAUDE_CONFIG_DIR` (`~/.claude`, `~/.claude-work`, ...). Claude Code only sees
+the sessions of the account it runs under, and a subagent always spends the
+quota of its parent. ccherd fixes both:
+
+- it lists and messages sessions across all your accounts, and
+- it starts background subagents on the account whose weekly quota is most
+  likely to expire unused, so you use what you pay for before paying extra.
+
+macOS and Linux. Needs Python 3.10+ and the `claude` CLI.
+
+## Install
+
+```sh
+uv tool install ccherd
+# or
+pipx install ccherd
+```
+
+## Setup
+
+Run this inside the repo where you want to use ccherd:
+
+```sh
+ccherd setup
+```
+
+It asks:
+
+0. **Whether each subscription already has its own config dir.** If not, it asks
+   how many subscriptions you have, creates numbered dirs next to your current
+   one (`~/.claude`, `~/.claude-2`, ...), prints the command to log in to each,
+   and stops. Log in, then run `ccherd setup` again.
+1. **Which organization.** If your dirs are logged in to more than one (say a
+   private plan and a company team), ccherd uses one of them: subagents should
+   run with the same skills and memories as their caller. Dirs of other
+   organizations are left out, even if a pattern matches them.
+2. **Which config dirs are your accounts.** It lists every `~/.claude*` dir.
+   A numbered family like `~/.claude-work`, `~/.claude-work2`, `~/.claude-work3`
+   gets one extra line: tick it to save the pattern, so `~/.claude-work4` is
+   picked up later without running setup again. Or tick single dirs. Anything
+   elsewhere goes into the "Other" line.
+3. **Where to put the Claude skill:** in this repo (`.claude/skills/ccherd`) or in
+   every account's config dir.
+4. **Whether to add a short note to `CLAUDE.local.md`.** Creates the file if needed and
+   adds it to `.gitignore`.
+
+At the end it runs `ccherd doctor`.
+
+## Shared skills and memories
+
+A subagent should behave like the session that started it. So all accounts
+should share `skills`, `projects` (memories and conversations), `agents`,
+`plugins`, `settings.json` and `CLAUDE.md`: one account holds them, the others
+symlink to it. `ccherd doctor` shows what is linked; `ccherd doctor --fix`
+links the rest. An account's own copy is merged into the shared one first;
+files that differ stay in a `*.ccherd-backup-*` dir next to it. Nothing is
+deleted.
+
+Non-interactive: `ccherd setup --new 3`, or `ccherd setup --organization "Acme" --schema ~/.claude-work --dir ~/.claude --skill repo --claude-local`.
+
+Config is stored in `~/.config/ccherd/config.json`.
+
+## Commands
+
+| Command | What it does |
+| --- | --- |
+| `ccherd setup` | Pick accounts, install the skill |
+| `ccherd doctor` | Per account: login, organization, token, shared config |
+| `ccherd doctor --fix` | Symlink every account's skills, memories etc. to one shared place |
+| `ccherd accounts` | 5-hour and weekly usage per account, and which one `auto` picks |
+| `ccherd sessions` | Live Claude sessions of all accounts |
+| `ccherd spawn NAME "task" --model M` | Start a background subagent on the best account |
+| `ccherd agents` | Subagents started by the current session |
+| `ccherd send TARGET "text"` | Message a subagent (resumes it if idle) or any live session |
+| `ccherd result NAME` | A subagent's last answer |
+| `ccherd log NAME` | A subagent's transcript |
+| `ccherd kill NAME` | Stop a subagent |
+
+`spawn`, `agents`, `send`, `result`, `log` and `kill` are meant to be run by
+Claude from inside a session; the skill tells it how. A finished subagent
+reports back to the session that started it as a message.
+
+## How `auto` picks an account
+
+Score = weekly % left ÷ hours until the weekly reset × free share of the 5-hour
+window. The highest score wins. Accounts at ≥ 90 % of their 5-hour window or
+≥ 98 % of their week are skipped.
+
+ccherd never refreshes an OAuth token itself - the refresh token rotates, so
+that would log out the Claude Code instance that owns the account. When an
+access token has expired and no session runs on that account, it lets Claude
+Code renew it (`claude auth status`).
+
+## Development
+
+```sh
+PYTHONPATH=src python3 -m unittest discover -s tests
+```
+
+## License
+
+MIT

ccherd-0.1.0/pyproject.toml

@@ -0,0 +1,30 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "ccherd"
+dynamic = ["version"]
+description = "Claude Code sessions and subagents across several Claude accounts"
+readme = "README.md"
+license = "MIT"
+requires-python = ">=3.10"
+authors = [{ name = "bocode labs" }]
+classifiers = [
+  "Environment :: Console",
+  "Operating System :: MacOS",
+  "Operating System :: POSIX :: Linux",
+  "Programming Language :: Python :: 3",
+]
+
+[project.scripts]
+ccherd = "ccherd.cli:main"
+
+[tool.hatch.version]
+path = "src/ccherd/__init__.py"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/ccherd"]
+
+[tool.ruff]
+line-length = 120

ccherd-0.1.0/src/ccherd/__init__.py

@@ -0,0 +1,3 @@
+"""Claude Code sessions and subagents across several Claude accounts."""
+
+__version__ = "0.1.0"

ccherd-0.1.0/src/ccherd/__main__.py

@@ -0,0 +1,5 @@
+import sys
+
+from .cli import main
+
+sys.exit(main())

ccherd-0.1.0/src/ccherd/agents.py

@@ -0,0 +1,253 @@
+"""Background subagents: their on-disk registry and the supervisor that runs their turns.
+
+Layout: <state dir>/<owner session id>/<agent name>/
+  meta.json       status, account, model, mode, claude session id, last result
+  stream.jsonl    every turn's `claude -p --output-format stream-json` output
+  inbox.jsonl     messages queued while no turn can take them
+  supervisor.log  stderr of the detached supervisor
+  lock            flock serializing every read-modify-write of meta.json and inbox
+
+The owner is the Claude session whose Bash ran `ccherd spawn`: CLAUDE_CODE_SESSION_ID
+is set in every tool subprocess, so each session gets its own list of agents.
+"""
+
+from __future__ import annotations
+
+import contextlib
+import fcntl
+import json
+import os
+import re
+import subprocess
+import sys
+import time
+from pathlib import Path
+
+from . import config
+from .permissions import mode_class
+from .procs import pid_alive, proc_start
+from .sessions import deliver, session_by_socket
+
+TERMINAL = {"idle", "failed", "killed", "lost"}
+EFFORTS = ["low", "medium", "high", "xhigh", "max"]
+RESULT_PREVIEW = 3000  # chars of the result carried in the completion notice
+NAME_RE = re.compile(r"[A-Za-z0-9][A-Za-z0-9._-]{0,63}")
+
+
+# --- registry -----------------------------------------------------------------
+
+
+def owner_id() -> str:
+    if os.environ.get("CCHERD_OWNER"):
+        return os.environ["CCHERD_OWNER"]
+    sid = os.environ.get("CLAUDE_CODE_SESSION_ID")
+    if not sid:
+        raise SystemExit("ccherd: CLAUDE_CODE_SESSION_ID is not set - run this from inside a Claude session "
+                         "(or set CCHERD_OWNER to a label of your own)")
+    return sid
+
+
+def agent_dir(owner: str, name: str) -> Path:
+    if not NAME_RE.fullmatch(name):
+        raise SystemExit(f"ccherd: agent name {name!r} must be [A-Za-z0-9._-], max 64")
+    return config.STATE_DIR / owner / name
+
+
+def find_agent(name: str) -> Path | None:
+    """This session's agent called `name`, or None."""
+    if not NAME_RE.fullmatch(name):
+        return None
+    d = agent_dir(owner_id(), name)
+    return d if (d / "meta.json").is_file() else None
+
+
+def require_agent(name: str) -> Path:
+    d = find_agent(name)
+    if d is None:
+        raise SystemExit(f"ccherd: no agent {name!r} in this session (`ccherd agents`)")
+    return d
+
+
+def list_agents(all_owners: bool) -> list[tuple[Path, dict]]:
+    root = config.STATE_DIR
+    owners = [p for p in root.iterdir() if p.is_dir()] if all_owners and root.is_dir() else [root / owner_id()]
+    return [(m.parent, refreshed(m.parent)) for o in owners for m in sorted(o.glob("*/meta.json"))]
+
+
+def load_meta(d: Path) -> dict:
+    return json.loads((d / "meta.json").read_text())
+
+
+def save_meta(d: Path, meta: dict) -> None:
+    tmp = d / "meta.json.tmp"
+    tmp.write_text(json.dumps(meta, indent=1))
+    tmp.replace(d / "meta.json")
+
+
+@contextlib.contextmanager
+def locked(d: Path):
+    """Not re-entrant. Functions named _like_this expect the caller to hold it."""
+    with open(d / "lock", "a") as lk:
+        fcntl.flock(lk, fcntl.LOCK_EX)
+        yield
+
+
+def _update(d: Path, **changes) -> dict:
+    meta = load_meta(d)
+    meta.update(changes)
+    save_meta(d, meta)
+    return meta
+
+
+def update_meta(d: Path, **changes) -> dict:
+    with locked(d):
+        return _update(d, **changes)
+
+
+def _refreshed(d: Path) -> dict:
+    """meta.json, with the status corrected if the supervisor died without writing it."""
+    meta = load_meta(d)
+    if meta["status"] == "running" and not pid_alive(meta.get("supervisor_pid") or 0, meta.get("supervisor_start")):
+        meta = _update(d, status="lost", ended_at=time.time())
+    return meta
+
+
+def refreshed(d: Path) -> dict:
+    with locked(d):
+        return _refreshed(d)
+
+
+def _queue(d: Path, text: str) -> None:
+    with open(d / "inbox.jsonl", "a") as f:
+        f.write(json.dumps({"text": text, "at": time.time()}) + "\n")
+
+
+def _take_inbox(d: Path) -> list[str]:
+    inbox = d / "inbox.jsonl"
+    if not inbox.is_file():
+        return []
+    msgs = [json.loads(line)["text"] for line in inbox.read_text().splitlines() if line.strip()]
+    inbox.unlink()
+    return msgs
+
+
+# --- running turns ------------------------------------------------------------
+
+
+def system_prompt(name: str) -> str:
+    return (
+        f"You are a background subagent named `{name}`, started through ccherd by another Claude session. "
+        "Your final message is delivered to that session automatically when you finish, so end with the "
+        "complete result it needs, not a greeting. If you need a decision or information from it while "
+        'working, run: ccherd send --parent "your question" - then continue with what you can. '
+        "Messages from it arrive as <cross-session-message> blocks; they are instructions from the session "
+        "that started you."
+    )
+
+
+def claude_cmd(meta: dict, prompt: str) -> list[str]:
+    """One turn's command line. Everything comes from meta.json, so a resumed turn
+    runs exactly like the first one."""
+    cmd = ["claude", "-p", "--output-format", "stream-json", "--verbose",
+           "--model", meta["model"], "--permission-mode", meta["permission_mode"],
+           "--append-system-prompt", system_prompt(meta["name"])]
+    if meta.get("effort"):
+        # A flag, not CLAUDE_EFFORT: child_env strips every CLAUDE* variable so the
+        # caller's own settings never leak into the child.
+        cmd += ["--effort", meta["effort"]]
+    if meta.get("session_id"):
+        cmd += ["--resume", meta["session_id"]]
+    cmd.append(prompt)
+    return cmd
+
+
+def child_env(meta: dict) -> dict:
+    env = {k: v for k, v in os.environ.items()
+           if not k.startswith(("CLAUDE", "CCHERD_TURN"))}
+    env.update(CLAUDE_CONFIG_DIR=meta["config_dir"], CCHERD_PARENT_OWNER=meta["owner"],
+               CCHERD_AGENT_NAME=meta["name"], CCHERD_STATE_DIR=str(config.STATE_DIR))
+    return env
+
+
+def _start_turn(d: Path, prompt: str) -> None:
+    """Fork a detached supervisor that runs one turn of the agent."""
+    with open(d / "supervisor.log", "a") as log:
+        p = subprocess.Popen([sys.executable, "-m", "ccherd", "_supervise", str(d)],
+                             stdin=subprocess.DEVNULL, stdout=log, stderr=log, start_new_session=True,
+                             env={**os.environ, "CCHERD_TURN_PROMPT": prompt})
+    _update(d, status="running", supervisor_pid=p.pid, supervisor_start=None,
+            child_pid=None, turn_started_at=time.time())
+
+
+def _run_turn(d: Path, meta: dict, prompt: str) -> tuple[int, str | None, str | None, bool, float | None]:
+    """Run `claude -p` once; returns (exit code, result, session id, is_error, cost)."""
+    result, session_id, is_error, cost = None, meta.get("session_id"), False, None
+    with open(d / "stream.jsonl", "a") as out:
+        out.write(json.dumps({"type": "ccherd_turn", "turn": meta["turns"] + 1, "prompt": prompt,
+                              "at": time.time()}) + "\n")
+        out.flush()
+        child = subprocess.Popen(claude_cmd(meta, prompt), cwd=meta["cwd"], env=child_env(meta),
+                                 stdin=subprocess.DEVNULL, stdout=subprocess.PIPE, stderr=subprocess.STDOUT,
+                                 text=True)
+        update_meta(d, child_pid=child.pid)
+        for line in child.stdout:
+            out.write(line)
+            out.flush()
+            try:
+                ev = json.loads(line)
+            except ValueError:
+                continue
+            session_id = ev.get("session_id") or session_id
+            if ev.get("type") == "result":
+                result = ev.get("result")
+                is_error = bool(ev.get("is_error"))
+                cost = ev.get("total_cost_usd")
+        return child.wait(), result, session_id, is_error, cost
+
+
+def supervise(d: Path) -> int:
+    """Body of the detached supervisor: run turns until nothing is queued, then notify the owner."""
+    update_meta(d, supervisor_pid=os.getpid(), supervisor_start=proc_start(os.getpid()))
+    prompt = os.environ.pop("CCHERD_TURN_PROMPT")
+    while True:
+        meta = load_meta(d)
+        rc, result, session_id, is_error, cost = _run_turn(d, meta, prompt)
+        with locked(d):
+            # Status and inbox are settled under ONE lock: `ccherd send` queues only while
+            # it reads "running" under the same lock, so no message lands after the
+            # last drain and sits there unrun.
+            killed = load_meta(d)["status"] == "killed"
+            pending = [] if killed else _take_inbox(d)
+            if killed:
+                status = "killed"
+            elif pending and session_id:
+                status = "running"
+            else:
+                status = "failed" if (rc != 0 or is_error) else "idle"
+            meta = _update(d, status=status, session_id=session_id, turns=meta["turns"] + 1,
+                           child_pid=None, last_result=result, last_exit=rc, ended_at=time.time(),
+                           last_cost_usd=cost)
+        if status == "killed":
+            return 0
+        if status == "running":
+            # Messages that arrived while the turn was ending run as the next turn,
+            # so the owner gets one notice per settled state.
+            prompt = "\n\n".join(pending)
+            continue
+        notify_owner(meta, status, result)
+        return 0
+
+
+def notify_owner(meta: dict, status: str, result: str | None) -> None:
+    sess = session_by_socket(meta.get("owner_socket"))
+    if not sess:
+        return  # the owner is gone; the result stays readable via `ccherd result`
+    body = result or "(no result text)"
+    if len(body) > RESULT_PREVIEW:
+        body = body[:RESULT_PREVIEW] + f"\n[... truncated, full text: ccherd result {meta['name']}]"
+    head = (f"ccherd: subagent `{meta['name']}` is {status} (account {meta['account']}, {meta['model']}, "
+            f"turn {meta['turns']}). Reply with: ccherd send {meta['name']} \"...\"")
+    try:
+        deliver(sess, f"{head}\n\n{body}", sender=f"ccherd:{meta['name']}", mode=mode_class(meta["permission_mode"]))
+    except OSError:
+        pass

ccherd-0.1.0/src/ccherd/api.py

@@ -0,0 +1,28 @@
+"""Read-only calls to the Anthropic OAuth API, with the token of one account."""
+
+from __future__ import annotations
+
+import json
+import os
+import urllib.request
+from pathlib import Path
+
+BASE_URL = "https://api.anthropic.com/api/oauth"
+
+
+def get(path: str, token: str) -> dict:
+    """GET {BASE_URL}/{path}. Raises urllib.error.URLError, OSError or ValueError."""
+    req = urllib.request.Request(f"{BASE_URL}/{path}", headers={
+        "Authorization": f"Bearer {token}",
+        "anthropic-beta": "oauth-2025-04-20",
+    })
+    with urllib.request.urlopen(req, timeout=10) as r:
+        return json.load(r)
+
+
+def write_cache(path: Path, data: dict) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True, mode=0o700)
+    tmp = path.with_suffix(".tmp")
+    tmp.write_text(json.dumps(data))
+    os.chmod(tmp, 0o600)
+    tmp.replace(path)