@hanamorilabs/tab 0.1.11 → 0.1.13

package/dist/help.js

@@ -0,0 +1,105 @@
+/**
+ * `tab help`, drawn from the one command reference (`tab-docs.ts`, generated
+ * from packages/shared): the overview by group, one command in full, the
+ * glossary, and the refusals a call can meet.
+ */
+import { findTabCommand, TAB_COMMAND_GROUPS, TAB_COMMANDS, TAB_ERRORS, TAB_GLOSSARY } from "./tab-docs.js";
+import { bold, cyan, dim, heading, rows, width, yellow } from "./ui.js";
+const DOCS_URL = "https://console.flocktab.com/docs";
+/** Break a paragraph at word boundaries so it fits `cols`, each line after `indent` spaces. */
+export function wrap(text, cols, indent = 0) {
+    const room = Math.max(24, cols - indent);
+    const lines = [];
+    let line = "";
+    for (const word of text.split(/\s+/).filter(Boolean)) {
+        if (line && width(line) + 1 + width(word) > room) {
+            lines.push(line);
+            line = word;
+        }
+        else
+            line = line ? `${line} ${word}` : word;
+    }
+    if (line)
+        lines.push(line);
+    return lines.map((l) => `${" ".repeat(indent)}${l}`).join("\n");
+}
+const columns = () => Math.min(100, Math.max(60, process.stdout.columns ?? 100));
+export function renderOverview(opts) {
+    const cols = opts.cols ?? columns();
+    const out = [`${heading("tab")} ${dim("- run any AI agent on a FlockTab tab: a hard cap, a kill switch and a record of every call")}`, ""];
+    // One width for the usage column across every group, so the summaries line up.
+    const first = (c) => `tab ${c.overview ?? c.usage[0]}`;
+    const left = Math.min(42, Math.max(...TAB_COMMANDS.map((c) => width(first(c)))));
+    for (const group of TAB_COMMAND_GROUPS) {
+        out.push(bold(group.title));
+        out.push(dim(wrap(group.blurb, cols, 2)));
+        for (const c of TAB_COMMANDS.filter((x) => x.group === group.id)) {
+            const name = first(c);
+            const label = width(name) > left ? `${name.slice(0, left - 1)}…` : name;
+            const text = wrap(c.summary, cols, left + 4).trimStart();
+            out.push(`  ${cyan(label)}${" ".repeat(left - width(label))}  ${text}`);
+        }
+        out.push("");
+    }
+    out.push(`${bold("tab help <command>")}  ${dim("everything about one command: what it does, its options, examples")}`);
+    out.push(`${bold("tab help glossary")}   ${dim("what is what: Agent, tab, kind, hold, unlock, pool, ...")}`);
+    out.push(`${bold("tab help errors")}     ${dim("every refusal a call can meet, and what to do")}`);
+    out.push("");
+    out.push(dim(`Docs ${DOCS_URL}   Config ${opts.configPath}   or FLOCKTAB_PROXY_URL, FLOCKTAB_KEY, FLOCKTAB_UNLOCK`));
+    return out.join("\n");
+}
+export function renderCommand(doc, cols = columns()) {
+    const out = [`${heading(`tab ${doc.name}`)}${doc.aliases?.length ? dim(`  also: ${doc.aliases.join(", ")}`) : ""}`, wrap(doc.summary, cols), ""];
+    out.push(bold("Usage"));
+    for (const u of doc.usage)
+        out.push(`  ${cyan(`tab ${u}`)}`);
+    out.push("");
+    for (const p of doc.details)
+        out.push(wrap(p, cols), "");
+    if (doc.options?.length) {
+        out.push(bold("Options"));
+        const w = Math.max(...doc.options.map((o) => width(o.flag)));
+        for (const o of doc.options)
+            out.push(`  ${yellow(o.flag)}${" ".repeat(w - width(o.flag))}  ${wrap(o.what, cols, w + 4).trimStart()}`);
+        out.push("");
+    }
+    if (doc.examples?.length) {
+        out.push(bold("Examples"));
+        const w = Math.max(...doc.examples.map((e) => width(e.cmd)));
+        for (const e of doc.examples)
+            out.push(`  ${cyan(e.cmd)}${" ".repeat(w - width(e.cmd))}  ${dim(wrap(e.what, cols, w + 4).trimStart())}`);
+        out.push("");
+    }
+    if (doc.see?.length)
+        out.push(dim(`See also: ${doc.see.map((s) => `tab help ${s}`).join(" · ")}`));
+    return out.join("\n").trimEnd();
+}
+export function renderGlossary(cols = columns()) {
+    const out = [heading("What is what"), ""];
+    for (const e of [...TAB_GLOSSARY].sort((a, b) => a.term.replace(/^[^A-Za-z]+/, "").localeCompare(b.term.replace(/^[^A-Za-z]+/, "")))) {
+        out.push(`${bold(e.term)}${e.also?.length ? dim(`  (${e.also.join(", ")})`) : ""}`);
+        out.push(wrap(e.meaning, cols, 2), "");
+    }
+    return out.join("\n").trimEnd();
+}
+export function renderErrors(cols = columns()) {
+    const out = [heading("When a call is refused"), wrap("A refusal always happens before the provider or vendor is reached, and carries an x-flocktab-reason header naming the rule.", cols), ""];
+    for (const e of TAB_ERRORS) {
+        out.push(`${yellow(String(e.status))} ${bold(e.code)}`);
+        out.push(wrap(e.when, cols, 2));
+        out.push(dim(wrap(`Do: ${e.fix}`, cols, 2)), "");
+    }
+    return out.join("\n").trimEnd();
+}
+/** What `tab help [word]` prints, or undefined when the word names nothing. */
+export function renderHelp(word, opts) {
+    if (!word)
+        return renderOverview(opts);
+    if (word === "glossary" || word === "terms")
+        return renderGlossary();
+    if (word === "errors" || word === "error")
+        return renderErrors();
+    const doc = findTabCommand(word);
+    return doc ? renderCommand(doc) : undefined;
+}
+export { rows };

package/dist/logins.js

@@ -38,8 +38,8 @@ function jwtClaims(token) {
 /**
  * Claude Code keeps the signed-in account (not the token) in `~/.claude.json`
  * under `oauthAccount`; Codex keeps its ChatGPT login in `auth.json` under
- * the home it runs with. Grok Build and Kimi Code are asked nothing: their
- * accounts are read off the wire by the proxy.
+ * the home it runs with; Grok Build keeps email and id in `auth.json`; Kimi
+ * Code's account is the subject of its login token.
  */
 export async function localLogin(vendor, opts = {}) {
     const home = opts.home ?? homedir();
@@ -66,6 +66,31 @@ export async function localLogin(vendor, opts = {}) {
         const accountId = str(tokens.account_id) ?? str(authClaims?.chatgpt_account_id);
         return { ...(email ? { email } : {}), ...(plan ? { plan } : {}), ...(accountId ? { accountId } : {}) };
     }
+    if (vendor === "xai") {
+        // Grok Build: `auth.json` is one entry per issuer, with the account's email and id beside the token.
+        const auth = await jsonFile(path.join(opts.grokHome ?? path.join(home, ".grok"), "auth.json"));
+        const entry = Object.values(auth ?? {}).find((v) => Boolean(v) && typeof v === "object");
+        if (!entry)
+            return undefined;
+        const email = str(entry.email);
+        // The proxy files Grok calls under the login token's subject, then its user id: read it the same way.
+        const claims = jwtClaims(entry.key);
+        const accountId = str(claims?.sub) ?? str(claims?.user_id) ?? str(entry.user_id);
+        return email || accountId ? { ...(email ? { email } : {}), ...(accountId ? { accountId } : {}) } : undefined;
+    }
+    if (vendor === "kimi") {
+        // Kimi Code names no email; the login token's subject is the account the proxy files calls under.
+        // Kimi Code keeps its home in `~/.kimi-code`, the older kimi-cli in `~/.kimi`; same file inside.
+        const homes = opts.kimiShareDir ? [opts.kimiShareDir] : [path.join(home, ".kimi-code"), path.join(home, ".kimi")];
+        let cred;
+        for (const dir of homes) {
+            cred = await jsonFile(path.join(dir, "credentials", "kimi-code.json"));
+            if (cred)
+                break;
+        }
+        const accountId = str(jwtClaims(cred?.access_token)?.sub);
+        return accountId ? { accountId } : undefined;
+    }
     return undefined;
 }
 /** "me@x.com (Claude Max 20x)" or nothing worth saying. */

package/dist/manage.js

@@ -8,6 +8,7 @@ import { spawn } from "node:child_process";
 import { readProject } from "./project.js";
 import { saveConfig } from "./config.js";
 import { ConsoleApiError } from "./console-api.js";
+import { requestJson, watch } from "./network.js";
 import { bold, dim, green, money, red, rows, table, yellow } from "./ui.js";
 export class ManageError extends Error {
 }
@@ -17,13 +18,13 @@ export function api(config, fetchImpl = fetch) {
     const token = config.token;
     if (!base || !token)
         throw new ManageError("This machine is not logged in. Run tab login.");
-    return async (method, path, body) => {
-        const res = await fetchImpl(`${base}${path}`, {
+    return async (method, path, body, signal) => {
+        const { response: res, body: json } = await requestJson(`${base}${path}`, {
             method,
+            ...(signal ? { signal } : {}),
             headers: { authorization: `Bearer ${token}`, "content-type": "application/json" },
             ...(body !== undefined ? { body: JSON.stringify(body) } : {}),
-        });
-        const json = (await res.json().catch(() => ({})));
+        }, fetchImpl);
         if (!res.ok) {
             const detail = json.error ?? `console answered ${res.status}`;
             throw new ConsoleApiError(res.status === 401 ? "Session expired. Run tab login." : json.hint ? `${detail} (${json.hint})` : detail, res.status);
@@ -65,13 +66,13 @@ async function tabsOf(call) {
 }
 /** Slug or name (case-insensitive); omitted means this folder's Agent. */
 export async function resolveSlug(call, given, cwd = process.cwd()) {
-    const tabs = await tabsOf(call);
     if (!given) {
         const project = await readProject(cwd);
         if (!project)
             throw new ManageError("No Agent named and this folder has none yet (tab use), so say which: tab <command> <agent>.");
         return project.agent;
     }
+    const tabs = await tabsOf(call);
     const want = given.trim().toLowerCase();
     const hit = tabs.find((t) => t.slug.toLowerCase() === want) ?? tabs.find((t) => t.name.toLowerCase() === want);
     if (!hit)
@@ -197,7 +198,7 @@ export async function accounts(config, flags) {
         };
         return table(["vendor", "account", "plan", "/month", "30d at list", "calls", "used", "agents"], list.map((a) => [
             a.vendor,
-            a.label ?? a.email ?? dim(a.id),
+            a.label ?? a.email ?? dim(`account ${(a.externalId ?? a.id).slice(0, 12)}`),
             a.planLabel ?? dim("unknown"),
             a.monthlyCents ? money(a.monthlyCents) : dim("-"),
             money(a.listCents),
@@ -310,48 +311,79 @@ export function logLine(r) {
  * machine, one condensed line per call, hosted or self-hosted alike because
  * it is the ledger's own record. `-f` follows it; `--all` is the whole flock.
  */
-export async function log(config, flags, follow) {
+export async function log(config, flags, follow, signal) {
     const call = api(config);
-    const limit = Math.min(500, Math.max(1, Number(flags.opts.lines ?? 30) || 30));
-    const mine = new Set(Object.values(config.agents ?? {}).map((a) => a.agentName.toLowerCase()));
-    const wanted = (r) => flags.opts.all !== undefined || mine.size === 0 || mine.has(r.agent.toLowerCase());
-    const fetchRows = async () => (await call("GET", `/api/cli/ledger?limit=${flags.opts.all !== undefined ? limit : limit * 4}`)).rows.filter(wanted).slice(0, limit);
-    const first = await fetchRows();
+    const limit = Math.min(500, Math.max(1, Math.floor(Number(flags.opts.lines ?? 30) || 30)));
+    const mine = [...new Set(Object.values(config.agents ?? {}).map((a) => a.agentId).filter(Boolean))].sort();
+    const all = flags.opts.all !== undefined;
+    if (!all && mine.length > 200)
+        throw new ManageError("This machine has more than 200 Agents. Use tab ledger <agent>, or --all explicitly for the flock.");
+    if (!all && mine.length === 0) {
+        out(flags.json ? JSON.stringify({ rows: [] }) : dim("No Agent IDs saved on this machine. Run tab use, or add --all for the flock."));
+        return 0;
+    }
+    const params = new URLSearchParams({ limit: String(limit) });
+    if (!all)
+        for (const id of mine)
+            params.append("agentId", id);
+    if (follow)
+        params.set("incremental", "1");
+    let cursor;
+    const fetchPage = async (requestSignal) => {
+        const query = new URLSearchParams(params);
+        if (cursor)
+            query.set("cursor", cursor);
+        const page = await call("GET", `/api/cli/ledger?${query}`, undefined, requestSignal);
+        if (follow && !page.cursor)
+            throw new ManageError("The console does not support incremental logs yet. Use tab ledger until it is updated.");
+        if (page.hasMore && page.cursor === cursor)
+            throw new ManageError("The ledger cursor did not advance.");
+        cursor = page.cursor;
+        return page;
+    };
+    const first = (await fetchPage(signal)).rows;
     if (flags.json && !follow) {
         out(JSON.stringify({ rows: first }, null, 2));
         return 0;
     }
     if (first.length === 0 && !follow)
         out(dim("Nothing yet. Run tab claude or tab codex in a project folder."));
-    const seen = new Set();
-    for (const r of [...first].reverse()) {
-        seen.add(r.id);
-        out(flags.json ? JSON.stringify(r) : logLine(r));
-    }
+    const seen = new Map();
+    const print = (r) => {
+        const fingerprint = JSON.stringify(r);
+        if (seen.get(r.id) === fingerprint)
+            return;
+        seen.delete(r.id);
+        seen.set(r.id, fingerprint);
+        if (seen.size > 2_000)
+            seen.delete(seen.keys().next().value);
+        out(flags.json ? fingerprint : logLine(r));
+    };
+    for (const r of [...first].reverse())
+        print(r);
     if (!follow)
         return 0;
-    for (;;) {
-        await new Promise((resolve) => setTimeout(resolve, 2000));
-        let rows;
+    await watch(async (requestSignal) => {
+        const bootstrap = !cursor;
         try {
-            rows = await fetchRows();
-        }
-        catch {
-            continue;
+            const page = await fetchPage(requestSignal);
+            for (const row of bootstrap ? [...page.rows].reverse() : page.rows)
+                print(row);
+            return page.hasMore === true;
         }
-        for (const r of [...rows].reverse()) {
-            if (seen.has(r.id))
-                continue;
-            seen.add(r.id);
-            out(flags.json ? JSON.stringify(r) : logLine(r));
+        catch (error) {
+            if (error instanceof ConsoleApiError && error.status === 400)
+                cursor = undefined;
+            throw error;
         }
-    }
+    }, 2_000, { ...(signal ? { signal } : {}), onError: (error) => console.error(dim(error instanceof Error ? error.message : String(error))) });
+    return 0;
 }
 export async function ledger(config, flags) {
     const call = api(config);
     const params = new URLSearchParams();
     if (flags.args[0])
-        params.set("agent", await resolveSlug(call, flags.args[0]));
+        params.set("agent", flags.args[0].trim());
     if (flags.opts.limit)
         params.set("limit", flags.opts.limit);
     if (flags.opts.blocked !== undefined)
@@ -408,34 +440,25 @@ export async function outside(config, flags) {
     });
     return 0;
 }
-export async function live(config, flags) {
+export async function live(config, flags, signal) {
     const call = api(config);
-    const once = async () => {
-        const feed = await call("GET", "/api/cli/live");
+    const once = async (requestSignal) => {
+        const feed = await call("GET", flags.json ? "/api/cli/live" : "/api/cli/live?view=summary", undefined, requestSignal);
         emit(flags.json, feed, () => `${dim("active")} ${feed.totals.active}  ${dim("calls/min")} ${feed.totals.callsPerMinute}  ${dim("blocked 5m")} ${feed.totals.blocked}  ${dim("spend 5m")} ${money(feed.totals.windowCents)}\n` +
             table(["agent", "pulse", "calls/min", "blocked", "5m", "last"], feed.agents.map((a) => [a.slug, a.pulse, String(a.callsPerMinute), String(a.blocked), money(a.windowCents), a.lastDecision ? `${a.lastDecision.toLowerCase()} ${dim(a.lastReason ?? "")}` : dim("-")]), { right: [2, 3, 4] }));
     };
-    await once();
+    await once(signal);
     if (flags.opts.watch === undefined)
         return 0;
-    const every = Math.max(2, Number(flags.opts.watch) || 4) * 1000;
-    await new Promise((resolve) => {
-        const timer = setInterval(() => {
-            out("");
-            once().catch((err) => out(red(String(err instanceof Error ? err.message : err))));
-        }, every);
-        process.on("SIGINT", () => {
-            clearInterval(timer);
-            resolve();
-        });
-    });
+    const every = Math.min(60, Math.max(2, Number(flags.opts.watch) || 4)) * 1000;
+    await watch(once, every, { ...(signal ? { signal } : {}), onError: (error) => console.error(red(error instanceof Error ? error.message : String(error))) });
     return 0;
 }
 /** `tab web [agent]`: this folder's Agent in the console. */
 export async function web(config, flags) {
     const call = api(config);
-    const slug = flags.args[0] || (await readProject(process.cwd()))?.agent;
-    const url = slug ? `${config.consoleUrl}/console/tabs/${encodeURIComponent(await resolveSlug(call, slug))}` : `${config.consoleUrl}/console`;
+    const slug = flags.args[0] ? await resolveSlug(call, flags.args[0]) : (await readProject(process.cwd()))?.agent;
+    const url = slug ? `${config.consoleUrl}/console/tabs/${encodeURIComponent(slug)}` : `${config.consoleUrl}/console`;
     const cmd = process.platform === "darwin" ? "open" : process.platform === "win32" ? "cmd" : "xdg-open";
     const args = process.platform === "win32" ? ["/c", "start", "", url] : [url];
     try {

package/dist/network.js

@@ -0,0 +1,78 @@
+function pause(ms, signal) {
+    signal.throwIfAborted();
+    return new Promise((resolve, reject) => {
+        const aborted = () => {
+            clearTimeout(timer);
+            reject(signal.reason);
+        };
+        const timer = setTimeout(() => {
+            signal.removeEventListener("abort", aborted);
+            resolve();
+        }, ms);
+        signal.addEventListener("abort", aborted, { once: true });
+    });
+}
+/** Use Node's shared fetch pool; bound both headers and body, including cancellation. */
+export async function requestJson(url, init = {}, fetchImpl = fetch, timeoutMs = 15_000) {
+    const controller = new AbortController();
+    const signal = init.signal
+        ? AbortSignal.any([init.signal, controller.signal])
+        : controller.signal;
+    signal.throwIfAborted();
+    const timer = setTimeout(() => controller.abort(new DOMException("Console request timed out", "TimeoutError")), timeoutMs);
+    let onAbort;
+    const cancelled = new Promise((_resolve, reject) => {
+        onAbort = () => reject(signal.reason);
+        signal.addEventListener("abort", onAbort, { once: true });
+    });
+    try {
+        return await Promise.race([
+            (async () => {
+                const response = await fetchImpl(url, { ...init, signal });
+                const body = (await response.json().catch(() => ({})));
+                return { response, body };
+            })(),
+            cancelled,
+        ]);
+    }
+    finally {
+        clearTimeout(timer);
+        signal.removeEventListener("abort", onAbort);
+    }
+}
+/** Completion-based watch loop. A true result drains the next cursor page immediately. */
+export async function watch(task, intervalMs, options = {}) {
+    const controller = new AbortController();
+    const signal = options.signal ?? controller.signal;
+    const stop = () => controller.abort();
+    if (!options.signal) {
+        process.once("SIGINT", stop);
+        process.once("SIGTERM", stop);
+    }
+    let delay = intervalMs;
+    try {
+        while (!signal.aborted) {
+            await pause(delay, signal);
+            try {
+                const more = await task(signal);
+                delay = more ? 0 : intervalMs;
+            }
+            catch (error) {
+                if (signal.aborted)
+                    break;
+                options.onError?.(error);
+                delay = Math.min(Math.max(delay, intervalMs) * 2, 60_000);
+            }
+        }
+    }
+    catch (error) {
+        if (!signal.aborted)
+            throw error;
+    }
+    finally {
+        if (!options.signal) {
+            process.removeListener("SIGINT", stop);
+            process.removeListener("SIGTERM", stop);
+        }
+    }
+}

package/dist/pool-run.js

@@ -4,29 +4,35 @@
  * another has room, wait for a quiet moment and relaunch into the same
  * conversation as that other login.
  */
-import { pickMember, relaunchArgs, shouldSwap } from "./pool.js";
-const label = (s) => `${s.member.name}${s.email ? ` (${s.email})` : ""}${s.used === undefined ? "" : `, ${Math.round(s.used)}% used`}`;
+import { isOver, pickMember, relaunchArgs, shouldSwap } from "./pool.js";
+const label = (s) => `${s.member.name}${s.email && s.email !== s.member.name ? ` (${s.email})` : ""}${s.used === undefined ? "" : `, ${Math.round(s.used)}% used`}`;
+/** Which limit a login is over, in words. */
+function why(s, limits) {
+    return (s.used ?? 0) >= limits.at ? `is over ${limits.at}%` : `has ${Math.round(s.longUsed ?? 0)}% of its long window used`;
+}
 export async function runPooled(args, deps) {
     const all = await deps.standings();
-    let current = deps.pinned ? all.find((s) => s.member.name === deps.pinned) : pickMember(all, deps.at);
+    let current = deps.pinned ? all.find((s) => s.member.name === deps.pinned) : pickMember(all, deps.limits);
     if (!current) {
         deps.say(deps.pinned ? `No pool member named ${deps.pinned}. See tab pool.` : "The pool is empty. Add a login with tab pool add.");
         return 2;
     }
-    if (!deps.pinned && (current.used ?? 0) >= deps.at)
-        deps.say(`Every login in the pool is over ${deps.at}%. Running as the least used.`);
+    if (!deps.pinned && isOver(current, deps.limits))
+        deps.say(`Every login in the pool is over its limit. Running as the least used.`);
     let launchArgs = args;
     for (;;) {
         deps.say(`Pool: running as ${label(current)}.`);
         const child = deps.start(current, launchArgs);
         let next;
+        let seen = current;
         if (!deps.pinned && deps.swap === "auto") {
             while (await deps.wait(deps.intervalMs ?? 60_000, child.done)) {
                 // A failed look at the console is not a reason to touch a running harness.
                 const now = await deps.standings().catch(() => undefined);
-                const to = now ? shouldSwap(now, deps.at, current.member.name) : undefined;
+                const to = now ? shouldSwap(now, deps.limits, current.member.name) : undefined;
                 if (to && (await deps.idle().catch(() => false))) {
                     next = to;
+                    seen = now?.find((s) => s.member.name === current.member.name) ?? current;
                     child.stop();
                     break;
                 }
@@ -35,7 +41,7 @@ export async function runPooled(args, deps) {
         const code = await child.done;
         if (!next)
             return code;
-        deps.say(`Pool: ${current.member.name} is over ${deps.at}%. Continuing as ${label(next)}; the conversation carries over, the vendor's prompt cache does not.`);
+        deps.say(`Pool: ${current.member.name} ${why(seen, deps.limits)}. Continuing as ${label(next)}; the conversation carries over, the vendor's prompt cache does not.`);
         current = next;
         launchArgs = relaunchArgs(deps.harness, args);
     }

package/dist/pool-view.js

@@ -0,0 +1,87 @@
+/**
+ * `tab pool`, drawn: one table per vendor. Who each login is, its plan, how
+ * 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 { bold, dim, green, red, table, width, yellow } from "./ui.js";
+const BAR = 10;
+/** "2h 10m", "3d 4h", "12m": how long until a window resets. */
+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 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`;
+}
+function paint(pct, at) {
+    return pct >= at ? red : pct >= at * 0.75 ? yellow : green;
+}
+export function usageBar(pct, at) {
+    if (pct === undefined)
+        return dim("·".repeat(BAR));
+    const filled = Math.min(BAR, Math.max(0, Math.round((pct / 100) * BAR)));
+    return `${paint(pct, at)("█".repeat(filled))}${dim("░".repeat(BAR - filled))}`;
+}
+/** "claude max 20x" and "pro" as the harness files spell them, in the vendor's capitals. */
+export function planName(plan) {
+    if (!plan)
+        return undefined;
+    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 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");
+    if (live.length === 0)
+        return dim("every window has reset");
+    return live
+        .map((w) => {
+        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}`) : ""}`;
+    })
+        .join(dim("  ·  "));
+}
+export function renderPool(sections, opts) {
+    const now = opts.now ?? new Date();
+    const out = [];
+    // One width for the login and plan columns, so the vendors line up under each other.
+    const whoOf = (s) => (s.email && s.email !== s.member.name ? `${s.member.name} ${dim(`(${s.email})`)}` : s.member.name);
+    const all = sections.flatMap((x) => x.standings);
+    const loginWidth = Math.max(5, ...all.map((s) => width(s.email ? whoOf(s) : `${whoOf(s)} not signed in`)));
+    const planWidth = Math.max(4, ...all.map((s) => width(planName(s.plan) ?? "-")));
+    for (const section of sections) {
+        const limits = section.limits ?? { at: opts.at, guard: opts.guard ?? 95 };
+        const at = limits.at;
+        const next = pickMember(section.standings, limits)?.member.name;
+        const over = section.standings.filter((s) => isOver(s, limits)).length;
+        const count = `${section.standings.length} ${section.standings.length === 1 ? "login" : "logins"}`;
+        out.push(`${bold(section.title)}  ${dim(`${count} · moves at ${at}% · weekly guard ${limits.guard}%${over > 0 ? ` · ${over} over` : ""} · tab ${section.harness}`)}`);
+        out.push(table(["", "login".padEnd(loginWidth), "plan".padEnd(planWidth), "used", "", "windows", ...(opts.paths ? ["folder"] : [])], section.standings.map((s) => {
+            const who = whoOf(s);
+            return [
+                s.member.name === next ? green("→") : " ",
+                s.email ? who : `${who} ${yellow("not signed in")}`,
+                planName(s.plan) ?? dim("-"),
+                usageBar(s.used, at),
+                s.used === undefined ? dim("   -") : paint(s.used, at)(`${String(Math.round(s.used)).padStart(3)}%`),
+                windowsLine(s.windows, limits, now),
+                ...(opts.paths ? [dim(s.member.dir)] : []),
+            ];
+        }), { indent: 1 }));
+        out.push("");
+    }
+    out.push(dim(`${green("→")} runs next. The short window decides; the weekly one only from its guard up. A login over either gives way to the one with most room${opts.swap === "auto" ? ", also while running when idle" : ", at launch only"}.`));
+    out.push(dim("--as <login> pins one · --no-pool uses your usual login · tab pool at [vendor] [7d] <percent> · --paths shows folders"));
+    return out.join("\n");
+}