@hanamorilabs/tab 0.1.8 → 0.1.10

package/README.md

@@ -51,7 +51,9 @@ tab claude           # your own Claude login through the tab
 tab codex            # your own ChatGPT login (codex login once, inside tab codex)
 tab grok             # your SuperGrok login
 tab kimi             # your Kimi Code login
-tab accounts         # accounts seen: plan, seat price, 30 days at list, what is left
+tab accounts         # accounts seen: plan, seat price, 30 days at list, how much is used
+tab pool add claude work   # another Claude login in its own folder; tab claude then runs as the one with most room
+tab pool             # the logins, and how used each is; tab pool at 80 sets when to move
 tab agent kind me@joseairosa.com api   # back to the meter
 ```
 
@@ -90,10 +92,13 @@ tab <agent> [args]   claude, codex, grok, kimi, gemini, or any command, on the t
 tab use              pick or change the Agent this folder runs as (.flocktab)
 tab agent create <name> --subscription|--api   a new Agent of that kind (--cap 50)
 tab agent kind <agent> api|subscription        change it
-tab accounts         accounts your subscription Agents were seen on: plan, price, quota left
+tab accounts         accounts your subscription Agents were seen on: plan, price, quota used
+tab pool             several logins of one vendor: add claude|codex <name>, at <percent>, swap auto|launch
 tab alias setup <name>...   make plain `codex` run `tab codex` (shims in ~/.flocktab/bin)
 tab alias remove <name>...  undo that; `tab alias list` shows them
 tab status           flock, folder Agent, proxy health, provider key state
+tab log [-f] [--all] everything through the tab for this machine's Agents, one line per call
+tab log --proxy [-f] self-hosted: the local proxy's own log (cached tokens, milliseconds)
 tab version          tab and proxy versions
 tab up | down        self-hosted: start or stop the local proxy
 tab update           the newest tab and proxy from npm; restarts a running local proxy

package/dist/cli.js

@@ -23,13 +23,17 @@
  * terminal, so an interactive agent behaves exactly as it does without `tab`.
  */
 import { spawn } from "node:child_process";
+import { mkdir } from "node:fs/promises";
 import { hostname } from "node:os";
+import path from "node:path";
 import { createInterface } from "node:readline/promises";
 import { stdin, stdout } from "node:process";
 import { bold, box, cyan, dim, green, heading, line, rows, underline, yellow } from "./ui.js";
 import { envFor, knownClients, subscriptionVendorFor } from "./clients.js";
 import { describeLogin, localLogin } from "./logins.js";
 import { prepareCodexHome } from "./codex-home.js";
+import { addMember, loadPool, memberEnv, poolVendorFor, prepareClaudeMember, removeMember, savePool, usedPct } from "./pool.js";
+import { runPooled } from "./pool-run.js";
 import { ConsoleApiError, createAgent, issueAgentKey, listAgents } from "./console-api.js";
 import { consoleUrlFor, DeviceLoginError, startDeviceLogin, waitForApproval } from "./device-login.js";
 import { clearConfig, configDir, configPath, HOSTED_PROXY, isLocalProxy, loadConfig, LOCAL_PROXY, normalizeProxyUrl, presentedKey, saveConfig, } from "./config.js";
@@ -37,7 +41,7 @@ import { reportFolder } from "./folder.js";
 import { listAliases, pathLine, pathWithoutShims, removeAlias, shimDir, shimDirOnPath, validAliasName, writeAlias } from "./alias.js";
 import * as manage from "./manage.js";
 import { agentNameFor, projectRoot, readProject, writeProject } from "./project.js";
-import { downloadProxy, hasProxyEnv, packagedBinPath, proxyBinPath, proxyEnvPath, proxyInstalled, proxyLogPath, PROXY_VERSION, startProxy, stopProxy, tailProxyLog, writeProxyEnv, } from "./proxy-bin.js";
+import { downloadProxy, hasProxyEnv, packagedBinPath, proxyBinPath, proxyEnvPath, proxyInstalled, proxyLogPath, hasProxyLog, PROXY_VERSION, startProxy, stopProxy, tailProxyLog, writeProxyEnv, } from "./proxy-bin.js";
 import { proxyHealth, waitHealthy } from "./selfhost.js";
 import { TAB_VERSION } from "./version.js";
 const say = (text) => console.error(text);
@@ -58,10 +62,15 @@ function usage() {
         cmd("use", "pick or change the Agent this folder runs as (.flocktab)"),
         cmd("agent create <name>", "a new Agent: --subscription (your own logins) or --api (the flock's key, metered)"),
         cmd("agent kind <agent> api|subscription", "change it"),
-        cmd("accounts", "accounts your subscription Agents were seen on: plan, price, quota left"),
+        cmd("accounts", "accounts your subscription Agents were seen on: plan, price, quota used"),
+        cmd("pool", "several logins of one vendor; tab claude runs as the one with most room"),
+        cmd("pool add claude|codex <name>", "sign another login in (its own folder; --dir <path> to use one you have)"),
+        cmd("pool at <percent>", "move to another login once this much of a window is used (default 80)"),
         cmd("alias setup <name>...", "make plain `codex` run `tab codex` (shims in ~/.flocktab/bin)"),
         cmd("alias remove <name>...", "undo that; `tab alias list` shows them"),
         cmd("status", "which flock, which Agent here, is the proxy up"),
+        cmd("log [-f] [--all]", "everything through the tab on this machine's Agents, one line per call; -f follows"),
+        cmd("log --proxy [-f]", "self-hosted: the local proxy's own log (cached tokens, milliseconds; no keys, logins or prompts)"),
         cmd("version", "tab and proxy versions"),
         cmd("list", "every Agent: state, spent of cap, window, project"),
         cmd("close | open [agent]", "the kill switch; omit the Agent for this folder's"),
@@ -509,7 +518,51 @@ async function status() {
     say(box(rows(pairs, 0).split("\n"), { title: "FlockTab", tone }));
     return tone === "ok" ? 0 : 1;
 }
-async function runAgent(name, args) {
+/** `--pool`, `--no-pool` and `--as <member>` are tab's; everything else is the harness's. */
+function takePoolFlags(argv) {
+    const args = [];
+    let noPool = false;
+    let asked = false;
+    let pinned;
+    for (let i = 0; i < argv.length; i += 1) {
+        const a = argv[i];
+        if (a === "--no-pool")
+            noPool = true;
+        else if (a === "--pool")
+            asked = true;
+        else if (a === "--as" && argv[i + 1])
+            pinned = argv[(i += 1)];
+        else if (a.startsWith("--as="))
+            pinned = a.slice(5);
+        else
+            args.push(a);
+    }
+    return { args, noPool, asked: asked || pinned !== undefined, ...(pinned ? { pinned } : {}) };
+}
+async function flockAccounts(config) {
+    return (await manage.api(config)("GET", "/api/cli/accounts")).accounts;
+}
+/** Each member with the login its folder holds and how used the vendor last said that account is. */
+async function poolStandings(config, vendor, members) {
+    const accounts = await flockAccounts(config).catch(() => []);
+    return Promise.all(members.map(async (member) => {
+        const login = await localLogin(vendor, vendor === "anthropic" ? { claudeConfigDir: member.dir } : { codexHome: path.join(member.dir, "codex") });
+        const email = login?.email;
+        const account = email ? accounts.find((a) => a.provider === vendor && a.email?.toLowerCase() === email.toLowerCase()) : undefined;
+        return { member, used: account ? usedPct(account.quota) : undefined, ...(email ? { email } : {}) };
+    }));
+}
+/** Quiet: no call of this Agent in flight, and no reply from the vendor in the last 20 seconds. */
+async function poolIdle(config, vendor, agentName) {
+    const call = manage.api(config);
+    const { rows } = await call("GET", "/api/cli/ledger?limit=20");
+    if (rows.some((r) => r.agent === agentName && r.status === "pending"))
+        return false;
+    const recent = Date.now() - 20_000;
+    return !(await flockAccounts(config)).some((a) => a.provider === vendor && new Date(a.lastSeenAt).getTime() > recent);
+}
+async function runAgent(name, argv) {
+    const { args, noPool, asked, pinned } = takePoolFlags(argv);
     const config = await ensureLogin();
     if (!config)
         return 2;
@@ -525,13 +578,43 @@ async function runAgent(name, args) {
     // 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 });
-    const kind = !("error" in me) && me.kind === "subscription" ? "subscription" : "api";
+    let kind = !("error" in me) && me.kind === "subscription" ? "subscription" : "api";
+    // A proxy older than 0.1.7 answers whoami without the kind. Guessing api
+    // would hand a subscription Agent's harness the tab key, so ask the console.
+    const { consoleUrl, token } = config;
+    if (!("error" in me) && me.kind === undefined && config.mode === "self-hosted") {
+        // Not restarted here: other harnesses may be streaming through it.
+        warn(`The local proxy is older than this tab. When nothing is running through it: ${bold("tab down && tab up")}`);
+    }
+    if (consoleUrl && token && ("error" in me || me.kind === undefined)) {
+        try {
+            const listed = await listAgents(consoleUrl, token);
+            if (listed.agents.find((a) => a.id === agent.agentId)?.kind === "subscription")
+                kind = "subscription";
+        }
+        catch {
+            // Console unreachable: stay on what the proxy said.
+        }
+    }
     const auth = kind === "subscription" && vendor ? "subscription" : "key";
     // On a subscription there is no provider key to unlock; the bare key rides in the URL.
     const key = auth === "subscription" ? agent.key : presentedKey({ key: agent.key, unlock: config.unlock });
     reportFolder(config.proxyUrl, key);
     const { spec, env } = envFor({ name, proxyUrl: config.proxyUrl, presentedKey: key, auth });
-    if (auth === "subscription") {
+    const poolVendor = auth === "subscription" ? poolVendorFor(name) : undefined;
+    const pool = poolVendor ? await loadPool() : undefined;
+    const members = (poolVendor && pool?.members[poolVendor]) || [];
+    const pooled = members.length > 0 && !noPool;
+    if (asked && !pooled) {
+        fail(auth !== "subscription"
+            ? `A pool is for subscription Agents; this folder runs as an API-key Agent. ${dim("tab agent kind <agent> subscription")}`
+            : `No ${name} logins in the pool yet. ${dim(`tab pool add ${name} <name>`)}`);
+        return 2;
+    }
+    if (pooled) {
+        // The member's folder is where the harness keeps that login; tab sets the folder, never the login.
+    }
+    else if (auth === "subscription") {
         const login = describeLogin(await localLogin(vendor));
         const vendorName = vendor === "openai" ? "ChatGPT" : vendor === "xai" ? "SuperGrok" : vendor === "kimi" ? "Kimi" : "Claude";
         say(dim(`${spec.label} on your own ${vendorName} login${login ? `: ${login}` : ""}. FlockTab keeps the record and the kill switch; the account is read off each reply.`));
@@ -550,22 +633,154 @@ async function runAgent(name, args) {
             auth,
         });
     }
-    const child = spawn(spec.command, [...(spec.args ?? []), ...args], { stdio: "inherit", env });
-    return new Promise((resolve) => {
-        child.on("error", (err) => {
-            if (err.code === "ENOENT") {
-                fail(`${spec.label} is not installed (${spec.command} not on PATH). ${dim(spec.install)}`);
-                if (!knownClients().includes(name))
-                    say(dim(`Not a tab command either; see ${bold("tab help")}.`));
-                resolve(127);
-                return;
-            }
-            fail(err.message);
-            resolve(1);
+    const launch = (launchArgs, launchEnv) => {
+        const child = spawn(spec.command, [...(spec.args ?? []), ...launchArgs], { stdio: "inherit", env: launchEnv });
+        const done = new Promise((resolve) => {
+            child.on("error", (err) => {
+                if (err.code === "ENOENT") {
+                    fail(`${spec.label} is not installed (${spec.command} not on PATH). ${dim(spec.install)}`);
+                    if (!knownClients().includes(name))
+                        say(dim(`Not a tab command either; see ${bold("tab help")}.`));
+                    resolve(127);
+                    return;
+                }
+                fail(err.message);
+                resolve(1);
+            });
+            child.on("close", (code, signal) => resolve(code ?? (signal ? 128 : 1)));
         });
-        child.on("close", (code, signal) => resolve(code ?? (signal ? 128 : 1)));
+        return { done, stop: () => void child.kill("SIGTERM") };
+    };
+    if (!pooled || !poolVendor || !pool)
+        return launch(args, env).done;
+    // Codex members each need their own home written before the first launch.
+    if (poolVendor === "openai") {
+        for (const member of members) {
+            await prepareCodexHome({ baseDir: member.dir, proxyUrl: config.proxyUrl, presentedKey: key, mode: config.mode, auth, userCodexHome: path.join(member.dir, "no-personal-login") });
+        }
+    }
+    return runPooled(args, {
+        harness: name,
+        at: pool.at,
+        swap: pool.swap,
+        ...(pinned ? { pinned } : {}),
+        standings: () => poolStandings(config, poolVendor, members),
+        idle: () => poolIdle(config, poolVendor, agent.agentName),
+        start: (standing, launchArgs) => launch(launchArgs, { ...env, ...memberEnv(poolVendor, standing.member) }),
+        wait: (ms, until) => new Promise((resolve) => {
+            const timer = setTimeout(() => resolve(true), ms);
+            void until.then(() => {
+                clearTimeout(timer);
+                resolve(false);
+            });
+        }),
+        say: (text) => say(dim(text)),
     });
 }
+/**
+ * `tab pool`: several logins of one vendor on this machine. Each member is
+ * a folder the harness signs in to itself; tab only chooses which folder a
+ * launch uses, from the usage the vendors report.
+ */
+async function poolCommand(argv) {
+    const [sub, ...rest] = argv;
+    const pool = await loadPool();
+    const vendorOf = (word) => poolVendorFor(word === "chatgpt" ? "codex" : (word ?? ""));
+    if (sub === "at") {
+        const pct = Number(rest[0]);
+        if (!Number.isFinite(pct) || pct < 1 || pct > 100) {
+            fail("tab pool at <percent>, from 1 to 100.");
+            return 2;
+        }
+        await savePool({ ...pool, at: Math.round(pct) });
+        ok(`The pool moves to another login at ${Math.round(pct)}% used.`);
+        return 0;
+    }
+    if (sub === "swap") {
+        if (rest[0] !== "auto" && rest[0] !== "launch") {
+            fail(`tab pool swap auto|launch. ${dim("auto: relaunch into the same conversation when idle. launch: only choose when a harness starts.")}`);
+            return 2;
+        }
+        await savePool({ ...pool, swap: rest[0] });
+        ok(rest[0] === "auto" ? "The pool moves a running harness when it is idle." : "The pool only chooses at launch.");
+        return 0;
+    }
+    if (sub === "add" || sub === "remove" || sub === "rm") {
+        const vendor = vendorOf(rest[0]);
+        const flags = manage.parseFlags(rest.slice(1));
+        const memberName = flags.args[0];
+        if (!vendor || !memberName) {
+            fail(`tab pool ${sub} claude|codex <name>${sub === "add" ? " [--dir <folder>]" : ""}`);
+            return 2;
+        }
+        if (sub !== "add") {
+            await savePool(removeMember(pool, vendor, memberName));
+            ok(`Removed ${bold(memberName)} from the pool. Its folder and login are left where they are.`);
+            return 0;
+        }
+        let next;
+        try {
+            next = addMember(pool, vendor, memberName, flags.opts.dir);
+        }
+        catch (err) {
+            fail(err.message);
+            return 2;
+        }
+        const member = next.members[vendor].at(-1);
+        const loginOf = () => localLogin(vendor, vendor === "anthropic" ? { claudeConfigDir: member.dir } : { codexHome: path.join(member.dir, "codex") });
+        if (!flags.opts.dir && vendor === "anthropic")
+            await prepareClaudeMember(member.dir);
+        if (vendor === "openai")
+            await mkdir(path.join(member.dir, "codex"), { recursive: true, mode: 0o700 });
+        if (!(await loginOf())?.email) {
+            const harness = vendor === "anthropic" ? "claude" : "codex";
+            say(dim(vendor === "anthropic" ? `Opening Claude Code in ${member.dir}. Sign in as the account for ${memberName} (/login), then /exit.` : `Signing Codex in for ${memberName}.`));
+            // Plain launch: no proxy, no tab key. This only creates the login, in the harness's own store.
+            const loginEnv = { ...process.env, ...memberEnv(vendor, member), PATH: pathWithoutShims() };
+            for (const k of ["ANTHROPIC_BASE_URL", "ANTHROPIC_API_KEY", "ANTHROPIC_AUTH_TOKEN", "OPENAI_BASE_URL", "OPENAI_API_KEY"])
+                delete loginEnv[k];
+            const code = await new Promise((resolve) => {
+                const child = spawn(harness, vendor === "anthropic" ? [] : ["login"], { stdio: "inherit", env: loginEnv });
+                child.on("error", () => resolve(127));
+                child.on("close", (c) => resolve(c ?? 1));
+            });
+            if (code === 127) {
+                fail(`${harness} is not installed.`);
+                return 127;
+            }
+        }
+        const login = await loginOf();
+        if (!login?.email) {
+            fail(`No login found in ${member.dir}. Nothing was added; run the same command again to retry.`);
+            return 1;
+        }
+        await savePool(next);
+        ok(`${bold(memberName)} is in the pool as ${describeLogin(login)}.`);
+        return 0;
+    }
+    if (sub && sub !== "list" && sub !== "ls") {
+        fail(`Unknown: tab pool ${sub}. ${dim("tab pool | add | remove | at | swap")}`);
+        return 2;
+    }
+    const config = await ensureLogin();
+    if (!config)
+        return 2;
+    const vendors = ["anthropic", "openai"].filter((v) => (pool.members[v] ?? []).length > 0);
+    if (vendors.length === 0) {
+        say(dim(`No logins in the pool. ${bold("tab pool add claude work")} signs one in; then ${bold("tab claude")} runs as whichever has most room.`));
+        return 0;
+    }
+    for (const vendor of vendors) {
+        const standings = await poolStandings(config, vendor, pool.members[vendor]);
+        say(heading(vendor === "anthropic" ? "Claude" : "ChatGPT (Codex)"));
+        say(rows(standings.map((s) => [
+            s.member.name,
+            `${s.email ?? yellow("not signed in")}  ${s.used === undefined ? dim("not seen yet") : s.used >= pool.at ? yellow(`${Math.round(s.used)}% used`) : green(`${Math.round(s.used)}% used`)}  ${dim(s.member.dir)}`,
+        ]), 0));
+    }
+    say(dim(`Moves at ${pool.at}% used (${pool.swap === "auto" ? "also while running, when idle" : "at launch only"}). tab claude --as <name> pins one; --no-pool uses your usual login.`));
+    return 0;
+}
 /**
  * `tab alias codex claude`: shims so the plain commands run on the tab.
  * `tab alias` alone lists them; `tab unalias codex` removes one.
@@ -695,6 +910,29 @@ ${installed}` : "Updated.");
     await stopProxy();
     return (await bringUp(config.proxyUrl)) ? 0 : 1;
 }
+/**
+ * `tab logs`: the local proxy's log. One line per call: kind, vendor, Agent,
+ * model, outcome, status, tokens (cached apart) and duration. The proxy never
+ * writes a key, a login, a prompt or an email there. `-f` follows it.
+ */
+async function logs(args) {
+    const flags = manage.parseFlags(args);
+    const follow = args.includes("-f") || flags.opts.follow !== undefined;
+    const lines = Math.min(5000, Math.max(1, Number(flags.opts.lines ?? 50) || 50));
+    const file = proxyLogPath();
+    if (!(await hasProxyLog())) {
+        warn(`No local proxy log yet (${file}). It is written by the self-hosted proxy: ${bold("tab up")}.`);
+        return 1;
+    }
+    const [cmd, cmdArgs] = process.platform === "win32"
+        ? ["powershell", ["-NoProfile", "-Command", `Get-Content -Path '${file}' -Tail ${lines}${follow ? " -Wait" : ""}`]]
+        : ["tail", [`-n`, String(lines), ...(follow ? ["-f"] : []), file]];
+    const child = spawn(cmd, cmdArgs, { stdio: "inherit" });
+    return new Promise((resolve) => {
+        child.on("error", () => resolve(1));
+        child.on("close", (code) => resolve(code ?? 0));
+    });
+}
 async function selfHosted(action) {
     const config = await loadConfig();
     const proxyUrl = config?.mode === "self-hosted" ? config.proxyUrl : LOCAL_PROXY;
@@ -751,6 +989,8 @@ async function managed(command, rest) {
                 return await manage.outside(config, flags);
             case "live":
                 return await manage.live(config, flags);
+            case "log":
+                return await manage.log(config, manage.parseFlags(rest.filter((a) => a !== "-f")), rest.includes("-f") || flags.opts.follow !== undefined);
             case "accounts":
             case "quota":
                 return await manage.accounts(config, flags);
@@ -810,8 +1050,16 @@ async function main(argv) {
         case "agent":
         case "web":
             return managed(command, rest);
+        case "pool":
+            return poolCommand(rest);
         case "status":
             return status();
+        case "log":
+            if (rest.includes("--proxy"))
+                return logs(rest.filter((a) => a !== "--proxy"));
+            return managed("log", rest);
+        case "logs":
+            return logs(rest);
         case "up":
             return selfHosted("up");
         case "down":

package/dist/clients.js

@@ -107,10 +107,14 @@ export function envFor(input) {
             return;
         }
         env.ANTHROPIC_BASE_URL = input.proxyUrl;
-        env.ANTHROPIC_API_KEY = input.presentedKey;
-        // Claude Code prefers an auth token when one is set; make sure a stale
-        // one cannot win over the tab key.
-        delete env.ANTHROPIC_AUTH_TOKEN;
+        // The tab key goes in as the auth token, not the API key. Claude Code
+        // asks a person to approve an `ANTHROPIC_API_KEY` once and remembers a
+        // No, after which it silently uses its own Claude login and the call
+        // arrives without the tab key. `ANTHROPIC_AUTH_TOKEN` is checked first,
+        // never asks, and switches the Claude login off for the session. It is
+        // sent as `Authorization: Bearer`, which the proxy reads like `x-api-key`.
+        env.ANTHROPIC_AUTH_TOKEN = input.presentedKey;
+        delete env.ANTHROPIC_API_KEY;
     };
     const setOpenAI = () => {
         if (auth === "subscription") {

package/dist/logins.js

@@ -44,7 +44,9 @@ function jwtClaims(token) {
 export async function localLogin(vendor, opts = {}) {
     const home = opts.home ?? homedir();
     if (vendor === "anthropic") {
-        const account = (await jsonFile(path.join(home, ".claude.json")))?.oauthAccount;
+        // With CLAUDE_CONFIG_DIR set (a pool member), Claude Code keeps the file inside that folder.
+        const file = opts.claudeConfigDir ? path.join(opts.claudeConfigDir, ".claude.json") : path.join(home, ".claude.json");
+        const account = (await jsonFile(file))?.oauthAccount;
         if (!account)
             return undefined;
         const email = str(account.emailAddress);

package/dist/manage.js

@@ -182,7 +182,7 @@ export async function agent(config, flags) {
 /**
  * `tab accounts` (also `tab quota`): every account the flock's subscription
  * Agents were seen on, with the plan the vendor reported, its seat price,
- * what the last 30 days would have cost at list, and what the plan has left.
+ * what the last 30 days would have cost at list, and how much of the plan is used.
  */
 export async function accounts(config, flags) {
     const call = api(config);
@@ -193,9 +193,9 @@ export async function accounts(config, flags) {
         const left = (w) => {
             const pctLeft = Math.max(0, 100 - w.usedPct);
             const paint = pctLeft <= 10 ? red : pctLeft <= 30 ? yellow : green;
-            return paint(`${pctLeft}%`);
+            return paint(`${Math.min(100, Math.max(0, w.usedPct))}%`);
         };
-        return table(["vendor", "account", "plan", "/month", "30d at list", "calls", "left", "agents"], list.map((a) => [
+        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.planLabel ?? dim("unknown"),
@@ -298,6 +298,55 @@ export async function key(config, flags) {
         (flags.opts.show !== undefined ? `\n${issued.key}` : `\n${dim("Add --show to print it once.")}`));
     return 0;
 }
+/** One call, one condensed line: when, which Agent, how it went, what it cost or was worth, what it used. */
+export function logLine(r) {
+    const shadow = r.status === "shadow";
+    const status = shadow ? "SUBSCRIPTION" : (r.status ?? r.decision).toUpperCase();
+    const paint = status === "BLOCKED" || status === "CLOSED" ? red : status === "PENDING" ? yellow : green;
+    return `${dim(r.at)}  ${bold(r.agent)}  ${paint(status)}  ${money(r.cents)}${shadow ? dim(" at list") : ""}  ${dim(r.reason)}`;
+}
+/**
+ * `tab log`: everything that went through the tab for the Agents on this
+ * 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) {
+    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();
+    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));
+    }
+    if (!follow)
+        return 0;
+    for (;;) {
+        await new Promise((resolve) => setTimeout(resolve, 2000));
+        let rows;
+        try {
+            rows = await fetchRows();
+        }
+        catch {
+            continue;
+        }
+        for (const r of [...rows].reverse()) {
+            if (seen.has(r.id))
+                continue;
+            seen.add(r.id);
+            out(flags.json ? JSON.stringify(r) : logLine(r));
+        }
+    }
+}
 export async function ledger(config, flags) {
     const call = api(config);
     const params = new URLSearchParams();
@@ -311,9 +360,11 @@ export async function ledger(config, flags) {
     emit(flags.json, { timezone, rows: list }, () => list.length === 0
         ? dim("No decisions yet.")
         : table(["time", "agent", "action", "amount", "status", "reason"], list.map((r) => {
-            const status = (r.status ?? r.decision).toUpperCase();
+            // A subscription call is recorded at list price; nothing was held, so there is no "of".
+            const shadow = r.status === "shadow";
+            const status = shadow ? "SUBSCRIPTION" : (r.status ?? r.decision).toUpperCase();
             const paint = status === "BLOCKED" || status === "CLOSED" ? red : status === "PENDING" ? yellow : green;
-            const held = r.reservedCents && r.reservedCents !== r.cents ? dim(` of ${money(r.reservedCents)}`) : "";
+            const held = !shadow && r.reservedCents && r.reservedCents !== r.cents ? dim(` of ${money(r.reservedCents)}`) : "";
             return [r.at, r.agent, r.action.length > 28 ? `${r.action.slice(0, 27)}…` : r.action, `${money(r.cents)}${held}`, paint(status), r.reason];
         }), { right: [3] }) + `\n${dim(`times in ${timezone}`)}`);
     return 0;

package/dist/pool-run.js

@@ -0,0 +1,42 @@
+/**
+ * Running a harness on the pool: choose the login at launch, watch what the
+ * vendors report, and when the login in use is over the threshold while
+ * 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`}`;
+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);
+    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.`);
+    let launchArgs = args;
+    for (;;) {
+        deps.say(`Pool: running as ${label(current)}.`);
+        const child = deps.start(current, launchArgs);
+        let next;
+        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;
+                if (to && (await deps.idle().catch(() => false))) {
+                    next = to;
+                    child.stop();
+                    break;
+                }
+            }
+        }
+        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.`);
+        current = next;
+        launchArgs = relaunchArgs(deps.harness, args);
+    }
+}

package/dist/pool.js

@@ -0,0 +1,142 @@
+/**
+ * A subscription pool: several logins of one vendor on this machine, and the
+ * rule for which one a harness runs as. Each member is a folder the harness
+ * itself signs in to (`CLAUDE_CONFIG_DIR` for Claude Code, `CODEX_HOME` for
+ * Codex), so the login stays where the harness keeps it: `tab` never reads,
+ * copies or forwards a token. Usage comes from what the vendors report on
+ * every reply, already kept per account. When the login in use crosses the
+ * threshold and another has room, the harness is relaunched into the same
+ * conversation as that other login.
+ */
+import { chmod, mkdir, readdir, readFile, symlink, writeFile, lstat } from "node:fs/promises";
+import { homedir } from "node:os";
+import path from "node:path";
+import { configDir } from "./config.js";
+export const DEFAULT_AT = 80;
+export function poolPath(env = process.env) {
+    return path.join(configDir(env), "pool.json");
+}
+export function poolVendorFor(harness) {
+    if (harness === "claude")
+        return "anthropic";
+    if (harness === "codex")
+        return "openai";
+    return undefined;
+}
+export async function loadPool(env = process.env) {
+    const empty = { at: DEFAULT_AT, swap: "auto", members: {} };
+    try {
+        const raw = JSON.parse(await readFile(poolPath(env), "utf8"));
+        const at = typeof raw.at === "number" && raw.at >= 1 && raw.at <= 100 ? raw.at : DEFAULT_AT;
+        const members = {};
+        for (const vendor of ["anthropic", "openai"]) {
+            const list = raw.members?.[vendor];
+            if (Array.isArray(list))
+                members[vendor] = list.filter((m) => typeof m?.name === "string" && typeof m?.dir === "string").map((m) => ({ name: m.name, dir: m.dir }));
+        }
+        return { at, swap: raw.swap === "launch" ? "launch" : "auto", members };
+    }
+    catch {
+        return empty;
+    }
+}
+export async function savePool(pool, env = process.env) {
+    const file = poolPath(env);
+    await mkdir(path.dirname(file), { recursive: true, mode: 0o700 });
+    await writeFile(file, `${JSON.stringify(pool, null, 2)}\n`, { mode: 0o600 });
+    await chmod(file, 0o600);
+    return file;
+}
+export function addMember(pool, vendor, name, dir, env = process.env) {
+    if (!/^[A-Za-z0-9][A-Za-z0-9._@-]{0,63}$/.test(name))
+        throw new Error("A member name is letters, digits, dot, dash, underscore or @, up to 64.");
+    const list = pool.members[vendor] ?? [];
+    if (list.some((m) => m.name === name))
+        throw new Error(`${name} is already in the pool.`);
+    const member = { name, dir: dir ? path.resolve(dir) : path.join(configDir(env), "pool", vendor, name) };
+    return { ...pool, members: { ...pool.members, [vendor]: [...list, member] } };
+}
+export function removeMember(pool, vendor, name) {
+    return { ...pool, members: { ...pool.members, [vendor]: (pool.members[vendor] ?? []).filter((m) => m.name !== name) } };
+}
+/** The env that makes a harness use this member's login folder. */
+export function memberEnv(vendor, member) {
+    return vendor === "anthropic" ? { CLAUDE_CONFIG_DIR: member.dir } : { CODEX_HOME: path.join(member.dir, "codex") };
+}
+/** How used an account is: its fullest window that has not reset yet. */
+export function usedPct(quota, now = new Date()) {
+    const live = quota.filter((w) => !w.resetsAt || new Date(w.resetsAt).getTime() > now.getTime());
+    if (quota.length === 0)
+        return undefined;
+    return live.reduce((max, w) => Math.max(max, w.usedPct), 0);
+}
+const room = (s) => s.used ?? 0;
+/** Stay on the current login while it is under the threshold; else the one with most room. */
+export function pickMember(all, at, current) {
+    if (all.length === 0)
+        return undefined;
+    const now = all.find((s) => s.member.name === current);
+    if (now && room(now) < at)
+        return now;
+    return [...all].sort((a, b) => room(a) - room(b))[0];
+}
+/** The login to move to, when the current one is over and another has room. */
+export function shouldSwap(all, at, current) {
+    const now = all.find((s) => s.member.name === current);
+    if (!now || room(now) < at)
+        return undefined;
+    const best = pickMember(all, at, current);
+    return best && best.member.name !== current && room(best) < at ? best : undefined;
+}
+/** Arguments that reopen the conversation the previous login was in. */
+export function relaunchArgs(harness, args) {
+    if (harness === "codex")
+        return ["resume", "--last"];
+    const kept = [];
+    for (let i = 0; i < args.length; i += 1) {
+        const a = args[i];
+        if (a === "--continue" || a === "-c")
+            continue;
+        // One-shot and resume arguments belong to the first launch only.
+        if (a === "--resume" || a === "-r" || a === "-p" || a === "--print") {
+            if (args[i + 1] && !args[i + 1].startsWith("-"))
+                i += 1;
+            continue;
+        }
+        kept.push(a);
+    }
+    return [...kept, "--continue"];
+}
+const NEVER_SHARED = new Set([".credentials.json", ".claude.json", ".claude.json.backup"]);
+/**
+ * A Claude member folder: everything in `~/.claude` linked in (settings,
+ * skills, and `projects`, which is what lets `--continue` find the
+ * conversation under another login), except the login itself. The member's
+ * own `.claude.json` starts as a copy of the person's without the account.
+ */
+export async function prepareClaudeMember(dir, home = homedir()) {
+    await mkdir(dir, { recursive: true, mode: 0o700 });
+    const shared = path.join(home, ".claude");
+    for (const entry of await readdir(shared).catch(() => [])) {
+        if (NEVER_SHARED.has(entry))
+            continue;
+        const target = path.join(dir, entry);
+        if (await lstat(target).then(() => true, () => false))
+            continue;
+        await symlink(path.join(shared, entry), target);
+    }
+    const own = path.join(dir, ".claude.json");
+    if (await lstat(own).then(() => true, () => false))
+        return;
+    let seed = {};
+    try {
+        const parsed = JSON.parse(await readFile(path.join(home, ".claude.json"), "utf8"));
+        if (parsed && typeof parsed === "object")
+            seed = { ...parsed };
+    }
+    catch {
+        // No file to start from: Claude Code makes its own.
+    }
+    delete seed.oauthAccount;
+    await writeFile(own, JSON.stringify(seed), { mode: 0o600 });
+}

package/dist/proxy-bin.js

@@ -8,12 +8,12 @@
  * runtime beyond the binary itself.
  */
 import { spawn } from "node:child_process";
-import { chmod, mkdir, open, readFile, rename, rm, stat, writeFile } from "node:fs/promises";
+import { access, chmod, mkdir, open, readFile, rename, rm, stat, writeFile } from "node:fs/promises";
 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.5";
+export const PROXY_VERSION = "0.1.7";
 export const RELEASES = "https://github.com/joseairosa/flocktab/releases/download";
 export function targetFor(platform = process.platform, arch = process.arch) {
     if (platform === "darwin")
@@ -214,3 +214,13 @@ export async function tailProxyLog(lines = 8, env = process.env) {
         return [];
     }
 }
+/** Whether the local proxy has written a log yet. */
+export async function hasProxyLog(env = process.env) {
+    try {
+        await access(proxyLogPath(env));
+        return true;
+    }
+    catch {
+        return false;
+    }
+}

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.8";
+export const TAB_VERSION = "0.1.10";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hanamorilabs/tab",
-  "version": "0.1.8",
+  "version": "0.1.10",
   "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.5",
-    "@hanamorilabs/flocktab-proxy-darwin-x64": "0.1.5",
-    "@hanamorilabs/flocktab-proxy-linux-x64": "0.1.5",
-    "@hanamorilabs/flocktab-proxy-linux-arm64": "0.1.5",
-    "@hanamorilabs/flocktab-proxy-win-x64": "0.1.5"
+    "@hanamorilabs/flocktab-proxy-darwin-arm64": "0.1.7",
+    "@hanamorilabs/flocktab-proxy-darwin-x64": "0.1.7",
+    "@hanamorilabs/flocktab-proxy-linux-x64": "0.1.7",
+    "@hanamorilabs/flocktab-proxy-linux-arm64": "0.1.7",
+    "@hanamorilabs/flocktab-proxy-win-x64": "0.1.7"
   },
   "devDependencies": {
     "@types/node": "^22.18.6",