even-keel 0.0.2 → 0.2.0-rc.2

package/README.md

@@ -1,5 +1,201 @@
-# Even Keel
+<h1>
+  <picture>
+    <source media="(prefers-color-scheme: dark)" srcset="assets/logo-dark.svg">
+    <img src="assets/logo-light.svg" alt="Even Keel" height="40">
+  </picture>
+</h1>
 
-Runs Claude Code and Codex sessions on tracker issues one after another, in the order their dependencies allow, paced to the limits of a subscription.
+**You write the tickets. It takes the night shift.** Even Keel takes the open tasks of a project from your tracker, in the order of their `blocks` links, and works through them one at a time with [Claude Code](https://docs.claude.com/en/docs/claude-code/overview), [Codex](https://github.com/openai/codex), [OpenCode](https://opencode.ai) or [GitHub Copilot](https://github.com/github/copilot-cli) while you do something else. It waits out a spent usage limit, hands a long session over to a fresh one and keeps going while you are away. Only what really needs you — a question, a decision — waits for you: on its page, in the tracker or on your phone.
 
-**This package only holds the name.** Even Keel is installed from its repository for now: [github.com/NamerekT/even-keel](https://github.com/NamerekT/even-keel). An install through npm is planned; until then the `0.0.x` versions are placeholders and install nothing.
+**Already inside, so you don't glue five tools together:**
+
+- **Usage limits.** A spent 5-hour or weekly limit is waited out: the session is resumed after the reset while its prompt cache is warm, or handed to a fresh one — no work lost, no 3 a.m. restart.
+- **A full context, your way.** A session past its context threshold writes a handoff note and a fresh one takes over in the same worktree — or leaves it to Claude Code's auto-compact, per project or per task by a [label](docs/guide/reference.md#configuration). The statistics count both, and the session audit skill compares what each cost on your own tasks.
+- **What each task cost.** Built-in statistics (optional): cost and time per task, where sessions got stuck, how full the context ran, and before/after every change to your rule files.
+- **Every account on one page.** Claude, Codex, OpenCode and Copilot — subscriptions and API keys — each with its limits or spend and what runs on it right now. You pick the account a project runs on.
+- **`CLAUDE.md` or `AGENTS.md`.** One instruction file reaches every agent: Claude Code gets your `AGENTS.md`, Codex your `CLAUDE.md`.
+
+It runs as a service on your own machine, next to your repositories, on your own subscription, through the unmodified `claude`, `codex`, `opencode` and `copilot` CLIs. Trackers out of the box: [Huly](https://huly.io), GitHub Issues, [Linear](https://linear.app), GitLab Issues (GitLab.com or your own server) and Jira Cloud.
+
+![A project's chain: one task done, one session working, the rest queued; the panel on the right shows the session's stage, context fill and current action](assets/screens/chain.png)
+
+## Sequential by design
+
+Most agent orchestrators sell width: ten agents in parallel, each in its own worktree. Even Keel deliberately runs the tasks of a project one after another. Why:
+
+- **Backlog tasks are connected.** A parallel agent working on task B decides on its own what task A, not yet done, will look like. The sequential agent on B reads A's merged code.
+- **The bottleneck is human attention, not typing speed.** Questions, reviews and merges are yours to handle. Ten agents produce ten queues of them at once.
+- **A worktree isolates the work, not the result.** Conflicts, especially semantic ones that git does not see, move to merge time, where they are more expensive.
+- **The subscription limit is shared.** Parallel agents spend it sooner, not on more; and each of them reads the same area of the code again.
+
+Even Keel wins in time, not in width: the agent keeps working while you are away, and the chain survives what usually stops it — the usage limit running out, a context grown too large. That steady going is what the name means. Different projects are different repositories, so their chains can run side by side.
+
+![A task goes to Done, its worktree is cleaned up and the next task's session starts](assets/screens/chain.gif)
+
+## What it does
+
+- **A chain per project.** Open blockers first, then the order you drag on the page, then milestone and priority. A task labelled `Manual` is yours and never enters it.
+- **Several trackers per project.** Tasks from a second tracker or account — say the GitHub issues others file next to your private Huly project — join the same chain.
+- **Release branches.** A second chain on the same tracker project takes a released version's milestone in its own clone, and its fixes are merged forward into your development branch while that chain stands.
+- **A session per task**, in its own git worktree. The session does the task and merges; Even Keel closes the task, cleans up and starts the next. A task with nothing to merge (already done, research) the session marks `NO CHANGES: <why>`, and Even Keel closes it all the same.
+- **Questions** wait for you in the page's chat, as a tracker comment or in Claude's Remote Control. You can also write to a session while it works.
+- **Unattended mode** for nights: sessions ask nothing and park what a question holds.
+- **CI.** The next task waits for the CI's verdict on `main`, and a red `main` is fixed first. No CI — your own check commands.
+- **Pull requests (experimental).** Instead of merging, Even Keel can push a task's branch and open a pull request on GitHub or Forgejo, or a merge request on GitLab; review feedback, failed checks and conflicts go back to the task's session.
+- **Plugins and MCP servers** per project, with their keys kept behind a local gateway.
+- **Accounts, one per project and provider.** OpenCode signs in with ChatGPT, GitHub Copilot, an API key or runs its free models; the Copilot CLI with your sign-in or a token each. Claude sessions on an API key run through the Agent SDK and outlive a restart of the service with their questions open; a subscription can switch to it too.
+- **A session audit skill** reads the statistics and proposes what to change in your rules.
+- **The page:** the chain, each session's stage, current action and context fill, task cards, changelog drafts; in English or Russian.
+
+| A question in the page's chat | A spent limit, waited out with the cache warm | Statistics |
+| --- | --- | --- |
+| ![The page's chat with a session's question and its options](assets/screens/question.png) | ![The session hit the usage limit; the panel says it goes on after the reset with the cache still warm](assets/screens/limit.png) | ![The stats page: cost, weekly limits and spend by day per project](assets/screens/stats.png) |
+
+Every feature in full: [docs/guide/features.md](docs/guide/features.md).
+
+## Requirements
+
+- **Node.js 24** or newer ([nodejs.org](https://nodejs.org/en/download); on Linux nvm needs no `sudo`).
+- **git** ([git-scm.com](https://git-scm.com/downloads)) with your name and email set (`git config --global user.name "John Doe"`, `git config --global user.email john@example.com`). Nothing works without it: every task runs in its own git worktree, and sessions commit and merge under that name.
+- **Claude Code CLI** ([install](https://docs.claude.com/en/docs/claude-code/setup)), signed in with a Claude subscription (`claude` once in a terminal). **Codex CLI** only for projects or tasks on Codex: `npm install -g @openai/codex`, signed in with `codex login` or from the accounts page. **OpenCode** (preview) only for projects or tasks on it: `npm install -g opencode-ai`, signed in from the accounts page; checked with its free `opencode/big-pickle`. **GitHub Copilot CLI** (preview) only for projects or tasks on it: `winget install GitHub.Copilot` (or `npm install -g @github/copilot`), signed in with `copilot login` or a token on the accounts page.
+- **A tracker:** a Huly workspace, GitHub or GitLab projects with Issues, a Linear workspace or a Jira Cloud site.
+- **Windows, Linux or macOS.** Windows is where it runs every day; Linux and macOS (Apple silicon) were checked end to end. On Windows it starts at your sign-in with no administrator; only the older Windows service needs **PowerShell 7**. The MSI installer of Node can sit on "Preparing to install…" for over 10 minutes: wait it out.
+
+## Before you run it
+
+- **Even Keel depends on undocumented behaviour of the agents' CLIs**: their background sessions, transcripts, session files and the text of their commands. None of it is a public API. Chain sessions run on your CLI, and the page warns while its version is not the one Even Keel was last checked against; "CLI version → Checked" has Even Keel download that version and run sessions on it instead. Last checked against **Claude Code 2.1.316**, **codex-cli 0.166.0**, **OpenCode 1.19.5** and **Copilot CLI 1.0.105**. A CLI update may still break a part of Even Keel until it is adapted — please open an issue when it does. What exactly it relies on and the limits of the pin: [setup](docs/guide/setup.md#the-clis-it-depends-on).
+- **Your subscription, the providers' terms.** Sessions run on the accounts you sign in with and wait out their limits: a project runs on one account per provider, and a spent limit is never got round by switching to another account ([docs/sessions/models.md](docs/sessions/models.md#run-profiles-btn-173-srcsessionslaunchts)). Claude sessions are governed by Anthropic's [Consumer Terms](https://www.anthropic.com/legal/consumer-terms) and [Usage Policy](https://www.anthropic.com/legal/aup) (the [Commercial Terms](https://www.anthropic.com/legal/commercial-terms) for Team, Enterprise and API keys). Anthropic asks products built on the Agent SDK to [use API key authentication](https://code.claude.com/docs/en/legal-and-compliance), so a subscription runs on the CLI's own background sessions unless you switch its card to the SDK yourself. Codex sessions are governed by OpenAI's [Terms of Use](https://openai.com/policies/terms-of-use/) and [Usage Policies](https://openai.com/policies/usage-policies/) when you sign in with ChatGPT (the [Services Agreement](https://openai.com/policies/services-agreement/) for Business, Enterprise, Edu and API keys), with the [Service Terms](https://openai.com/policies/service-terms/) on top. OpenAI's terms do not allow getting round its usage limits, so Even Keel refuses a second Codex account on the free plan. OpenCode sessions are governed by the terms of the provider you sign it in with; a Claude subscription is allowed only in Claude Code, so OpenCode reaches Claude only on an API key. Copilot sessions are governed by GitHub's [Terms of Service](https://docs.github.com/en/site-policy/github-terms/github-terms-of-service) and the [GitHub Copilot terms](https://github.com/customer-terms/github-copilot-product-specific-terms), which allow one free account per person. Even Keel does not share, pool or resell access: use accounts that are yours.
+- **Sessions run without asking you on each tool call**: Claude sessions with `--permission-mode auto`, Codex sessions with `--approve-for-me`, or with no sandbox at all when `execution.codex` is `bypass`. Set up the permissions and hooks you want in your Claude Code and Codex settings before you start a chain.
+- **Your sign-in stays with the CLIs.** Even Keel reads only the expiry dates from Claude's `.credentials.json`, and only the e-mail and the plan from Codex's `auth.json`; tokens are never copied or sent anywhere. It also removes the lock files the CLI leaves behind in the account folders. An API key you add is sent only to its own provider, to check it.
+- **Some behaviour has never been checked live** — an early reset of Claude limits, long chains on Codex, OpenCode and Copilot under the service, a few tracker and CI paths. Read [What has not been verified](docs/unverified.md) before relying on any of them. What has been checked live — where, when, on which versions and with what result — is logged in [What has been verified](docs/verified.md).
+
+## Quick start
+
+```sh
+npx even-keel
+```
+
+This installs Even Keel globally with npm and sets it up as a service ([below](#as-a-service)). On Windows that is a start at your sign-in with an icon in the tray — no administrator, any terminal. To run it in a terminal instead: `npm install --global even-keel`, then `even-keel`. Its data — `.env`, the state and the logs — lives in `%LOCALAPPDATA%\even-keel`, `~/.local/share/even-keel` or `~/Library/Application Support/even-keel`.
+
+From a clone, which keeps its data in its own folder:
+
+```sh
+git clone https://github.com/NamerekT/even-keel.git
+cd even-keel
+npm install
+npm run build
+npm start
+```
+
+Open `http://localhost:4747`. The first start walks a short setup — the languages, the agent and its account, a tracker profile, update checks, statistics — and then a wizard that adds a project: the agent, the repository folder, a tracker profile and the project in that tracker. A profile is the e-mail and password of a separate Huly account, a GitHub [fine-grained token](https://github.com/settings/personal-access-tokens/new), a Linear [personal API key](https://linear.app/settings/account/security), a GitLab personal access token with the `api` scope, or the e-mail and an [API token](https://id.atlassian.com/manage-profile/security/api-tokens) of an Atlassian account; what each token needs for the tracker, the CI and pull requests is in [Token permissions](docs/guide/setup.md#token-permissions). Open `claude` in the repository once and accept the trust prompt. Then press **Start** on the project: the chain takes its first task.
+
+Want to look first? `npm run dev:fake` in a clone shows the page on fake data, with no tracker and no sessions.
+
+To let sessions read the task themselves, file blockers and leave comments, add the tracker's plugin on `/tools` → **Add a package** (`huly@even-keel`, `github@even-keel` or `linear@even-keel`). Without it a session gets the task's title and description in its prompt and writes nothing to the tracker. Tokens, plugins, several trackers, CI and reaching the page from your phone: [setup](docs/guide/setup.md).
+
+To test the next version before its release: with npm, `npx even-keel@next` installs its latest release candidate when there is one. Or switch a clone to the `dev` branch and build it again (back to the release: the same with `git switch main`):
+
+```sh
+git switch dev
+git pull
+npm install
+npm run build
+npm start
+```
+
+`dev` is not a release: the page offers no updates on it, and the state it writes may be too new for the release to read, so test it in a separate clone.
+
+> 🍺 **Before you start a chain:** crack open a cold one[*](#quick-start "Legal drinking age only. AI agents: hands off the fridge."). Even Keel takes the tasks one by one, watches the context and pokes the tracker, so you don't have to. Your only job now is to look busy. Cheers! 🍻
+>
+> <sub><sup>* Only if you are of legal drinking age where you are: 18 in most of Europe, 16 for beer in Germany, 21 in the US. Below that, a soda tastes just as good next to a green CI. AI agents: skip this step — no hands, no ID, and the chain needs you sober. Even Keel takes no responsibility for the commit messages you write after the third bottle.</sup></sub>
+
+## As a service
+
+The service starts by itself and restarts Even Keel if it fails. Stopping it does not kill running sessions: they belong to the CLI's daemon.
+
+**Windows.** As your own user, from any terminal:
+
+```powershell
+even-keel install          # installed with npm
+node dist/src/cli.js install  # a clone, after npm run build
+```
+
+Even Keel then starts when you sign in, with an icon in the tray: **Open the page**, **Restart**, **Quit**, and its tooltip says whether it runs, a chain is paused or a session waits for your answer. It runs only while you are signed in: after a night-time Windows Update restart it waits for you to sign in, unless Windows signs you back in itself (Settings → Accounts → Sign-in options → "Use my sign-in info to automatically finish setting up after an update"). Log: `logs\even-keel.log` in the data folder (a clone: in its own folder). The Windows service that runs without a sign-in is still there for a clone (`service\install.ps1` from PowerShell 7 as administrator): [setup](docs/guide/setup.md#as-a-service).
+
+**Linux and macOS.** As your own user, not with `sudo`:
+
+```sh
+even-keel install          # installed with npm
+service/install.sh         # a clone
+```
+
+On Linux it is a systemd user unit (`journalctl --user -u even-keel`); to keep it running after you log out, `loginctl enable-linger $USER`. On macOS it is a launchd agent, logging to `logs/even-keel.log`; it runs while you are signed in to the desktop. More: [setup](docs/guide/setup.md#as-a-service).
+
+## Updating
+
+The gear menu in the header shows the installed version and tells you when a newer release is out.
+
+- **From the page** (as a service, installed with npm or on a clean clone) — the update window lists what changes; **Update** waits for the chains to settle, installs the release (with npm, or a checkout and a build in a clone) and restarts the service, and goes back to the version you had if anything fails. **Revert** takes you back to the previous version the same way, unless the update changed the stored state's format.
+- **Installed with npm, by hand** — `even-keel update` (stops the service, installs the latest release, starts it), or `npm install --global even-keel@<version>` with Even Keel stopped.
+- **A clone as a service, by hand** — `git pull`, then run its install again.
+- **A clone from a terminal** — stop Even Keel, then `git pull`, `npm ci`, `npm run build` and `npm start`.
+
+Running sessions survive the update. Plugins, stored state and going back to an older version: [setup](docs/guide/setup.md#updating).
+
+## Uninstall
+
+`even-keel uninstall` (a clone: `node dist/src/cli.js uninstall` or `service/uninstall.sh`) removes the service and nothing else; then `npm uninstall --global even-keel` and delete the data folder, or delete the clone. What stays in your repositories and your Claude Code config: [setup](docs/guide/setup.md#uninstall).
+
+## Configuration
+
+The settings live in Even Keel's database and are edited on the page: a project's on its **Settings**, the shared ones behind the gear in the header. Every change applies at once, with no restart. `.env` holds the page's address and a few paths. Every variable and key: [docs/guide/reference.md](docs/guide/reference.md).
+
+## What comes next
+
+The single executable once planned for v0.2 gave way to the npm package: an executable per platform meant its own build and release pipeline and a whole second install to check live on every system, while `npx even-keel` already installs Even Keel, sets up the service and updates it with one command.
+
+Looked at, not promised: running in Docker, a cap on how much of the usage limit one task may spend.
+
+## Extending
+
+### Your own tracker
+
+The chain never talks to a tracker directly: it reads tasks through an adapter. The contract, with what each field means and what to return when your tracker lacks something, is the JSDoc of [src/tracker/source.ts](src/tracker/source.ts) (`TrackerAdapter`, `TaskSource`). `src/github/` is a compact example, `src/huly/` a fuller one. Register the adapter in [src/tracker/adapters.ts](src/tracker/adapters.ts) and pick it with `tracker` in the config. `brief` and `complete` are optional: without them, sessions must learn the task and close it some other way. So are `card` and `ready`, the task card on the page and its **Move to Todo** button; without them the page links to the task in the tracker.
+
+### A plugin for it
+
+A plugin gives sessions the tracker's MCP server and a skill for working a task. Use [plugins/huly](plugins/huly) as the pattern: `.claude-plugin/plugin.json`, `.mcp.json` with the server, `skills/task/SKILL.md`; add an entry to [.claude-plugin/marketplace.json](.claude-plugin/marketplace.json) and name the server in the adapter's `mcpServer`, so that Even Keel can check sessions see it. When the server's `${…}` placeholder names the adapter's key differently, declare it in the adapter's `mcpKeys` (`{ LINEAR_API_KEY: 'LINEAR_TOKEN' }`), so the gateway fills it from the project's profile; a value built from several keys, such as Jira's Basic header, goes in `mcpValues`. Raise the plugin's `version` on every change: installed copies are cached by version.
+
+### Where it could grow
+
+- Other trackers: YouTrack, Jira Data Center…
+- Your own classifier for the statistics, or a different model behind it.
+- Other APIs and other agents: today Even Keel runs the Claude Code, Codex, OpenCode and GitHub Copilot CLIs and is built around the first two's subscription limits.
+
+## Development
+
+`main` is always the latest release. The next version is built on `dev`, fixes of the released one on `release/v<x.y>` ([docs/releases.md](docs/releases.md)). Pull requests are not accepted for now: bugs and ideas go to issues ([CONTRIBUTING.md](CONTRIBUTING.md)).
+
+```sh
+npm test            # vitest, without the end-to-end scenarios
+npm run test:e2e    # the end-to-end scenarios of src/e2e/
+npm run typecheck
+npm run dev         # the server, restarting on changes
+npm run dev:web     # the page with hot reload, proxying /api to a running server
+npm run dev:fake    # the page on fake data
+npm run shot -- '?chain=ask' .cards   # a dark screenshot of an element on fake data, into .temp/shot/
+```
+
+## Security
+
+A vulnerability is reported privately, not as an issue: [SECURITY.md](SECURITY.md).
+
+## Support
+
+Even Keel is free. If it saves you time, [Patreon](https://www.patreon.com/Namerek) keeps it going: patrons get the write-ups of how it is built and what each change to the rules cost, measured on its own statistics.
+
+## License
+
+[MIT](LICENSE)
+
+Even Keel is an independent project, not affiliated with or endorsed by Anthropic, OpenAI, GitHub or the makers of OpenCode. Claude and Claude Code are trademarks of Anthropic; Codex and OpenAI are trademarks of OpenAI; GitHub and GitHub Copilot are trademarks of GitHub.

package/dist/src/account/apps.js

@@ -0,0 +1,100 @@
+import { CLAUDE } from '../claude/name.js';
+import { fail, notice } from '../notice/notice.js';
+export const APP_LABELS = { vscode: 'VS Code' };
+const SETTING = 'claudeCode.environmentVariables';
+const VARIABLE = 'CLAUDE_CONFIG_DIR';
+const VSCODE_ENTRYPOINT = 'claude-vscode';
+export function configDirOf(settings) {
+    const variables = parseSettings(settings)[SETTING];
+    if (!Array.isArray(variables))
+        return null;
+    const found = variables.find((each) => isVariable(each) && each.name === VARIABLE);
+    return found === undefined || found.value === '' ? null : found.value;
+}
+export function withConfigDir(settings, dir) {
+    const parsed = parseSettings(settings);
+    const current = Array.isArray(parsed[SETTING]) ? parsed[SETTING] : [];
+    const index = current.findIndex((each) => isVariable(each) && each.name === VARIABLE);
+    const next = [...current];
+    if (dir === null) {
+        if (index >= 0)
+            next.splice(index, 1);
+    }
+    else if (index >= 0) {
+        next[index] = { name: VARIABLE, value: dir };
+    }
+    else {
+        next.push({ name: VARIABLE, value: dir });
+    }
+    const result = { ...parsed, [SETTING]: next };
+    if (next.length === 0)
+        delete result[SETTING];
+    const eol = settings.includes('\r\n') ? '\r\n' : '\n';
+    const text = JSON.stringify(result, null, indentOf(settings)).replace(/\n/g, eol);
+    return settings.trim() === '' || /\r?\n$/.test(settings) ? `${text}${eol}` : text;
+}
+export function isVsCodeChat(record) {
+    return record.entrypoint === VSCODE_ENTRYPOINT;
+}
+export function vscodeChats(account, records) {
+    return records
+        .filter(({ record }) => isVsCodeChat(record))
+        .map(({ record, title }) => ({
+        name: title ?? record.name ?? lastSegment(record.cwd) ?? record.sessionId.slice(0, 8),
+        session: record.name ?? record.sessionId.slice(0, 8),
+        account,
+        status: record.status ?? null,
+    }));
+}
+export function appSwitchProblem(view, app, key) {
+    const current = view.apps.find((each) => each.app === app);
+    if (current === undefined)
+        return notice('app.unknown', { app });
+    const label = APP_LABELS[current.app];
+    if (current.error !== null)
+        return current.error;
+    const target = view.accounts.find((entry) => entry.key === key);
+    if (target === undefined)
+        return notice('account.unknown', { key });
+    if (target.agent !== CLAUDE)
+        return notice('account.codexApp', {});
+    const email = target.status?.email ?? key;
+    if (current.account === key)
+        return notice('app.alreadyUses', { app: label, account: email });
+    if (target.removing)
+        return notice('account.removing', { account: email });
+    if (target.needsLogin || target.status?.loggedIn !== true)
+        return notice('account.needsLogin', { account: email });
+    if (current.sessions.length > 0)
+        return notice('app.chatsOpen', { app: label, count: current.sessions.length });
+    return undefined;
+}
+function parseSettings(settings) {
+    if (settings.trim() === '')
+        return {};
+    let value;
+    try {
+        value = JSON.parse(settings);
+    }
+    catch {
+        throw fail('vscode.notJson', {});
+    }
+    if (typeof value !== 'object' || value === null || Array.isArray(value))
+        throw fail('vscode.notObject', {});
+    return value;
+}
+function isVariable(value) {
+    if (typeof value !== 'object' || value === null)
+        return false;
+    const { name, value: text } = value;
+    return typeof name === 'string' && typeof text === 'string';
+}
+function indentOf(settings) {
+    const indent = /\n([ \t]+)\S/.exec(settings)?.[1];
+    if (indent === undefined)
+        return 4;
+    return indent.startsWith('\t') ? '\t' : indent.length;
+}
+function lastSegment(path) {
+    return path?.split(/[\\/]/).filter(Boolean).at(-1);
+}

package/dist/src/account/credit.js

@@ -0,0 +1,117 @@
+import { isSpendingLimit, spendingReset } from '../limits/spending.js';
+const MODELS_URL = 'https://api.anthropic.com/v1/models?limit=100';
+const MESSAGES_URL = 'https://api.anthropic.com/v1/messages';
+const API_VERSION = '2023-06-01';
+// The API's answer to a key whose organization has no credit left; the CLI writes it down as `billing_error`.
+const OUT_OF_CREDIT = 'credit balance is too low';
+const OPENAI_MODELS_URL = 'https://api.openai.com/v1/models';
+const OPENAI_RESPONSES_URL = 'https://api.openai.com/v1/responses';
+const OPENAI_OUT_OF_MONEY = 'insufficient_quota';
+// Models of the list that take no text input through `/v1/responses`.
+const NOT_TEXT = /tts|transcribe|audio|realtime|search|image|embedding/;
+/**
+ * Asks Anthropic whether the key can pay again: one output token from the cheapest model the key lists (a Haiku, else
+ * the newest one) — a fraction of a cent. The models list alone costs nothing but answers even with no credit.
+ */
+export function checkCredit(key, timeoutMs, fetchImpl = fetch) {
+    return askCredit({
+        modelsUrl: MODELS_URL,
+        url: MESSAGES_URL,
+        headers: { 'x-api-key': key, 'anthropic-version': API_VERSION, 'content-type': 'application/json' },
+        pick: (ids) => ids.find((id) => id.includes('haiku')) ?? ids[0] ?? null,
+        body: (model) => ({ model, max_tokens: 1, messages: [{ role: 'user', content: '.' }] }),
+        empty: (status, text) => status === 400 && (text.toLowerCase().includes(OUT_OF_CREDIT) || isSpendingLimit(text)),
+    }, timeoutMs, fetchImpl);
+}
+/**
+ * The same question to OpenAI for a Codex key (BTN-195): a nano text model the key lists, else a mini one, through
+ * `/v1/responses` with its least `max_output_tokens`. A key out of money answers 429 `insufficient_quota`; a 429 of a
+ * rate limit tells nothing.
+ */
+export function checkOpenAiCredit(key, timeoutMs, fetchImpl = fetch) {
+    return askCredit({
+        modelsUrl: OPENAI_MODELS_URL,
+        url: OPENAI_RESPONSES_URL,
+        headers: { authorization: `Bearer ${key}`, 'content-type': 'application/json' },
+        pick: (ids) => {
+            const text = ids.filter((id) => id.startsWith('gpt-') && !NOT_TEXT.test(id));
+            return text.find((id) => id.includes('nano')) ?? text.find((id) => id.includes('mini')) ?? null;
+        },
+        body: (model) => ({ model, input: '.', max_output_tokens: 16, store: false }),
+        empty: (status, text) => status === 429 && text.includes(OPENAI_OUT_OF_MONEY),
+    }, timeoutMs, fetchImpl);
+}
+async function askCredit(ask, timeoutMs, fetchImpl) {
+    try {
+        const listed = await fetchImpl(ask.modelsUrl, { headers: ask.headers, signal: AbortSignal.timeout(timeoutMs) });
+        if (!listed.ok) {
+            await listed.body?.cancel();
+            return { state: 'unknown', reason: `models HTTP ${listed.status}` };
+        }
+        const model = ask.pick(modelIds(await listed.json()));
+        if (model === null)
+            return { state: 'unknown', reason: 'the key lists no models' };
+        const response = await fetchImpl(ask.url, {
+            method: 'POST',
+            headers: ask.headers,
+            body: JSON.stringify(ask.body(model)),
+            signal: AbortSignal.timeout(timeoutMs),
+        });
+        const text = await response.text();
+        if (response.ok)
+            return { state: 'ok' };
+        if (ask.empty(response.status, text))
+            return { state: 'empty' };
+        return { state: 'unknown', reason: `HTTP ${response.status}` };
+    }
+    catch (error) {
+        return { state: 'unknown', reason: error instanceof Error ? error.message : String(error) };
+    }
+}
+function modelIds(body) {
+    const data = body?.data;
+    return Array.isArray(data) ? data.map((model) => model?.id).filter((id) => typeof id === 'string') : [];
+}
+/**
+ * The credit of the API accounts whose session of a current task stopped on it: checked once per interval while the
+ * chain keeps asking, and not past two intervals after it stopped asking.
+ */
+export class CreditChecks {
+    intervalMs;
+    wanted = new Map();
+    constructor(intervalMs) {
+        this.intervalMs = intervalMs;
+    }
+    /** When the credit of the key came back after the stop at `since`; null — not yet, and the key gets checked. */
+    restoredAfter(key, since, now, text = '') {
+        const known = this.wanted.get(key);
+        if (known === undefined || Date.parse(known.since) < Date.parse(since)) {
+            const spending = isSpendingLimit(text) ? { resetsAt: spendingReset(text, since) } : null;
+            this.wanted.set(key, { since, askedAt: now.getTime(), checkedAt: now.getTime(), restoredAt: null, spending });
+            return null;
+        }
+        known.askedAt = now.getTime();
+        return known.restoredAt;
+    }
+    due(now) {
+        const time = now.getTime();
+        return [...this.wanted]
+            .filter(([, want]) => want.restoredAt === null && time - want.askedAt <= 2 * this.intervalMs && time - want.checkedAt >= this.intervalMs)
+            .map(([key]) => key);
+    }
+    spendingLimit(key, now) {
+        const want = this.wanted.get(key);
+        return want === undefined || want.restoredAt !== null || now.getTime() - want.askedAt > 2 * this.intervalMs ? null : want.spending;
+    }
+    note(key, verdict, now) {
+        const want = this.wanted.get(key);
+        if (want === undefined)
+            return;
+        want.checkedAt = now.getTime();
+        if (verdict.state === 'ok')
+            want.restoredAt = now.toISOString();
+    }
+    forget(key) {
+        this.wanted.delete(key);
+    }
+}

package/dist/src/account/current.js

@@ -0,0 +1,13 @@
+import { accountId, launchBlock } from './model.js';
+/** The account folder as the chain judges a launch in it. */
+export function currentAccount(view, key = view.active) {
+    const entry = view.accounts.find((each) => each.key === key);
+    const loggedIn = entry?.status?.loggedIn === true;
+    const email = loggedIn ? entry?.status?.email ?? null : null;
+    return {
+        id: loggedIn ? accountId(key, email) : null,
+        ready: loggedIn && launchBlock(view, key) === undefined,
+        label: entry?.name ?? email ?? key,
+        provider: entry?.agent,
+    };
+}

package/dist/src/account/daemon.js

@@ -0,0 +1,65 @@
+// Sessions inherit the environment the transient daemon of an account folder started with,
+// so an env key the share removed stays in new sessions until that daemon is restarted.
+// They also run on the daemon's version, not on the one of the client that starts them.
+export class DaemonRefresh {
+    options;
+    stale = new Set();
+    behind = new Map();
+    constructor(options) {
+        this.options = options;
+    }
+    pending(key) {
+        return this.stale.has(key);
+    }
+    /** The daemons on another version than the pin, as of the last launch in their folder. */
+    outdated() {
+        return [...this.behind.values()];
+    }
+    async prepare(home) {
+        const before = this.snapshot();
+        if (!home.global && this.options.share(home))
+            this.stale.add(home.key);
+        await this.compare(home);
+        if (this.stale.has(home.key) || this.behind.has(home.key))
+            await this.settle(home);
+        if (this.snapshot() !== before)
+            this.options.onChange();
+    }
+    /** A key left the folder's settings outside the share — the page removed it from the global one (BTN-131). */
+    async expire(home) {
+        const before = this.snapshot();
+        this.stale.add(home.key);
+        await this.settle(home);
+        if (this.snapshot() !== before)
+            this.options.onChange();
+    }
+    async compare(home) {
+        if (this.options.daemon === undefined)
+            return;
+        try {
+            const daemon = await this.options.daemon(home);
+            if (daemon === null || daemon.running === daemon.wanted)
+                this.behind.delete(home.key);
+            else
+                this.behind.set(home.key, { account: home.key, agent: home.agent, ...daemon });
+        }
+        catch (error) {
+            this.options.onError(error);
+        }
+    }
+    async settle(home) {
+        try {
+            if ((await this.options.running(home)) === 0) {
+                await this.options.stopDaemon(home);
+                this.stale.delete(home.key);
+                this.behind.delete(home.key);
+            }
+        }
+        catch (error) {
+            this.options.onError(error);
+        }
+    }
+    snapshot() {
+        return JSON.stringify([[...this.stale], [...this.behind.values()]]);
+    }
+}

package/dist/src/account/globals.js

@@ -0,0 +1,25 @@
+import { AccountHomes, accountsRoot, codexAccountsRoot, copilotAccountsRoot, openCodeAccountsRoot } from './homes.js';
+import { inTransaction } from '../storage/database.js';
+/** Registration belongs to this installation; a CLI's own folder and credentials remain the CLI's. */
+export async function openAccountHomes(db, env) {
+    const { rows } = await db.query('select account from global_accounts');
+    const registration = {
+        keys: new Set(rows.map((row) => row.account)),
+        save: async (key, added) => {
+            await db.query(added ? 'insert into global_accounts (account) values ($1) on conflict do nothing' : 'delete from global_accounts where account = $1', [key]);
+        },
+    };
+    const homes = new AccountHomes(env, accountsRoot(env), codexAccountsRoot(env), openCodeAccountsRoot(env), copilotAccountsRoot(env), registration);
+    const legacy = await db.query("select 1 from service_state where name = 'accounts.adoptLegacy'");
+    if (legacy.rows.length > 0) {
+        const visible = homes.availableGlobals();
+        await inTransaction(db, async (tx) => {
+            for (const home of visible)
+                await tx.query('insert into global_accounts (account) values ($1) on conflict do nothing', [home.key]);
+            await tx.query("delete from service_state where name = 'accounts.adoptLegacy'");
+        });
+        for (const home of visible)
+            registration.keys.add(home.key);
+    }
+    return homes;
+}

package/dist/src/account/header-levels.js

@@ -0,0 +1,22 @@
+import { nextTask } from '../chain/order.js';
+import { runChoice } from '../sessions/launch.js';
+/** The same launch choice as a session, with its inherited accounts underneath. No liveness or pause changes the choice. */
+export function headerLevels(ctx) {
+    const shared = runChoice(undefined, ctx.shared, ctx.hasAccount).account;
+    const project = runChoice(undefined, ctx.project, ctx.hasAccount).account;
+    const open = (task) => task.status.category !== 'Won' && task.status.category !== 'Lost';
+    const current = ctx.tasks.find((task) => task.id === ctx.current?.task && open(task));
+    const next = nextTask(ctx.tasks, ctx.order.filter((id) => ctx.tasks.some((task) => task.id === id && open(task))), ctx.holding ?? []);
+    const task = current ?? ctx.tasks.find((each) => each.id === next);
+    const choice = runChoice(task, ctx.project, ctx.hasAccount);
+    const pinned = current && ctx.current?.sessionId ? ctx.sessionAccount(ctx.current.sessionId) : undefined;
+    const account = pinned ?? choice.account;
+    const labelled = ctx.project.labels && task?.runLabels.length === 1 && choice.fallback === null;
+    const levels = [];
+    if (task && (labelled || account !== project))
+        levels.push({ account, source: 'task', task: task.id });
+    if (project !== shared)
+        levels.push({ account: project, source: 'project' });
+    levels.push({ account: shared, source: 'shared' });
+    return levels.filter((each, index) => levels.findIndex((other) => other.account === each.account) === index);
+}