@hanamorilabs/tab 0.1.21 → 0.1.22

package/dist/cli.js

@@ -36,6 +36,7 @@ import { addMember, loadPool, memberEnv, memberHome, POOL_VENDORS, poolVendorFor
 import { runPooled } from "./pool-run.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) {
@@ -1194,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));

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.16";
+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

@@ -6,6 +6,7 @@
  * few seconds costs one request a minute.
  */
 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";
@@ -13,10 +14,6 @@ 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")}`;
@@ -35,9 +32,9 @@ export function planLine(accounts, now = new Date()) {
         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, and the pool login this run is on when there is one. */
 export function statusText(info, now = new Date(), pool) {
@@ -167,6 +164,9 @@ export function runTheirs(command, stdin, env = process.env) {
         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);
     });
 }

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]",
@@ -430,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.21";
+export const TAB_VERSION = "0.1.22";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hanamorilabs/tab",
-  "version": "0.1.21",
+  "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.16",
-    "@hanamorilabs/flocktab-proxy-darwin-x64": "0.1.16",
-    "@hanamorilabs/flocktab-proxy-linux-x64": "0.1.16",
-    "@hanamorilabs/flocktab-proxy-linux-arm64": "0.1.16",
-    "@hanamorilabs/flocktab-proxy-win-x64": "0.1.16"
+    "@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",