@hanamorilabs/tab 0.1.20 → 0.1.22

package/dist/cli.js

@@ -34,8 +34,9 @@ import { describeLogin, localLogin } from "./logins.js";
 import { prepareCodexHome } from "./codex-home.js";
 import { addMember, loadPool, memberEnv, memberHome, POOL_VENDORS, poolVendorFor, prepareClaudeMember, prepareSharedSessions, limitsFor, removeMember, savePool, setGuard, setThreshold, thresholdFor, usage as quotaUsage } from "./pool.js";
 import { runPooled } from "./pool-run.js";
-import { claudeSettingsArg, installStatusLine, statusline } from "./statusline.js";
+import { claudeSettingsArg, composedStatusline, installStatusLine } from "./statusline.js";
 import { renderPool } from "./pool-view.js";
+import { runTop } from "./top.js";
 import { renderHelp } from "./help.js";
 import { findTabCommand } from "./tab-docs.js";
 import { ConsoleApiError, createAgent, issueAgentKey, listAgents, setAgentHarness } from "./console-api.js";
@@ -468,6 +469,35 @@ async function version() {
     say(rows([["tab", tabVersion], ["proxy", `${PROXY_VERSION}  ${dim(`(${where})`)}`]], 0));
     return 0;
 }
+/** The pool as `tab pool` sees it, for the dashboard's Subscriptions panel: nothing when no login is pooled. */
+async function poolSections(config) {
+    const pool = await loadPool();
+    const vendors = POOL_VENDORS.filter((v) => (pool.members[v] ?? []).length > 0);
+    if (vendors.length === 0)
+        return [];
+    const accounts = await flockAccounts(config).catch(() => []);
+    return Promise.all(vendors.map(async (vendor) => ({ vendor, title: VENDOR_NAMES[vendor], harness: VENDOR_HARNESS[vendor], limits: limitsFor(pool, vendor), standings: await poolStandings(config, vendor, pool.members[vendor], accounts) })));
+}
+/** `tab top [--every <seconds>] [--once]`: the flock on one screen, redrawn every few seconds. */
+async function topCommand(argv) {
+    const config = await ensureLogin();
+    if (!config)
+        return 2;
+    const flags = manage.parseFlags(argv);
+    const every = Number(flags.opts.every ?? "2");
+    if (!Number.isFinite(every) || every < 1 || every > 3600) {
+        fail(`tab top [--every <seconds>] [--once]. ${dim("Refresh every 1 to 3600 seconds; the default is 2.")}`);
+        return 2;
+    }
+    const once = flags.args.includes("--once") || "once" in flags.opts;
+    try {
+        return await runTop({ call: manage.api(config), config, health: () => proxyHealth(config.proxyUrl), pool: () => poolSections(config) }, { every, once });
+    }
+    catch (err) {
+        fail(err instanceof Error ? err.message : String(err));
+        return 1;
+    }
+}
 async function status() {
     const config = await loadConfig();
     if (!config) {
@@ -588,7 +618,10 @@ async function poolIdle(config, vendor, agentName) {
     const recent = Date.now() - 20_000;
     return !(await flockAccounts(config)).some((a) => a.provider === vendor && new Date(a.lastSeenAt).getTime() > recent);
 }
+/** `FLOCKTAB_TIMING=1`: one line per launch step on stderr, with the seconds since the process began. */
+const timing = process.env.FLOCKTAB_TIMING ? (label) => process.stderr.write(`  ⏱ ${(process.uptime()).toFixed(2)}s ${label}\n`) : () => undefined;
 async function runAgent(name, argv) {
+    timing("runAgent");
     const observationFlags = takeObserveFlag(argv);
     const { args, noPool, asked, pinned } = takePoolFlags(observationFlags.args);
     if (observationFlags.observe && name !== "claude" && name !== "codex") {
@@ -598,12 +631,15 @@ async function runAgent(name, argv) {
     const config = await ensureLogin();
     if (!config)
         return 2;
+    timing("login");
     // Hosted whoami below proves readiness and current Agent kind in one round trip.
     if (config.mode === "self-hosted" && !(await ensureProxy(config)))
         return 1;
+    timing("proxy");
     const agent = await resolveAgent(config, { harness: harnessOf(name) });
     if (!agent)
         return 1;
+    timing("agent");
     // The Agent's kind decides: a subscription Agent's harness brings its own
     // login (Claude Code its Claude one, Codex ChatGPT, Grok SuperGrok, Kimi
     // Code its Kimi plan), read fresh on every launch so a change in the
@@ -611,6 +647,7 @@ async function runAgent(name, argv) {
     // consumer plan, is metered with the flock's key.
     const vendor = subscriptionVendorFor(name);
     const me = await whoami(config.proxyUrl, { key: agent.key, unlock: config.unlock });
+    timing("whoami");
     if (config.mode === "hosted" && "error" in me) {
         fail(me.error);
         return 1;
@@ -640,6 +677,7 @@ async function runAgent(name, argv) {
     const { spec, env } = envFor({ name, proxyUrl: config.proxyUrl, presentedKey: key, auth });
     const poolVendor = auth === "subscription" ? poolVendorFor(name) : undefined;
     const pool = poolVendor ? await loadPool() : undefined;
+    timing("pool");
     const members = (poolVendor && pool?.members[poolVendor]) || [];
     const pooled = members.length > 0 && !noPool;
     if (asked && !pooled) {
@@ -697,6 +735,7 @@ async function runAgent(name, argv) {
         });
         return { done, stop: () => void child.kill("SIGTERM") };
     };
+    timing("home");
     if (!pooled || !poolVendor || !pool)
         return launch(args, env).done.finally(() => observation?.stop().catch(() => undefined));
     // Codex members each need their own home written before the first launch;
@@ -713,14 +752,20 @@ async function runAgent(name, argv) {
             await prepareCodexHome({ baseDir: member.dir, proxyUrl: config.proxyUrl, presentedKey: key, mode: config.mode, auth, userCodexHome: path.join(member.dir, "no-personal-login") });
         }
     }
+    timing("members");
     return runPooled(args, {
         harness: name,
         limits: limitsFor(pool, poolVendor),
         swap: pool.swap,
         ...(pinned ? { pinned } : {}),
-        standings: () => poolStandings(config, poolVendor, members),
+        standings: () => poolStandings(config, poolVendor, members).finally(() => timing("standings")),
         idle: () => poolIdle(config, poolVendor, agent.agentName),
-        start: (standing, launchArgs) => launch(launchArgs, { ...env, ...memberEnv(poolVendor, standing.member) }),
+        start: (standing, launchArgs) => {
+            timing("launch");
+            // The status line says which pool login this run is on; the harness passes its environment to it.
+            const poolEnv = { FLOCKTAB_POOL_LOGIN: standing.member.name, FLOCKTAB_POOL_SIZE: String(members.length) };
+            return launch(launchArgs, { ...env, ...memberEnv(poolVendor, standing.member), ...poolEnv });
+        },
         wait: (ms, until) => new Promise((resolve) => {
             const timer = setTimeout(() => resolve(true), ms);
             void until.then(() => {
@@ -944,7 +989,7 @@ async function statuslineInstall(args) {
     if (!/^y(es)?$/i.test(go))
         return 1;
     const done = await installStatusLine(vendor, home, process.env.FLOCKTAB_DEV ? "tabdev" : "tab");
-    ok(done === "already" ? `${file} already has a status line; left as it is.` : `Added. It shows on the next ${word} launch.`);
+    ok(done === "already" ? `${file} already runs tab's status line.` : done === "composed" ? `Added after yours: the file is backed up next to it, and your own line still runs first. It shows on the next ${word} launch.` : `Added. It shows on the next ${word} launch.`);
     return 0;
 }
 /** `tab use [claude|codex|grok|kimi]`: pick or change the Agent this folder runs a harness as; bare, the folder's default. */
@@ -1179,6 +1224,8 @@ async function main(argv) {
             return poolCommand(rest);
         case "status":
             return status();
+        case "top":
+            return topCommand(rest);
         case "statusline": {
             if (rest[0] === "install")
                 return statuslineInstall(rest.slice(1));
@@ -1187,7 +1234,9 @@ async function main(argv) {
                 console.log("FlockTab · not logged in");
                 return 0;
             }
-            console.log(await statusline(config, rest[0] && harnessOf(rest[0]) !== "any" ? harnessOf(rest[0]) : "any"));
+            // The harness hands its state on stdin; the person's own status line gets the same, and runs first.
+            const stdin = process.stdin.isTTY ? "" : await new Promise((resolve) => { let d = ""; process.stdin.setEncoding("utf8"); process.stdin.on("data", (c) => { d += c; }); process.stdin.on("end", () => resolve(d)); process.stdin.on("error", () => resolve(d)); setTimeout(() => resolve(d), 500); });
+            console.log(await composedStatusline(config, rest[0] && harnessOf(rest[0]) !== "any" ? harnessOf(rest[0]) : "any", stdin));
             return 0;
         }
         case "log":

package/dist/codex-home.js

@@ -56,6 +56,16 @@ export function codexSubscriptionParts(proxyUrl, presentedKey, model) {
                 `requires_openai_auth = true`,
                 `supports_websockets = false`,
             ].join("\n"),
+            // A session that started on an API-key Agent remembers one of the metered provider ids; on
+            // this Agent those names run the login through the tab as well.
+            ...["hosted", "self-hosted"].map((mode) => [
+                `[model_providers.${JSON.stringify(codexProviderId(mode))}]`,
+                `name = ${JSON.stringify(codexProviderId(mode))}`,
+                `base_url = ${JSON.stringify(codex)}`,
+                `wire_api = "responses"`,
+                `requires_openai_auth = true`,
+                `supports_websockets = false`,
+            ].join("\n")),
         ],
     };
 }
@@ -111,6 +121,16 @@ export function codexKeyParts(proxyUrl, model, mode = "hosted") {
                 `env_key = "OPENAI_API_KEY"`,
                 `wire_api = "responses"`,
             ].join("\n"),
+            // A session that ran on a subscription Agent remembers the `flocktab` provider. Here that name
+            // is the metered provider under another id, so the session resumes on this Agent's key
+            // instead of being refused at the passthrough.
+            [
+                `[model_providers.${CODEX_TAB_PROVIDER}]`,
+                `name = "OpenAI through FlockTab"`,
+                `base_url = ${JSON.stringify(`${proxyUrl}/v1`)}`,
+                `env_key = "OPENAI_API_KEY"`,
+                `wire_api = "responses"`,
+            ].join("\n"),
         ],
     };
 }

package/dist/manage.js

@@ -5,6 +5,7 @@
  * slug or a name; omitted, it is this folder's Agent from `.flocktab`.
  */
 import { spawn } from "node:child_process";
+import { quotaWindowLabel } from "./quota-windows.js";
 import { readProject } from "./project.js";
 import { saveConfig } from "./config.js";
 import { ConsoleApiError } from "./console-api.js";
@@ -219,7 +220,7 @@ export async function accounts(config, flags) {
             a.monthlyCents ? money(a.monthlyCents) : dim("-"),
             money(a.listCents),
             String(a.calls),
-            a.quota.length === 0 ? dim("-") : a.quota.map((q) => `${q.window} ${left(q)}`).join("  "),
+            a.quota.length === 0 ? dim("-") : a.quota.map((q) => `${quotaWindowLabel(q.window)} ${left(q)}`).join("  "),
             a.agents.join(", "),
         ]), { right: [3, 4, 5] }) + `\n${dim("Set a price or label in the console, Control, Subscriptions.")}`;
     });

package/dist/pool-view.js

@@ -3,23 +3,22 @@
  * used the vendor last said it is (a bar, then each window with when it
  * resets), and an arrow on the login the next launch would run as.
  */
-import { isOver, pickMember, windowMinutes } from "./pool.js";
+import { isOver, pickMember } from "./pool.js";
+import { compareQuotaWindows, quotaWindowLabel } from "./quota-windows.js";
 import { bold, dim, green, red, table, width, yellow } from "./ui.js";
 const BAR = 10;
-/** "2h 10m", "3d 4h", "12m": how long until a window resets. */
+/** "0h 12m", "2h 10m", "3d 04h": how long until a window resets, always six characters so columns hold. */
 export function until(resetsAt, now) {
     if (!resetsAt)
         return undefined;
     const ms = new Date(resetsAt).getTime() - now.getTime();
     if (!Number.isFinite(ms) || ms <= 0)
         return undefined;
-    const minutes = Math.round(ms / 60_000);
-    if (minutes < 60)
-        return `${Math.max(1, minutes)}m`;
+    const minutes = Math.max(1, Math.round(ms / 60_000));
     const hours = Math.floor(minutes / 60);
     if (hours < 24)
         return `${hours}h ${String(minutes % 60).padStart(2, "0")}m`;
-    return `${Math.floor(hours / 24)}d ${hours % 24}h`;
+    return `${Math.floor(hours / 24)}d ${String(hours % 24).padStart(2, "0")}h`;
 }
 function paint(pct, at) {
     return pct >= at ? red : pct >= at * 0.75 ? yellow : green;
@@ -37,7 +36,7 @@ export function planName(plan) {
     return plan.replace(/\b[a-z]/g, (c) => c.toUpperCase()).replace(/\b(\d+)X\b/g, "$1x");
 }
 function windowsLine(windows, limits, now) {
-    const sorted = [...(windows ?? [])].sort((a, b) => windowMinutes(a.window) - windowMinutes(b.window));
+    const sorted = [...(windows ?? [])].sort((a, b) => compareQuotaWindows(a.window, b.window));
     const live = sorted.filter((w) => !w.resetsAt || new Date(w.resetsAt).getTime() > now.getTime());
     if (!windows || windows.length === 0)
         return dim("no call through FlockTab yet");
@@ -48,7 +47,7 @@ function windowsLine(windows, limits, now) {
         const left = until(w.resetsAt, now);
         // The short window is judged by the threshold, the long one by its guard.
         const at = sorted.length > 1 && w === sorted.at(-1) ? limits.guard : limits.at;
-        return `${w.window} ${paint(w.usedPct, at)(`${Math.round(w.usedPct)}%`)}${left ? dim(` resets in ${left}`) : ""}`;
+        return `${quotaWindowLabel(w.window)} ${paint(w.usedPct, at)(`${Math.round(w.usedPct)}%`)}${left ? dim(` resets in ${left}`) : ""}`;
     })
         .join(dim("  ·  "));
 }

package/dist/pool.js

@@ -9,6 +9,7 @@
  * conversation as that other login.
  */
 import { chmod, mkdir, readdir, readFile, readlink, symlink, unlink, writeFile, lstat } from "node:fs/promises";
+import { compareQuotaWindows, quotaWindowIsLong, quotaWindowMinutes } from "./quota-windows.js";
 import { homedir } from "node:os";
 import path from "node:path";
 import { moveInto } from "./codex-home.js";
@@ -172,8 +173,7 @@ export async function prepareSharedSessions(vendor, member, env = process.env, u
 }
 /** `5h` is 300 minutes, `7d` 10080; a name that is not a length sorts last. */
 export function windowMinutes(window) {
-    const m = /^(\d+)([mhd])$/.exec(window);
-    return m ? Number(m[1]) * (m[2] === "d" ? 1440 : m[2] === "h" ? 60 : 1) : Number.MAX_SAFE_INTEGER;
+    return quotaWindowMinutes(window);
 }
 /**
  * How used an account is. The short window (Claude's 5 hours, Codex's
@@ -184,11 +184,14 @@ export function windowMinutes(window) {
 export function usage(quota, now = new Date()) {
     if (quota.length === 0)
         return {};
-    const sorted = [...quota].sort((x, y) => windowMinutes(x.window) - windowMinutes(y.window));
+    const sorted = [...quota].sort((x, y) => compareQuotaWindows(x.window, y.window));
     const pct = (w) => (!w.resetsAt || new Date(w.resetsAt).getTime() > now.getTime() ? w.usedPct : 0);
     const short = sorted[0];
-    const long = sorted.length > 1 ? sorted.at(-1) : undefined;
-    return { used: pct(short), ...(long ? { longUsed: pct(long) } : {}) };
+    // The week is whichever weekly window is fullest: Claude Max meters Fable on its own (7d_oi)
+    // beside the general 7d, and a login out of Fable is out for a Fable run.
+    const longs = sorted.filter((w) => quotaWindowIsLong(w.window));
+    const longUsed = longs.length > 0 ? Math.max(...longs.map(pct)) : undefined;
+    return { used: pct(short), ...(longUsed !== undefined ? { longUsed } : {}) };
 }
 const room = (s) => s.used ?? 0;
 const longRoom = (s) => s.longUsed ?? 0;

package/dist/proxy-bin.js

@@ -13,7 +13,7 @@ import { createRequire } from "node:module";
 import path from "node:path";
 import { configDir } from "./config.js";
 /** The proxy release `tab up` fetches. Bump with each proxy tag. */
-export const PROXY_VERSION = "0.1.14";
+export const PROXY_VERSION = "0.1.17";
 export const RELEASES = "https://github.com/joseairosa/flocktab/releases/download";
 export function targetFor(platform = process.platform, arch = process.arch) {
     if (platform === "darwin")

package/dist/quota-windows.js

@@ -0,0 +1,37 @@
+// GENERATED from packages/shared/src/quota-windows.ts by scripts/sync-docs.mjs. Edit that file, not this one.
+/**
+ * A vendor's quota windows, as the wire names them: "5h", "7d" (Claude Max,
+ * both models), "7d_oi" (Claude Max, the weekly window Fable has of its own;
+ * "oi" is the vendor's tag for it), "5h"/"7d" (ChatGPT). A window's name is
+ * its length, then an optional `_<tag>` for a model-specific one.
+ */
+/** Which models a tagged window belongs to, in the person's words. */
+const TAGS = {
+    oi: "Fable",
+};
+export function quotaWindowMinutes(window) {
+    const m = /^(\d+)([mhd])(?:_[a-z0-9]+)?$/.exec(window);
+    return m ? Number(m[1]) * (m[2] === "d" ? 1440 : m[2] === "h" ? 60 : 1) : Number.MAX_SAFE_INTEGER;
+}
+/** "Fable 7d" for "7d_oi"; a plain window is its own label. */
+export function quotaWindowLabel(window) {
+    const m = /^(\d+[mhd])_([a-z0-9]+)$/.exec(window);
+    if (!m)
+        return window;
+    const tag = TAGS[m[2]] ?? m[2];
+    return `${tag} ${m[1]}`;
+}
+/** The model a tagged window is for ("Fable"), or undefined for a window every model shares. */
+export function quotaWindowModel(window) {
+    const m = /^\d+[mhd]_([a-z0-9]+)$/.exec(window);
+    return m ? (TAGS[m[1]] ?? m[1]) : undefined;
+}
+/** A week-long window (or longer): the one that only matters once it is nearly spent. */
+export function quotaWindowIsLong(window) {
+    const minutes = quotaWindowMinutes(window);
+    return minutes !== Number.MAX_SAFE_INTEGER && minutes > 1440;
+}
+/** Sort order for windows: shortest first; a model's own window after the general one of the same length. */
+export function compareQuotaWindows(a, b) {
+    return quotaWindowMinutes(a) - quotaWindowMinutes(b) || (quotaWindowModel(a) ? 1 : 0) - (quotaWindowModel(b) ? 1 : 0);
+}

package/dist/statusline.js

@@ -5,39 +5,51 @@
  * from the console with a short cache, so a status bar that polls every
  * few seconds costs one request a minute.
  */
-import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { copyFile, mkdir, readFile, writeFile } from "node:fs/promises";
+import { compareQuotaWindows, quotaWindowLabel } from "./quota-windows.js";
+import { homedir } from "node:os";
+import { spawn } from "node:child_process";
 import path from "node:path";
 import { configDir } from "./config.js";
 import { readProject } from "./project.js";
 import { api } from "./manage.js";
 const CACHE_MS = 60_000;
-function windowMinutes(window) {
-    const m = /^(\d+)([mhd])$/.exec(window);
-    return m ? Number(m[1]) * (m[2] === "d" ? 1440 : m[2] === "h" ? 60 : 1) : Number.MAX_SAFE_INTEGER;
-}
 function money(cents) {
     const n = BigInt(cents);
     return `$${n / 100n}.${(n % 100n).toString().padStart(2, "0")}`;
 }
-/** "5h 36% · 7d 29%", shortest window first; nothing when the vendor said nothing yet. */
+/**
+ * "5h 36% · 7d 29%", shortest window first; nothing before the first call. A vendor that
+ * names the login but reports no usage on the wire (SuperGrok, Kimi) gets the login and says so.
+ */
 export function planLine(accounts, now = new Date()) {
     // The account most recently seen with quota: the login in use.
     const withQuota = accounts.filter((a) => a.quota.length > 0);
-    const account = withQuota[0];
+    const account = withQuota[0] ?? accounts[0];
     if (!account)
         return undefined;
+    if (account.quota.length === 0)
+        return `${account.email ?? `account ${account.externalId.slice(0, 8)}`} · usage not reported by the vendor`;
     const windows = [...account.quota]
         .filter((w) => !w.resetsAt || new Date(w.resetsAt).getTime() > now.getTime())
-        .sort((a, b) => windowMinutes(a.window) - windowMinutes(b.window));
+        .sort((a, b) => compareQuotaWindows(a.window, b.window));
     const who = account.email ?? `account ${account.externalId.slice(0, 8)}`;
-    return `${who} · ${windows.length === 0 ? "windows reset" : windows.map((w) => `${w.window} ${Math.round(w.usedPct)}%`).join(" · ")}`;
+    return `${who} · ${windows.length === 0 ? "windows reset" : windows.map((w) => `${quotaWindowLabel(w.window)} ${Math.round(w.usedPct)}%`).join(" · ")}`;
 }
-/** The line itself, from what the console said. */
-export function statusText(info, now = new Date()) {
+/** The line itself, from what the console said, and the pool login this run is on when there is one. */
+export function statusText(info, now = new Date(), pool) {
     const { tab } = info;
     const closed = tab.state !== "open";
     const head = `${tab.name}${closed ? " CLOSED" : ""}`;
     if (tab.kind === "subscription") {
+        if (pool) {
+            // The pool picked this login for the run: its own windows, not another login's that the
+            // console saw last on this Agent; the login is said once.
+            const mine = (info.accounts ?? []).filter((a) => a.email === pool.login || a.externalId === pool.login);
+            const plan = planLine(mine, now);
+            const windows = plan && plan.startsWith(`${pool.login} · `) ? plan.slice(pool.login.length + 3) : plan;
+            return `${head} · pool ${pool.login} (${pool.size}) · ${windows ?? "no call yet on this login"}`;
+        }
         return `${head} · ${planLine(info.accounts ?? [], now) ?? "no call yet"}`;
     }
     const spent = BigInt(tab.spentCents);
@@ -45,13 +57,22 @@ export function statusText(info, now = new Date()) {
     const pct = cap > 0n ? Number((spent * 100n) / cap) : 0;
     return `${head} · ${money(tab.spentCents)} of ${money(tab.capCents)} / ${tab.window} (${pct}%)`;
 }
+/** The pool login a pooled launch put in the harness's environment, which it passes on to us. */
+export function poolFromEnv(env = process.env) {
+    const login = env.FLOCKTAB_POOL_LOGIN?.trim();
+    if (!login)
+        return undefined;
+    const size = Number(env.FLOCKTAB_POOL_SIZE);
+    return { login, size: Number.isFinite(size) && size > 0 ? size : 1 };
+}
 /** The tab of this folder's Agent for `harness`, from a one-minute cache, else the console. */
 export async function statusline(config, harness, cwd = process.cwd(), env = process.env) {
     const project = await readProject(cwd, harness);
     if (!project)
         return "FlockTab · no Agent here (tab use)";
     const login = config.agents?.[project.agent];
-    const cacheFile = path.join(configDir(env), "cache", `status-${project.agent}.json`);
+    const pool = poolFromEnv(env);
+    const cacheFile = path.join(configDir(env), "cache", `status-${project.agent}${pool ? `-${pool.login.replace(/[^a-z0-9]+/gi, "_")}` : ""}.json`);
     try {
         const cached = JSON.parse(await readFile(cacheFile, "utf8"));
         if (Date.now() - cached.at < CACHE_MS)
@@ -63,7 +84,7 @@ export async function statusline(config, harness, cwd = process.cwd(), env = pro
     let text;
     try {
         const info = await api(config)("GET", `/api/cli/tabs/${encodeURIComponent(project.agent)}`);
-        text = `FlockTab · ${statusText(info)}`;
+        text = `FlockTab · ${statusText(info, new Date(), poolFromEnv(env))}`;
     }
     catch {
         return `FlockTab · ${login?.agentName ?? project.agent} · console unreachable`;
@@ -77,6 +98,86 @@ export async function statusline(config, harness, cwd = process.cwd(), env = pro
     }
     return text;
 }
+/**
+ * The status line command the person had before tab, if any. Their own files are read, never
+ * changed: Claude Code's `settings.local.json` then `settings.json`, Grok Build's `config.toml`,
+ * Kimi Code's `tui.toml`. When `tab statusline install` took the slot in a Grok or Kimi config,
+ * the original command it set aside under `<tab home>/statusline/` is what counts.
+ */
+export async function theirStatusCommand(harness, env = process.env) {
+    const ours = (cmd) => /\btab(dev)? statusline\b/.test(cmd);
+    try {
+        const saved = (await readFile(path.join(configDir(env), "statusline", `${harness}.original`), "utf8")).trim();
+        if (saved && !ours(saved))
+            return saved;
+    }
+    catch {
+        // Nothing set aside.
+    }
+    const home = env.HOME || homedir();
+    if (harness === "claude") {
+        for (const file of ["settings.local.json", "settings.json"]) {
+            try {
+                const parsed = JSON.parse(await readFile(path.join(home, ".claude", file), "utf8"));
+                const cmd = parsed.statusLine?.type === "command" ? parsed.statusLine.command?.trim() : undefined;
+                if (cmd && !ours(cmd))
+                    return cmd;
+            }
+            catch {
+                // No such file, or not JSON.
+            }
+        }
+        return undefined;
+    }
+    const file = harness === "grok" ? path.join(home, ".grok", "config.toml") : harness === "kimi" ? path.join(home, ".kimi-code", "tui.toml") : undefined;
+    if (!file)
+        return undefined;
+    try {
+        const cmd = statusCommandIn(await readFile(file, "utf8"), harness === "grok" ? "[ui.status_line]" : "[status_line]");
+        return cmd && !ours(cmd) ? cmd : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+/** The `command = "…"` of one TOML table, read by line so no TOML parser is needed. */
+export function statusCommandIn(toml, marker) {
+    const lines = toml.split("\n");
+    const start = lines.findIndex((l) => l.trim() === marker);
+    if (start < 0)
+        return undefined;
+    for (const line of lines.slice(start + 1)) {
+        if (/^\s*\[/.test(line))
+            break;
+        const m = /^\s*command\s*=\s*"((?:[^"\\]|\\.)*)"/.exec(line);
+        if (m)
+            return m[1].replace(/\\"/g, '"');
+    }
+    return undefined;
+}
+/** Run the person's own status command with the same stdin the harness gave us; all its lines, or nothing. */
+export function runTheirs(command, stdin, env = process.env) {
+    return new Promise((resolve) => {
+        const child = spawn("/bin/sh", ["-c", command], { env, stdio: ["pipe", "pipe", "ignore"] });
+        let out = "";
+        const timer = setTimeout(() => { child.kill("SIGKILL"); resolve(undefined); }, 4000);
+        child.stdout.on("data", (d) => { out += d.toString(); });
+        child.on("error", () => { clearTimeout(timer); resolve(undefined); });
+        child.on("close", () => { clearTimeout(timer); const text = out.replace(/\s+$/, ""); resolve(text.trim() ? text : undefined); });
+        // A command that exits before reading stdin (echo, true) closes the pipe.
+        // That EPIPE is on stdin, not the child, and must not escape the status line.
+        child.stdin.on("error", () => { });
+        child.stdin.end(stdin);
+    });
+}
+/** tab's line added after the person's own (every line of it), never instead of it. */
+export async function composedStatusline(config, harness, stdin, env = process.env) {
+    const mine = statusline(config, harness, process.cwd(), env);
+    const theirs = await theirStatusCommand(harness === "any" ? "claude" : harness, env);
+    const output = theirs ? await runTheirs(theirs, stdin, env) : undefined;
+    const ours = await mine;
+    return output ? `${output}\n${ours}` : ours;
+}
 /**
  * How each harness is told to run `tab statusline`. Claude Code takes it on
  * the command line, so every `tab claude` has it. Grok Build and Kimi Code
@@ -95,10 +196,15 @@ export function grokStatusToml(tabBin = "tab") {
 export function kimiStatusToml(tabBin = "tab") {
     return `\n[status_line]\ncommand = "${tabBin} statusline kimi"\n`;
 }
-/** Add the status line to a harness home that does not have one. Returns what was done. */
-export async function installStatusLine(vendor, home, tabBin = "tab") {
+/**
+ * Put tab's status line into a harness home. A status line already there is not lost: the file is
+ * copied to `<file>.bak-<date>` first and the original command is set aside under
+ * `<tab home>/statusline/<harness>.original`, which `tab statusline` runs and adds its own line to.
+ */
+export async function installStatusLine(vendor, home, tabBin = "tab", tabHome = configDir()) {
     const file = vendor === "xai" ? path.join(home, "config.toml") : path.join(home, "tui.toml");
     const marker = vendor === "xai" ? "[ui.status_line]" : "[status_line]";
+    const harness = vendor === "xai" ? "grok" : "kimi";
     let current = "";
     try {
         current = await readFile(file, "utf8");
@@ -106,9 +212,25 @@ export async function installStatusLine(vendor, home, tabBin = "tab") {
     catch {
         // No file yet.
     }
-    if (current.includes(marker))
-        return "already";
     await mkdir(home, { recursive: true, mode: 0o700 });
-    await writeFile(file, `${current.replace(/\s*$/, "\n")}${vendor === "xai" ? grokStatusToml(tabBin) : kimiStatusToml(tabBin)}`);
-    return "written";
+    if (!current.includes(marker)) {
+        await writeFile(file, `${current.replace(/\s*$/, "\n")}${vendor === "xai" ? grokStatusToml(tabBin) : kimiStatusToml(tabBin)}`);
+        return "written";
+    }
+    const existing = statusCommandIn(current, marker);
+    if (!existing || /\btab(dev)? statusline\b/.test(existing))
+        return "already";
+    // Theirs stays: backed up whole, its command set aside, and run first by tab's line.
+    const stamp = new Date().toISOString().slice(0, 10);
+    await copyFile(file, `${file}.bak-${stamp}`);
+    await mkdir(path.join(tabHome, "statusline"), { recursive: true, mode: 0o700 });
+    await writeFile(path.join(tabHome, "statusline", `${harness}.original`), `${existing}\n`, { mode: 0o600 });
+    const lines = current.split("\n");
+    const start = lines.findIndex((l) => l.trim() === marker);
+    for (let i = start + 1; i < lines.length && !/^\s*\[/.test(lines[i]); i++) {
+        if (/^\s*command\s*=/.test(lines[i]))
+            lines[i] = `command = "${tabBin} statusline ${harness}"`;
+    }
+    await writeFile(file, lines.join("\n"));
+    return "composed";
 }

package/dist/tab-docs.js

@@ -259,7 +259,7 @@ export const TAB_COMMANDS = [
             { cmd: "tab pool add claude me@example.com", what: "sign a Claude login in; the email is prefilled" },
             { cmd: "tab pool", what: "every login: plan, usage bar, each window and its reset, and which runs next" },
             { cmd: "tab pool at claude 70", what: "Claude logins give way at 70% of the 5-hour window" },
-            { cmd: "tab pool at 7d 90", what: "any login gives way once 90% of its week is used" },
+            { cmd: "tab pool at 7d 90", what: "any login gives way once 90% of its week is used (for Claude, the general week or Fable's own, whichever is fuller)" },
             { cmd: "tab claude --as me@example.com", what: "pin one login for this run" },
         ],
         see: ["accounts", "claude"],
@@ -272,6 +272,22 @@ export const TAB_COMMANDS = [
         details: ["The first thing to run when something is off. Exit code 0 only when the machine is logged in, the folder has an Agent with a key here, and the proxy is healthy."],
         see: ["login", "use", "up"],
     },
+    {
+        name: "top",
+        overview: "top [--every <seconds>] [--once]",
+        group: "watch",
+        usage: ["top", "top --every 5", "top --once"],
+        summary: "The flock on one screen, live: Agents, subscriptions and their windows, the pool, outside spend, the ledger.",
+        details: [
+            "An always-on dashboard in the terminal, redrawn every 2 seconds (--every sets it). At the top: the flock, its plan, Agents used of the plan's limit, whether the proxy answers. Then who is working right now, calls per minute and this window's spend with their trend; every Agent with its harness, project, spent of cap, calls per minute, calls blocked and its last decision; every subscription login with each of its windows (for Claude, the general 5h and 7d windows and Fable 7d, Fable's own week) and how long until each resets, with the pool's next pick marked; outside spend by project over the last 30 days with the unattributed share; and the ledger's latest decisions as they happen.",
+            "q, Escape or Ctrl-C leaves and the terminal is as it was; r redraws at once. --once prints one screen and returns, for a pipe or a quick look. A panel the console cannot answer on a tick is a line at the bottom, and the last good read stays on screen. Everything comes from the console the other commands read, so nothing here disagrees with tab list, tab pool, tab accounts or the Console.",
+        ],
+        options: [
+            { flag: "--every <seconds>", what: "how often to redraw (default 2, 1 to 3600)" },
+            { flag: "--once", what: "one screen, then return" },
+        ],
+        see: ["list", "pool", "accounts", "live", "status"],
+    },
     {
         name: "statusline",
         overview: "statusline [harness]",
@@ -279,8 +295,8 @@ export const TAB_COMMANDS = [
         usage: ["statusline [claude|codex|grok|kimi]", "statusline install grok|kimi"],
         summary: "One line for a harness's status bar: the Agent and its tab, or the plan's windows.",
         details: [
-            "Prints what this folder runs the harness as, then either spent of cap for an API-key Agent or, for a subscription, the login in use and each window's usage as the vendor last reported it (5h 36% · 7d 29%). Read from the console at most once a minute, so a status bar that refreshes every few seconds costs nothing.",
-            "Claude Code shows it on every tab claude, passed on the command line so no file of yours is touched (your own --settings wins). Grok Build and Kimi Code read a status line only from their config; a pool member gets it (that home is tab's), and tab statusline install grok|kimi adds it to your own config after asking. Codex takes no command and already shows its own limits.",
+            "Prints what this folder runs the harness as, then either spent of cap for an API-key Agent or, for a subscription, the login in use and each window's usage as the vendor last reported it (5h 36% · 7d 29%). On a pooled run it names the pool login the run is on and how many logins the pool has (pool me@x.com (4)). Read from the console at most once a minute, so a status bar that refreshes every few seconds costs nothing.",
+            "Your own status line stays. tab runs it first (Claude Code's from settings.local.json or settings.json, Grok's and Kimi's from their config, with the same stdin the harness gives) and adds its own line after it, every line of yours kept. Claude Code shows the pair on every tab claude, passed on the command line so no file of yours is touched (your own --settings wins). Grok Build and Kimi Code read a status line only from their config; a pool member gets it (that home is tab's), and tab statusline install grok|kimi puts it in your own config after asking: the file is backed up next to it first and a command already there is set aside and keeps running first. Codex takes no command and already shows its own limits.",
         ],
         examples: [
             { cmd: "tab statusline claude", what: "the line, as Claude Code's status bar would show it" },
@@ -343,15 +359,18 @@ export const TAB_COMMANDS = [
         group: "watch",
         usage: ["outside"],
         summary: "The outside-spend connections and their totals per project.",
-        details: ["Connections are made in the console (Control, Outside spend): provider admin APIs and cloud billing. They answer whether a dollar went through a tab or around it."],
+        details: [
+            "Connections are made in the console (Control, Outside spend): provider admin APIs and cloud billing. They answer whether a dollar went through a tab or around it.",
+            "The console pulls every connected source on its own, once an hour; the last sync shows per connection.",
+        ],
         see: ["spend", "project"],
     },
     {
         name: "live",
         group: "watch",
         usage: ["live"],
-        summary: "Who is working right now.",
-        details: ["Each Agent's pulse (working, recent, idle, stopped), calls per minute and last decision."],
+        summary: "Who is active right now.",
+        details: ["Each Agent's pulse (active, quiet, idle, stopped), calls per minute and last decision. Active means a call was admitted in the last minute. Quiet means calls in the last five minutes, but not the last minute."],
         options: [{ flag: "--watch N", what: "refresh every N seconds" }],
     },
     {
@@ -427,7 +446,7 @@ export const TAB_GLOSSARY = [
     { term: "Control plane", meaning: "The part of flocktab.com a self-hosted proxy settles through: identity, reserve, commit, refund, and for subscriptions the account and its quota." },
     { term: "Passthrough", meaning: "How a Subscription Agent's calls travel: /t/<tab key>/<vendor>/... on either proxy. The agent's own login is forwarded untouched; FlockTab adds nothing to the request and keeps no copy of the login." },
     { term: "Account", also: ["vendor account", "subscription"], meaning: "One plan login (a Claude Max, ChatGPT, SuperGrok or Kimi account) as the vendor named it on the wire. Discovered on first sight, with its plan tier, seat price and reported usage. Nobody types one in." },
-    { term: "Quota window", also: ["5h", "7d"], meaning: "A vendor's own usage limit over a period, reported on every reply: Claude's 5-hour and 7-day windows, Codex's primary and secondary. FlockTab keeps the latest figure and its reset time per account." },
+    { term: "Quota window", also: ["5h", "7d"], meaning: "A vendor's own usage limit over a period, reported on every reply: Claude's 5-hour and 7-day windows plus Fable's own 7-day window (shown as Fable 7d), Codex's primary and secondary. FlockTab keeps the latest figure and its reset time per account." },
     { term: "Pool", meaning: "Several logins of one vendor on one machine, and tab choosing between them by reported usage. Each member is a folder the agent signs in to itself." },
     { term: "Threshold", meaning: "In the pool: the share of the short window at which a login gives way to one with more room. 80% unless set, per vendor if you like." },
     { term: "Weekly guard", meaning: "In the pool: the share of the long window from which a login gives way whatever its short window says. 95% unless set. Below it the weekly window is ignored." },

package/dist/top.js

@@ -0,0 +1,413 @@
+import { isOver, pickMember } from "./pool.js";
+import { planName, until, usageBar } from "./pool-view.js";
+import { compareQuotaWindows, quotaWindowIsLong, quotaWindowLabel } from "./quota-windows.js";
+import { bold, cyan, dim, green, magenta, money, red, stripAnsi, width, yellow } from "./ui.js";
+export const HISTORY = 40;
+const SPARK = "▁▂▃▄▅▆▇█";
+/** A sparkline of the last `n` values, scaled to their own maximum. */
+export function sparkline(values, n = 24) {
+    const tail = values.slice(-n);
+    if (tail.length === 0)
+        return "";
+    const max = Math.max(...tail);
+    if (max <= 0)
+        return dim(SPARK[0].repeat(tail.length));
+    return tail.map((v) => SPARK[Math.min(SPARK.length - 1, Math.round((v / max) * (SPARK.length - 1)))]).join("");
+}
+/** "3s", "2m", "1h 05m", "3d": how long ago. */
+export function ago(iso, now) {
+    if (!iso)
+        return "-";
+    const ms = now.getTime() - new Date(iso).getTime();
+    if (!Number.isFinite(ms) || ms < 0)
+        return "now";
+    const s = Math.round(ms / 1000);
+    if (s < 60)
+        return `${s}s`;
+    const m = Math.floor(s / 60);
+    if (m < 60)
+        return `${m}m`;
+    const h = Math.floor(m / 60);
+    if (h < 24)
+        return `${h}h ${String(m % 60).padStart(2, "0")}m`;
+    return `${Math.floor(h / 24)}d`;
+}
+/** Cut a coloured line to `cols` visible characters, keeping escape sequences intact and closing them. */
+export function clip(line, cols) {
+    if (width(line) <= cols)
+        return line;
+    let out = "";
+    let seen = 0;
+    for (let i = 0; i < line.length;) {
+        if (line[i] === "\u001b") {
+            const end = line.indexOf("m", i);
+            if (end === -1)
+                break;
+            out += line.slice(i, end + 1);
+            i = end + 1;
+            continue;
+        }
+        const ch = line.codePointAt(i);
+        const chStr = String.fromCodePoint(ch);
+        const w = width(chStr);
+        if (seen + w > cols - 1)
+            break;
+        out += chStr;
+        seen += w;
+        i += chStr.length;
+    }
+    // Close an open colour only when one was opened; with colour off there is nothing to close.
+    return `${out}${out.includes("\u001b[") ? "\u001b[0m" : ""}${dim("…")}`;
+}
+function pad(text, cols, right = false) {
+    const gap = Math.max(0, cols - width(text));
+    return right ? `${" ".repeat(gap)}${text}` : `${text}${" ".repeat(gap)}`;
+}
+function pulseMark(pulse) {
+    switch (pulse) {
+        case "working":
+            return green("●");
+        case "recent":
+            return cyan("◐");
+        case "idle":
+            return dim("○");
+        default:
+            return red("■");
+    }
+}
+/** ALLOWED and SETTLED green, SHADOW (a subscription call priced at list) cyan, PENDING yellow, the rest red. */
+function decisionMark(decision) {
+    const d = decision.toUpperCase();
+    if (d.startsWith("ALLOW") || d === "OK" || d === "SETTLED")
+        return green(d);
+    if (d === "SHADOW")
+        return cyan(d);
+    if (d.startsWith("PEND"))
+        return yellow(d);
+    if (d.startsWith("FLAG"))
+        return magenta(d);
+    if (d === "REFUNDED")
+        return dim(d);
+    return red(d);
+}
+const failingConnector = (c) => c.status !== "active";
+function pctOf(spent, cap) {
+    const c = Number(cap);
+    if (!Number.isFinite(c) || c <= 0)
+        return undefined;
+    return Math.min(999, (Number(spent) / c) * 100);
+}
+function tone(pct) {
+    if (pct === undefined)
+        return dim;
+    return pct >= 100 ? red : pct >= 75 ? yellow : green;
+}
+function section(title, note, cols) {
+    const head = `${bold(title)} ${dim(note)}`;
+    const rule = Math.max(0, cols - width(head) - 1);
+    return `${head} ${dim("─".repeat(rule))}`;
+}
+function header(snap, cols, now) {
+    const proxy = snap.proxy.health.ok ? green("● proxy") : red(`■ proxy ${snap.proxy.health.reason}`);
+    const agents = snap.flock.agentLimit === null ? `${snap.flock.agents} Agents` : `${snap.flock.agents}/${snap.flock.agentLimit} Agents`;
+    const agentsTone = snap.flock.agentLimit !== null && snap.flock.agents >= snap.flock.agentLimit ? yellow : (t) => t;
+    const clock = now.toLocaleTimeString("en-GB", { hour12: false });
+    const left = `${bold(magenta("FlockTab"))} ${bold("top")}  ${bold(snap.flock.name)} ${dim("·")} ${planName(snap.flock.plan) ?? snap.flock.plan} ${dim("·")} ${agentsTone(agents)} ${dim("·")} ${proxy} ${dim(snap.proxy.mode)}`;
+    const right = `${dim("q quit · r refresh")}  ${clock}`;
+    const gap = Math.max(1, cols - width(left) - width(right));
+    return [`${left}${" ".repeat(gap)}${right}`];
+}
+function totalsLine(snap) {
+    const t = snap.live?.totals;
+    if (!t)
+        return dim("live totals unavailable");
+    const cpm = snap.history.map((h) => h.callsPerMinute);
+    const cents = snap.history.map((h) => h.windowCents);
+    const parts = [
+        `${green(String(t.active))} working`,
+        `${bold(t.callsPerMinute.toFixed(1))} calls/min ${cyan(sparkline(cpm))}`,
+        `${(t.blocked > 0 ? red : dim)(String(t.blocked))} blocked`,
+        `${bold(money(t.windowCents))} this window ${cyan(sparkline(cents))}`,
+    ];
+    if (snap.outside)
+        parts.push(`outside 30d ${bold(money(sumCents(snap.outside.byProject.map((p) => p.cents))))}`);
+    return parts.join(dim("  ·  "));
+}
+function sumCents(list) {
+    return list.reduce((sum, c) => sum + BigInt(String(c).replace(/[^0-9-]/g, "") || "0"), 0n);
+}
+function agentsPanel(snap, cols, max, now) {
+    const out = [];
+    const agents = snap.live?.agents ?? [];
+    const shown = [...agents].sort((a, b) => rank(a) - rank(b) || b.callsPerMinute - a.callsPerMinute || a.name.localeCompare(b.name));
+    out.push(section("Agents", `${agents.filter((a) => a.pulse === "working").length} working · ${agents.filter((a) => a.tabState !== "open").length} closed`, cols));
+    if (shown.length === 0) {
+        out.push(dim("  no Agents yet · tab claude in a project folder makes one"));
+        return out;
+    }
+    const nameW = Math.min(24, Math.max(5, ...shown.map((a) => width(a.name))));
+    const projW = Math.min(18, Math.max(7, ...shown.map((a) => width(a.projectName ?? "-"))));
+    out.push(dim(`  ${pad("", 1)} ${pad("agent", nameW)} ${pad("harness", 7)} ${pad("project", projW)} ${pad("spent / cap · login", 32)} ${pad("c/min", 5, true)} ${pad("blk", 3, true)} ${pad("last", 8)} ${pad("ago", 6)} reason`));
+    for (const a of shown.slice(0, max)) {
+        const pct = a.kind === "subscription" ? undefined : pctOf(a.spentCents, a.capCents);
+        // A subscription Agent shows the login its latest call landed on instead of a cap it does not have.
+        const spent = a.kind === "subscription" ? (a.lastAccount ? cyan(clip(a.lastAccount, 32)) : dim("subscription · no call yet")) : `${tone(pct)(money(a.spentCents))} ${dim(`/ ${money(a.capCents)}`)}`;
+        const bar = a.kind === "subscription" ? "" : usageBar(pct, 100);
+        const last = a.lastDecision ? decisionMark(a.lastDecision) : dim("-");
+        const reason = a.lastReason ?? "";
+        out.push(`  ${pulseMark(a.pulse)} ${pad(clip(a.name, nameW), nameW)} ${pad(a.harness === "any" ? dim("any") : a.harness, 7)} ${pad(clip(a.projectName ?? dim("-"), projW), projW)} ${pad(`${spent}${bar ? ` ${bar}` : ""}`, 32)} ${pad((a.callsPerMinute > 0 ? bold : dim)(a.callsPerMinute.toFixed(1)), 5, true)} ${pad((a.blocked > 0 ? red : dim)(String(a.blocked)), 3, true)} ${pad(last, 8)} ${pad(dim(ago(a.lastAt, now)), 6)} ${dim(reason)}`);
+    }
+    if (shown.length > max)
+        out.push(dim(`  … ${shown.length - max} more`));
+    return out;
+}
+function rank(a) {
+    return a.pulse === "working" ? 0 : a.pulse === "recent" ? 1 : a.pulse === "idle" ? 2 : 3;
+}
+const VENDOR_TITLES = { anthropic: "Claude", openai: "ChatGPT", xai: "Grok", kimi: "Kimi" };
+function standingFor(pool, account) {
+    for (const s of pool ?? []) {
+        if (s.vendor !== account.provider)
+            continue;
+        const limits = s.limits ?? { at: 80, guard: 95 };
+        const next = pickMember(s.standings, limits)?.member.name;
+        for (const st of s.standings) {
+            if (account.email && st.email && st.email.toLowerCase() === account.email.toLowerCase())
+                return { standing: st, next: st.member.name === next, over: isOver(st, limits) };
+        }
+    }
+    return undefined;
+}
+function subscriptionsPanel(snap, cols, now) {
+    const out = [];
+    const accounts = snap.accounts ?? [];
+    const pooled = (snap.pool ?? []).reduce((n, s) => n + s.standings.length, 0);
+    out.push(section("Subscriptions", `${accounts.length} ${accounts.length === 1 ? "login" : "logins"}${pooled > 0 ? ` · ${pooled} in the pool` : ""}`, cols));
+    if (accounts.length === 0) {
+        out.push(dim("  no subscription login seen yet · tab claude with a subscription Agent"));
+        return out;
+    }
+    const whoW = Math.min(30, Math.max(5, ...accounts.map((a) => width(a.email ?? "account"))));
+    const planW = Math.max(4, ...accounts.map((a) => width(planName(a.planLabel ?? undefined) ?? "-")));
+    const live = (a) => a.quota.filter((w) => !w.resetsAt || new Date(w.resetsAt).getTime() > now.getTime());
+    // One slot per window the vendor has on any of its logins, so the columns hold across rows:
+    // a login that has not reported a window yet (Fable before its first Fable call) leaves the slot blank.
+    const slots = new Map();
+    for (const a of accounts) {
+        const names = slots.get(a.provider) ?? [];
+        for (const w of live(a))
+            if (!names.includes(w.window))
+                names.push(w.window);
+        slots.set(a.provider, names.sort(compareQuotaWindows));
+    }
+    // Label width per vendor: Claude's "Fable 7d" must not widen ChatGPT's "7d".
+    const labelWidth = (provider) => Math.max(2, ...(slots.get(provider) ?? []).map((w) => width(quotaWindowLabel(w))));
+    for (const a of [...accounts].sort((x, y) => x.provider.localeCompare(y.provider) || (x.email ?? "").localeCompare(y.email ?? ""))) {
+        const pool = standingFor(snap.pool, a);
+        const mark = pool?.next ? green("→") : pool?.over ? red("×") : pool ? dim("·") : " ";
+        const mine = new Map(live(a).map((w) => [w.window, w]));
+        const labelW = labelWidth(a.provider);
+        const cellW = labelW + 1 + 10 + 1 + 4 + 1 + 7; // label, bar, "100%", reset ("11h 00m")
+        const cells = (slots.get(a.provider) ?? []).map((name) => {
+            const w = mine.get(name);
+            if (!w)
+                return pad("", cellW);
+            const at = quotaWindowIsLong(name) ? 95 : 80;
+            const label = quotaWindowLabel(name);
+            const paint = w.usedPct >= at ? red : w.usedPct >= at * 0.75 ? yellow : green;
+            const left = until(w.resetsAt, now);
+            return `${pad((label.startsWith("Fable") ? magenta : dim)(label), labelW)} ${usageBar(w.usedPct, at)} ${paint(`${String(Math.round(w.usedPct)).padStart(3)}%`)} ${pad(left ? dim(left) : "", 7)}`;
+        });
+        const line = `  ${mark} ${pad(VENDOR_TITLES[a.provider] ?? a.vendor, 7)} ${pad(clip(a.email ?? dim("account"), whoW), whoW)} ${pad(planName(a.planLabel ?? undefined) ?? dim("-"), planW)}  ${cells.length > 0 ? cells.join(dim("  ")) : dim("no window reported yet")}  ${dim(`${a.calls} calls · seen ${ago(a.lastSeenAt, now)}`)}`;
+        out.push(line);
+    }
+    if (pooled > 0)
+        out.push(dim(`  ${green("→")} the pool's next pick · ${red("×")} over its limit · Fable's own week beside Claude's general one`));
+    return out;
+}
+function outsidePanel(snap, cols, max, now) {
+    const out = [];
+    const o = snap.outside;
+    if (!o)
+        return out;
+    const total = sumCents(o.byProject.map((p) => p.cents));
+    const failing = o.connections.filter(failingConnector);
+    out.push(section("Outside spend", `last 30 days · ${money(total)} · ${o.connections.length} ${o.connections.length === 1 ? "connector" : "connectors"}${failing.length > 0 ? ` · ${failing.length} failing` : ""}`, cols));
+    if (o.byProject.length === 0 && o.connections.length === 0) {
+        out.push(dim("  no connector yet · Console → Outside spend"));
+        return out;
+    }
+    const rows = [...o.byProject].sort((x, y) => Number(BigInt(y.cents) - BigInt(x.cents)));
+    const nameW = Math.min(28, Math.max(7, ...rows.map((p) => width(p.projectName))));
+    const barW = 20;
+    for (const p of rows.slice(0, max)) {
+        const cents = BigInt(p.cents);
+        const share = total > 0n ? Number((cents * 1000n) / total) / 10 : 0;
+        const filled = Math.round((share / 100) * barW);
+        const unattributed = p.projectId === null;
+        out.push(`  ${pad(clip(unattributed ? yellow(p.projectName) : p.projectName, nameW), nameW)} ${(unattributed ? yellow : cyan)("█".repeat(filled))}${dim("░".repeat(barW - filled))} ${pad(money(cents), 10, true)} ${dim(`${share.toFixed(0)}%`)}`);
+    }
+    if (rows.length > max)
+        out.push(dim(`  … ${rows.length - max} more`));
+    for (const c of failing.slice(0, 2))
+        out.push(`  ${red("■")} ${c.label} ${dim(c.lastError ?? c.status)}${c.lastSyncAt ? dim(` · synced ${ago(c.lastSyncAt, now)} ago`) : ""}`);
+    return out;
+}
+function tapePanel(snap, cols, max) {
+    const out = [];
+    const tape = snap.live?.tape ?? [];
+    out.push(section("Ledger", "latest decisions", cols));
+    if (tape.length === 0) {
+        out.push(dim("  no call yet"));
+        return out;
+    }
+    const agentW = Math.min(20, Math.max(5, ...tape.map((t) => width(t.agent))));
+    for (const t of tape.slice(0, max)) {
+        const time = t.at.length > 8 ? t.at.slice(-8) : t.at;
+        const bad = !["ALLOWED", "SETTLED", "SHADOW", "PENDING", "REFUNDED"].includes(t.decision.toUpperCase());
+        out.push(`  ${dim(time)} ${pad(clip(t.agent, agentW), agentW)} ${pad(decisionMark(t.decision), 8)} ${pad(t.amount, 8, true)} ${pad(clip(t.action, 30), 30)} ${pad(t.model ? dim(clip(t.model, 34)) : "", 34)} ${bad ? red(t.reason) : dim(t.reason)}`);
+    }
+    return out;
+}
+/** The whole screen as lines, each cut to the terminal's width; never more lines than `rows`. */
+export function renderTop(snap, size, now = snap.at) {
+    const cols = Math.max(60, size.columns);
+    const rows = Math.max(12, size.rows);
+    const fixed = 1 + 1 + 1; // header, totals, a blank line
+    const subs = subscriptionsPanel(snap, cols, now);
+    const errors = snap.errors.map((e) => red(`  ! ${e}`));
+    // Whatever is left after the header, the logins and any errors is split
+    // between the Agents, the outside projects and the tape, Agents first.
+    const agentCount = snap.live?.agents.length ?? 0;
+    const outsideCount = snap.outside ? Math.min(6, snap.outside.byProject.length + Math.min(2, snap.outside.connections.filter(failingConnector).length)) : 0;
+    let budget = rows - fixed - subs.length - errors.length - 1;
+    const agentRows = Math.max(3, Math.min(agentCount + 2, Math.floor(budget * 0.45)));
+    budget -= agentRows + 1;
+    const outsideRows = snap.outside ? Math.max(0, Math.min(outsideCount + 1, Math.floor(budget * 0.35))) : 0;
+    budget -= outsideRows > 0 ? outsideRows + 1 : 0;
+    const tapeRows = Math.max(2, budget);
+    const lines = [
+        ...header(snap, cols, now),
+        totalsLine(snap),
+        "",
+        ...agentsPanel(snap, cols, Math.max(1, agentRows - 2), now),
+        "",
+        ...subs,
+        "",
+        ...(outsideRows > 0 ? [...outsidePanel(snap, cols, Math.max(1, outsideRows - 1), now), ""] : []),
+        ...tapePanel(snap, cols, Math.max(1, tapeRows - 1)),
+        ...errors,
+    ];
+    return lines.slice(0, rows).map((l) => clip(l, cols));
+}
+/** One read of every panel; a panel that fails is a line at the bottom, never a blank screen. */
+export async function fetchSnapshot(deps, previous) {
+    const errors = [];
+    const note = (what) => (err) => {
+        errors.push(`${what}: ${err instanceof Error ? err.message : String(err)}`);
+        return undefined;
+    };
+    const [flock, live, accounts, outside, health, pool] = await Promise.all([
+        deps.call("GET", "/api/cli/agents").catch(note("agents")),
+        deps.call("GET", "/api/cli/live").catch(note("live")),
+        deps.call("GET", "/api/cli/accounts").catch(note("accounts")),
+        deps.call("GET", "/api/cli/outside").catch(note("outside")),
+        deps.health().catch((err) => ({ ok: false, reason: err instanceof Error ? err.message : String(err) })),
+        deps.pool ? deps.pool().catch(note("pool")) : Promise.resolve(undefined),
+    ]);
+    const history = [...(previous?.history ?? [])];
+    if (live) {
+        history.push({ callsPerMinute: live.totals.callsPerMinute, windowCents: Number(live.totals.windowCents) });
+        while (history.length > HISTORY)
+            history.shift();
+    }
+    return {
+        at: new Date(),
+        flock: flock
+            ? { name: flock.flock.name, plan: flock.flock.plan, agents: flock.agents.length, agentLimit: flock.flock.agentLimit ?? null }
+            : (previous?.flock ?? { name: deps.config.flockName ?? "flock", plan: "solo", agents: 0, agentLimit: null }),
+        proxy: { url: deps.config.proxyUrl, mode: deps.config.mode, health },
+        ...(live ? { live } : previous?.live ? { live: previous.live } : {}),
+        ...(accounts ? { accounts: accounts.accounts } : previous?.accounts ? { accounts: previous.accounts } : {}),
+        ...(outside ? { outside } : previous?.outside ? { outside: previous.outside } : {}),
+        ...(pool ? { pool } : previous?.pool ? { pool: previous.pool } : {}),
+        errors,
+        history,
+    };
+}
+const ALT_ON = "\u001b[?1049h\u001b[?25l";
+const ALT_OFF = "\u001b[?25h\u001b[?1049l";
+/** Draw in place: home, each line cleared to its end, then everything below. No flicker from a full clear. */
+function paint(lines, out) {
+    out.write(`\u001b[H${lines.map((l) => `${l}\u001b[K`).join("\n")}\u001b[J`);
+}
+/**
+ * Runs until `q`, Escape or Ctrl-C. `--every <seconds>` sets the refresh (2 by
+ * default, never under 1); `--once` prints one screen and returns, for a pipe
+ * or a quick look.
+ */
+export async function runTop(deps, opts, io = {}) {
+    const stdout = io.stdout ?? process.stdout;
+    const stdin = io.stdin ?? process.stdin;
+    // A pipe has no size: COLUMNS if the shell exports it, else wide enough that nothing useful is cut.
+    const size = () => ({ columns: stdout.columns || Number(process.env.COLUMNS) || 160, rows: stdout.rows || Number(process.env.LINES) || 40 });
+    let snap = await fetchSnapshot(deps);
+    if (opts.once) {
+        stdout.write(`${renderTop(snap, { columns: size().columns, rows: 200 }).join("\n")}\n`);
+        return 0;
+    }
+    const every = Math.max(1, opts.every) * 1000;
+    let stopped = false;
+    let wake;
+    const stop = () => {
+        stopped = true;
+        wake?.();
+    };
+    const onKey = (chunk) => {
+        const key = chunk.toString();
+        if (key === "q" || key === "Q" || key === "\u0003" || key === "\u001b")
+            stop();
+        else if (key === "r" || key === "R")
+            wake?.();
+    };
+    const onResize = () => paint(renderTop(snap, size(), new Date()), stdout);
+    const interactive = Boolean(stdin.isTTY && typeof stdin.setRawMode === "function");
+    stdout.write(ALT_ON);
+    if (interactive) {
+        stdin.setRawMode(true);
+        stdin.resume();
+        stdin.on("data", onKey);
+    }
+    stdout.on("resize", onResize);
+    process.once("SIGINT", stop);
+    process.once("SIGTERM", stop);
+    try {
+        while (!stopped) {
+            paint(renderTop(snap, size(), new Date()), stdout);
+            await new Promise((resolve) => {
+                wake = resolve;
+                setTimeout(resolve, every).unref();
+            });
+            wake = undefined;
+            if (stopped)
+                break;
+            snap = await fetchSnapshot(deps, snap);
+        }
+    }
+    finally {
+        stdout.off("resize", onResize);
+        process.off("SIGINT", stop);
+        process.off("SIGTERM", stop);
+        if (interactive) {
+            stdin.off("data", onKey);
+            stdin.setRawMode(false);
+            stdin.pause();
+        }
+        stdout.write(ALT_OFF);
+    }
+    return 0;
+}
+/** For tests: the visible text of a screen. */
+export function plain(lines) {
+    return lines.map(stripAnsi).join("\n");
+}

package/dist/version.js

@@ -1,2 +1,2 @@
 /** Written by scripts/write-version.mjs from package.json at build; `tab version` prints it. */
-export const TAB_VERSION = "0.1.20";
+export const TAB_VERSION = "0.1.22";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hanamorilabs/tab",
-  "version": "0.1.20",
+  "version": "0.1.22",
   "description": "Run any AI agent on a FlockTab tab: tab claude, tab codex, tab <command>.",
   "license": "MIT",
   "type": "module",
@@ -22,11 +22,11 @@
     "prepublishOnly": "pnpm build"
   },
   "optionalDependencies": {
-    "@hanamorilabs/flocktab-proxy-darwin-arm64": "0.1.14",
-    "@hanamorilabs/flocktab-proxy-darwin-x64": "0.1.14",
-    "@hanamorilabs/flocktab-proxy-linux-x64": "0.1.14",
-    "@hanamorilabs/flocktab-proxy-linux-arm64": "0.1.14",
-    "@hanamorilabs/flocktab-proxy-win-x64": "0.1.14"
+    "@hanamorilabs/flocktab-proxy-darwin-arm64": "0.1.17",
+    "@hanamorilabs/flocktab-proxy-darwin-x64": "0.1.17",
+    "@hanamorilabs/flocktab-proxy-linux-x64": "0.1.17",
+    "@hanamorilabs/flocktab-proxy-linux-arm64": "0.1.17",
+    "@hanamorilabs/flocktab-proxy-win-x64": "0.1.17"
   },
   "devDependencies": {
     "@types/node": "^22.18.6",