@hanamorilabs/tab 0.1.11 → 0.1.13

package/README.md

@@ -86,6 +86,8 @@ Codex shows `FlockTab - Self-hosted` as its provider.
 
 ## Commands
 
+`tab help` lists every command by group. `tab help <command>` (or `tab <command> --help`) explains one in full: what it does, its options, examples. `tab help glossary` says what is what, `tab help errors` lists every refusal and what to do. The same reference, with how the system works, is in the console under Docs (`console.flocktab.com/docs`).
+
 ```
 tab login            approve this machine in the console, once
 tab <agent> [args]   claude, codex, grok, kimi, gemini, or any command, on the tab
@@ -93,7 +95,7 @@ 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 used
-tab pool             several logins of one vendor: add claude|codex <name>, at <percent>, swap auto|launch
+tab pool             several logins of one vendor: add claude|codex|grok|kimi <name>, at [vendor] <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
@@ -161,3 +163,19 @@ plan    team
 kind    api (the flock's provider key, metered on the tab)
 byok    provider keys on this box
 ```
+
+## Trying a change before it is released
+
+`tabdev` is this checkout's CLI run from source, beside the `tab` npm
+installed. It keeps everything of its own: `~/.flocktabdev` for the login,
+keys, pool and proxy files, and `.flocktabdev` as the per-folder file. Nothing
+it does touches the production `tab`. Log it in once with `tabdev login`, and
+give its folders Agents of their own: choosing an Agent that production
+already holds a key for would replace that key (it asks first).
+
+```
+node apps/tab/scripts/link-dev.mjs            # writes ~/.local/bin/tabdev
+tabdev version                                # "0.1.x + dev (this checkout's source)"
+tabdev claude                                 # exactly what the next release would do
+node apps/tab/scripts/link-dev.mjs --remove
+```

package/dist/alias.js

@@ -65,10 +65,12 @@ export function shimDirOnPath(env = process.env, platform = process.platform) {
 /** PATH for the child agent: everything except the shim folder. */
 export function pathWithoutShims(env = process.env, platform = process.platform) {
     const sep = platform === "win32" ? ";" : ":";
-    const dir = path.resolve(shimDir(env));
+    // Also the default home's shims: a CLI run with FLOCKTAB_HOME elsewhere (tabdev)
+    // must not spawn a production `claude` shim that re-enters the other tab.
+    const dirs = new Set([path.resolve(shimDir(env)), path.resolve(shimDir({}))]);
     return (env.PATH ?? "")
         .split(sep)
-        .filter((p) => p && path.resolve(p) !== dir)
+        .filter((p) => p && !dirs.has(path.resolve(p)))
         .join(sep);
 }
 /** The line to add to a shell rc so the shims win. */

package/dist/cli.js

@@ -32,12 +32,16 @@ import { bold, box, cyan, dim, green, heading, line, rows, underline, yellow } f
 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 { addMember, loadPool, memberEnv, memberHome, POOL_VENDORS, poolVendorFor, prepareClaudeMember, prepareSharedSessions, limitsFor, removeMember, savePool, setGuard, setThreshold, thresholdFor, usage as quotaUsage } from "./pool.js";
 import { runPooled } from "./pool-run.js";
+import { renderPool } from "./pool-view.js";
+import { renderHelp } from "./help.js";
+import { findTabCommand } from "./tab-docs.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";
 import { reportFolder } from "./folder.js";
+import { whoami } from "./proxy-identity.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";
@@ -48,68 +52,15 @@ const say = (text) => console.error(text);
 const ok = (text) => say(line("ok", text));
 const warn = (text) => say(line("warn", text));
 const fail = (text) => say(line("fail", text));
-function usage() {
-    const others = knownClients().filter((n) => n !== "claude" && n !== "codex");
-    const cmd = (name, what) => [`tab ${name}`, what];
-    say(`${heading("tab")} ${dim("- run any AI agent on a FlockTab tab")}
-`);
-    say(rows([
-        cmd("login", "approve this machine in the console, once"),
-        cmd("claude [args]", "Claude Code on the tab"),
-        cmd("codex [args]", "Codex on the tab"),
-        cmd(others.join(" | tab "), "the same, for those agents"),
-        cmd("<command> [args]", "any other agent, both APIs pointed at the tab"),
-        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 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 through the browser (--email to prefill, --dir <path> to use a folder 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"),
-        cmd("cap [agent] <dollars>", "set the cap (--window day|week|month|run|hour|lifetime)"),
-        cmd("rename <agent> <name>", "rename it (the slug stays)"),
-        cmd("policy [agent]", "show or set: --velocity N|none --models a,b|none --allow tool|none"),
-        cmd("project [agent] <name>", "attribute to a project (--create, --repo owner/name, none)"),
-        cmd("projects [add <name>]", "list or add projects"),
-        cmd("key rotate [agent]", "new key, kept on this machine (--show prints it once)"),
-        cmd("archive [agent]", "close for good and leave the bill"),
-        cmd("ledger [agent]", "one row per call (--limit N --blocked)"),
-        cmd("spend [agent|project|day]", "meter and outside spend (--since 7d --agent x)"),
-        cmd("outside", "outside-spend connections and per-project totals"),
-        cmd("live", "who is working now (--watch 4)"),
-        cmd("web [agent]", "open the Agent's console page"),
-        cmd("... --json", "every read command as JSON, for scripts and agents"),
-        cmd("up", "self-hosted: start the local proxy (fetches it the first time)"),
-        cmd("down", "self-hosted: stop the local proxy"),
-        cmd("update", "the newest tab (and proxy) from npm; restarts a running local proxy"),
-        cmd("logout", "forget the session and keys"),
-    ].map(([k, v]) => [cyan(k), v])));
-    say(`
-${dim("Config")} ${configPath()}  ${dim("or FLOCKTAB_PROXY_URL, FLOCKTAB_KEY, FLOCKTAB_UNLOCK")}`);
-}
-async function whoami(proxyUrl, login) {
-    try {
-        const response = await fetch(`${proxyUrl}/v1/whoami`, {
-            headers: { authorization: `Bearer ${presentedKey(login)}` },
-        });
-        const body = (await response.json().catch(() => ({})));
-        if (!response.ok) {
-            const message = body.error?.message;
-            return { error: message ?? `whoami returned ${response.status}` };
-        }
-        return body;
-    }
-    catch {
-        return { error: "proxy unreachable" };
+/** `tab help`, `tab help <word>`: the overview, one command, the glossary, the errors. */
+function usage(word) {
+    const text = renderHelp(word, { configPath: configPath() });
+    if (text === undefined) {
+        fail(`No help for "${word}". ${dim("tab help lists every command.")}`);
+        return 2;
     }
+    say(text);
+    return 0;
 }
 /**
  * Without a terminal (CI, a script, `printf ... | tab up`) every answer
@@ -474,7 +425,9 @@ async function version() {
     const bin = proxyBinPath();
     const installed = await proxyInstalled();
     const where = packaged ? `packaged, ${packaged}` : installed ? `downloaded, ${bin}` : "not installed; tab up fetches it";
-    say(rows([["tab", TAB_VERSION], ["proxy", `${PROXY_VERSION}  ${dim(`(${where})`)}`]], 0));
+    // `tabdev` (scripts/link-dev.mjs) runs this checkout's source, not the npm install.
+    const tabVersion = process.env.FLOCKTAB_DEV ? `${TAB_VERSION} + dev ${dim("(this checkout's source)")}` : TAB_VERSION;
+    say(rows([["tab", tabVersion], ["proxy", `${PROXY_VERSION}  ${dim(`(${where})`)}`]], 0));
     return 0;
 }
 async function status() {
@@ -539,17 +492,53 @@ function takePoolFlags(argv) {
     }
     return { args, noPool, asked: asked || pinned !== undefined, ...(pinned ? { pinned } : {}) };
 }
+/** The login a member's folder holds, read from the harness's own files (account fields only). */
+function memberLogin(vendor, member) {
+    const home = memberHome(vendor, member);
+    return localLogin(vendor, vendor === "anthropic" ? { claudeConfigDir: home } : vendor === "openai" ? { codexHome: home } : vendor === "xai" ? { grokHome: home } : { kimiShareDir: home });
+}
+const VENDOR_NAMES = { anthropic: "Claude", openai: "ChatGPT (Codex)", xai: "Grok", kimi: "Kimi" };
+const VENDOR_HARNESS = { anthropic: "claude", openai: "codex", xai: "grok", kimi: "kimi" };
 async function flockAccounts(config) {
     return (await manage.api(config)("GET", "/api/cli/accounts")).accounts;
 }
+/**
+ * Tell the console which logins this machine is signed in with, so a pool
+ * member shows there before its first call. Only what the harness's own
+ * files say about the account (the vendor's id, email, plan tier), never a
+ * login. Best effort: the pool works the same when the console is away.
+ */
+async function registerPoolLogins(config, pool) {
+    const accounts = [];
+    for (const vendor of POOL_VENDORS) {
+        for (const member of pool.members[vendor] ?? []) {
+            const login = await memberLogin(vendor, member);
+            if (!login?.accountId)
+                continue;
+            accounts.push({ provider: vendor, externalId: login.accountId, ...(login.email ? { email: login.email } : {}), ...(login.plan ? { plan: login.plan } : {}) });
+        }
+    }
+    if (accounts.length === 0)
+        return undefined;
+    try {
+        return (await manage.api(config)("POST", "/api/cli/accounts", { accounts })).accounts;
+    }
+    catch {
+        return undefined;
+    }
+}
 /** 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(() => []);
+async function poolStandings(config, vendor, members, known) {
+    const accounts = known ?? (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 login = await memberLogin(vendor, member);
         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 } : {}) };
+        // By email where the vendor names one, else by the account id the proxy files calls under.
+        const account = accounts.find((a) => a.provider === vendor && ((email && a.email?.toLowerCase() === email.toLowerCase()) || (login?.accountId && a.externalId === login.accountId)));
+        const shown = email ?? (login?.accountId ? `account ${login.accountId.slice(0, 12)}` : undefined);
+        // The vendor's plan name once seen on the wire; before that, what the harness's own file says.
+        const plan = account?.planLabel ?? login?.plan?.replace(/^default_/, "").replaceAll("_", " ");
+        return { member, used: undefined, ...(account ? quotaUsage(account.quota) : {}), ...(shown ? { email: shown } : {}), ...(plan ? { plan } : {}), ...(account ? { windows: account.quota } : {}) };
     }));
 }
 /** Quiet: no call of this Agent in flight, and no reply from the vendor in the last 20 seconds. */
@@ -566,7 +555,8 @@ async function runAgent(name, argv) {
     const config = await ensureLogin();
     if (!config)
         return 2;
-    if (!(await ensureProxy(config)))
+    // Hosted whoami below proves readiness and current Agent kind in one round trip.
+    if (config.mode === "self-hosted" && !(await ensureProxy(config)))
         return 1;
     const agent = await resolveAgent(config);
     if (!agent)
@@ -578,6 +568,10 @@ async function runAgent(name, argv) {
     // consumer plan, is metered with the flock's key.
     const vendor = subscriptionVendorFor(name);
     const me = await whoami(config.proxyUrl, { key: agent.key, unlock: config.unlock });
+    if (config.mode === "hosted" && "error" in me) {
+        fail(me.error);
+        return 1;
+    }
     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.
@@ -653,7 +647,11 @@ async function runAgent(name, argv) {
     };
     if (!pooled || !poolVendor || !pool)
         return launch(args, env).done;
-    // Codex members each need their own home written before the first launch.
+    // Codex members each need their own home written before the first launch;
+    // Codex, Grok and Kimi members share one conversations folder.
+    for (const member of members)
+        await prepareSharedSessions(poolVendor, member);
+    void registerPoolLogins(config, pool);
     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") });
@@ -661,7 +659,7 @@ async function runAgent(name, argv) {
     }
     return runPooled(args, {
         harness: name,
-        at: pool.at,
+        limits: limitsFor(pool, poolVendor),
         swap: pool.swap,
         ...(pinned ? { pinned } : {}),
         standings: () => poolStandings(config, poolVendor, members),
@@ -686,14 +684,42 @@ async function poolCommand(argv) {
     const [sub, ...rest] = argv;
     const pool = await loadPool();
     const vendorOf = (word) => poolVendorFor(word === "chatgpt" ? "codex" : (word ?? ""));
+    const HARNESSES = "claude|codex|grok|kimi";
     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.");
+        // `tab pool at 80` for everyone; `tab pool at claude 70` for one vendor; `tab pool at claude default` to clear it.
+        // A window word makes it the weekly guard: `tab pool at 7d 95`, `tab pool at claude weekly 90`.
+        const words = rest.filter((w) => !["7d", "weekly", "week", "long"].includes(w));
+        const guard = words.length !== rest.length;
+        // `5h` / `short` is the default meaning, accepted so both read the same way.
+        const plain = words.filter((w) => !["5h", "short"].includes(w));
+        const vendor = plain.length > 1 ? vendorOf(plain[0]) : undefined;
+        const value = plain.length > 1 ? plain[1] : plain[0];
+        const clear = vendor !== undefined && (value === "default" || value === "reset");
+        if ((plain.length > 1 && !vendor) || plain.length > 2 || (!clear && !/^\d{1,3}$/.test(value ?? ""))) {
+            fail(`tab pool at [claude|codex|grok|kimi] [7d] <percent>|default. ${dim("A percent is 1 to 100. Without 7d it is the short (5-hour) window; with it, the weekly guard.")}`);
             return 2;
         }
-        await savePool({ ...pool, at: Math.round(pct) });
-        ok(`The pool moves to another login at ${Math.round(pct)}% used.`);
+        let next;
+        try {
+            next = (guard ? setGuard : setThreshold)(pool, clear ? undefined : Number(value), vendor);
+        }
+        catch (err) {
+            fail(err.message);
+            return 2;
+        }
+        await savePool(next);
+        if (guard) {
+            const g = vendor ? limitsFor(next, vendor).guard : next.guard;
+            ok(`${vendor ? `${VENDOR_NAMES[vendor]} logins give` : "A login gives"} way once ${g}% of the long (weekly) window is used, whatever the short one says. ${dim("Below that the weekly window is ignored.")}`);
+        }
+        else if (!vendor) {
+            const own = POOL_VENDORS.filter((v) => next.atByVendor[v] !== undefined).map((v) => `${VENDOR_HARNESS[v]} ${next.atByVendor[v]}%`);
+            ok(`The pool moves to another login at ${next.at}% used.${own.length > 0 ? dim(` Still their own: ${own.join(", ")}.`) : ""}`);
+        }
+        else if (clear)
+            ok(`${VENDOR_NAMES[vendor]} logins move at the shared ${next.at}% again.`);
+        else
+            ok(`${VENDOR_NAMES[vendor]} logins move at ${thresholdFor(next, vendor)}% used. ${dim(`Everyone else at ${next.at}%.`)}`);
         return 0;
     }
     if (sub === "swap") {
@@ -710,7 +736,7 @@ async function poolCommand(argv) {
         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>]" : ""}`);
+            fail(`tab pool ${sub} ${HARNESSES} <name>${sub === "add" ? " [--dir <folder>] [--email <address>]" : ""}`);
             return 2;
         }
         if (sub !== "add") {
@@ -727,27 +753,33 @@ async function poolCommand(argv) {
             return 2;
         }
         const member = next.members[vendor].at(-1);
-        const loginOf = () => localLogin(vendor, vendor === "anthropic" ? { claudeConfigDir: member.dir } : { codexHome: path.join(member.dir, "codex") });
+        const loginOf = () => memberLogin(vendor, member);
+        const signedIn = async () => {
+            const l = await loginOf();
+            return Boolean(l?.email ?? l?.accountId);
+        };
         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";
+        await mkdir(memberHome(vendor, member), { recursive: true, mode: 0o700 });
+        if (!flags.opts.dir)
+            await prepareSharedSessions(vendor, member);
+        if (!(await signedIn())) {
+            const harness = VENDOR_HARNESS[vendor];
             // `claude auth login` does the browser sign-in and exits: no session to open, no /login, no /exit.
             const email = flags.opts.email ?? (memberName.includes("@") ? memberName : undefined);
-            say(dim(`Signing ${vendor === "anthropic" ? "Claude Code" : "Codex"} in for ${memberName}. Your browser opens; pick the account for this login.`));
+            say(dim(`Signing ${harness} in for ${memberName}. Your browser opens; pick the account for this login.`));
             // 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"])
+            for (const k of ["ANTHROPIC_BASE_URL", "ANTHROPIC_API_KEY", "ANTHROPIC_AUTH_TOKEN", "OPENAI_BASE_URL", "OPENAI_API_KEY", "XAI_API_KEY", "GROK_XAI_API_BASE_URL", "KIMI_API_KEY", "KIMI_BASE_URL", "KIMI_CODE_BASE_URL"])
                 delete loginEnv[k];
             const run = (argv) => new Promise((resolve) => {
                 const child = spawn(harness, argv, { stdio: "inherit", env: loginEnv });
                 child.on("error", () => resolve(127));
                 child.on("close", (c) => resolve(c ?? 1));
             });
+            // Every one of them has its own sign-in command that opens the browser and exits.
             let code = await run(vendor === "anthropic" ? ["auth", "login", "--claudeai", ...(email ? ["--email", email] : [])] : ["login"]);
-            if (vendor === "anthropic" && code !== 0 && code !== 127 && !(await loginOf())?.email) {
+            if (vendor === "anthropic" && code !== 0 && code !== 127 && !(await signedIn())) {
                 // A Claude Code too old for `auth login`: sign in from inside it.
                 say(dim("That did not sign in. Opening Claude Code instead: /login as this account, then /exit."));
                 code = await run([]);
@@ -758,35 +790,32 @@ async function poolCommand(argv) {
             }
         }
         const login = await loginOf();
-        if (!login?.email) {
+        if (!(await signedIn())) {
             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)}.`);
+        const session = await loadConfig();
+        const shown = session?.token ? await registerPoolLogins(session, next) : undefined;
+        ok(`${bold(memberName)} is in the pool as ${describeLogin(login)}.${shown ? dim(" It shows in the console under Subscriptions.") : ""}`);
         return 0;
     }
-    if (sub && sub !== "list" && sub !== "ls") {
+    if (sub && sub !== "list" && sub !== "ls" && sub !== "--paths") {
         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);
+    const vendors = POOL_VENDORS.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.`));
+    // One round trip: register what this machine is signed in with, and get every account back.
+    const accounts = (await registerPoolLogins(config, pool)) ?? (await flockAccounts(config).catch(() => []));
+    const sections = await 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) })));
+    say(renderPool(sections, { at: pool.at, swap: pool.swap, paths: argv.includes("--paths") }));
     return 0;
 }
 /**
@@ -1015,13 +1044,20 @@ async function managed(command, rest) {
 }
 async function main(argv) {
     const [command, ...rest] = argv;
+    if (command && (rest.includes("--help") || rest.includes("-h"))) {
+        const doc = findTabCommand(command);
+        // `tab claude --help` is Claude's help: everything after an agent's name is the agent's.
+        if (doc && doc.group !== "run")
+            return usage(command);
+    }
     switch (command) {
         case undefined:
         case "-h":
         case "--help":
-        case "help":
-            usage();
-            return command === undefined ? 2 : 0;
+        case "help": {
+            const code = usage(command === "help" ? rest[0] : undefined);
+            return command === undefined ? 2 : code;
+        }
         case "login":
             return login(rest);
         case "logout":

package/dist/clients.js

@@ -128,7 +128,11 @@ export function envFor(input) {
                 delete env.XAI_API_KEY;
             }
             if (spec.provider === "moonshot") {
-                env.KIMI_BASE_URL = `${passthroughBase(input.proxyUrl, input.presentedKey, "kimi")}/coding/v1`;
+                // Kimi Code (the `~/.kimi-code` CLI) reads its plan endpoint from KIMI_CODE_BASE_URL;
+                // the older kimi-cli reads KIMI_BASE_URL. Its sign-in host is separate and untouched.
+                const kimiBase = `${passthroughBase(input.proxyUrl, input.presentedKey, "kimi")}/coding/v1`;
+                env.KIMI_CODE_BASE_URL = kimiBase;
+                env.KIMI_BASE_URL = kimiBase;
                 delete env.KIMI_API_KEY;
             }
             return;

package/dist/codex-home.js

@@ -10,7 +10,7 @@
  *
  * The person's own `~/.codex` is never read or written.
  */
-import { chmod, copyFile, mkdir, readFile, unlink, writeFile } from "node:fs/promises";
+import { chmod, copyFile, lstat, mkdir, readdir, readFile, rename, rm, symlink, unlink, writeFile } from "node:fs/promises";
 import { homedir } from "node:os";
 import path from "node:path";
 import { passthroughBase } from "./clients.js";
@@ -67,13 +67,57 @@ export async function prepareCodexHome(input) {
         await writeFile(config, codexConfigToml(input.proxyUrl, input.model, input.mode ?? "hosted"), { mode: 0o600 });
     }
     await chmod(config, 0o600);
+    await shareConversations(home, input.userCodexHome ?? path.join(homedir(), ".codex"));
     return home;
 }
+/**
+ * Codex keeps conversations as rollout files under `sessions`. The tab's
+ * home is its own folder (so its config and login never touch `~/.codex`),
+ * which hid every conversation the person already had: `tab codex resume
+ * <id>` answered "no saved session". `sessions` is therefore a link to the
+ * person's own, and anything already recorded under the tab is moved across
+ * first. With no `~/.codex` on the machine there is nothing to share.
+ */
+export async function shareConversations(home, userCodexHome) {
+    if (!(await lstat(userCodexHome).then((s) => s.isDirectory(), () => false)))
+        return "none";
+    const theirs = path.join(userCodexHome, "sessions");
+    const mine = path.join(home, "sessions");
+    if (path.resolve(theirs) === path.resolve(mine))
+        return "already";
+    const state = await lstat(mine).catch(() => undefined);
+    if (state?.isSymbolicLink())
+        return "already";
+    await mkdir(theirs, { recursive: true, mode: 0o700 });
+    if (state?.isDirectory()) {
+        await moveInto(mine, theirs);
+        await rm(mine, { recursive: true, force: true });
+    }
+    await symlink(theirs, mine);
+    return "linked";
+}
+/** Move every file under `from` to the same place under `to`; a file already there is kept. */
+export async function moveInto(from, to) {
+    for (const entry of await readdir(from, { withFileTypes: true })) {
+        const src = path.join(from, entry.name);
+        const dest = path.join(to, entry.name);
+        if (entry.isDirectory()) {
+            await mkdir(dest, { recursive: true, mode: 0o700 });
+            await moveInto(src, dest);
+        }
+        else if (!(await lstat(dest).then(() => true, () => false))) {
+            await rename(src, dest).catch(async () => {
+                // Another volume: copy, then the caller removes the source tree.
+                await copyFile(src, dest);
+            });
+        }
+    }
+}
 /**
  * The ChatGPT login for the tab's Codex home. A login already there (from
  * `codex login` run through `tab codex`) stays. Otherwise the person's own
  * `~/.codex/auth.json` is copied, owner-only: same machine, same person,
- * and `~/.codex` itself is still never written. A leftover API-key auth
+ * and the login and config in `~/.codex` are still never written. A leftover API-key auth
  * file from metered mode is replaced; with nothing to copy, Codex asks the
  * person to sign in and keeps that login in the tab home.
  */

package/dist/console-api.js

@@ -3,6 +3,7 @@
  * make one, key one. All three are `/api/cli/*` with `Bearer ft_cli_...`.
  * Injectable fetch so the folder picker is testable without a console.
  */
+import { requestJson } from "./network.js";
 export class ConsoleApiError extends Error {
     status;
     constructor(message, status) {
@@ -12,11 +13,10 @@ export class ConsoleApiError extends Error {
     }
 }
 async function call(consoleUrl, token, path, init, fetchImpl) {
-    const response = await fetchImpl(`${consoleUrl}${path}`, {
+    const { response, body } = await requestJson(`${consoleUrl}${path}`, {
         ...init,
         headers: { authorization: `Bearer ${token}`, "content-type": "application/json", ...(init.headers ?? {}) },
-    });
-    const body = (await response.json().catch(() => ({})));
+    }, fetchImpl);
     if (!response.ok) {
         const detail = body.error ?? `console answered ${response.status}`;
         throw new ConsoleApiError(body.hint ? `${detail} (${body.hint})` : detail, response.status);

package/dist/folder.js

@@ -1,4 +1,5 @@
 import { execFileSync } from "node:child_process";
+import { requestJson } from "./network.js";
 function parseGitRepo(remote) {
     const trimmed = remote.trim();
     const ssh = /^git@github\.com:([^/]+)\/(.+?)(?:\.git)?$/i.exec(trimmed);
@@ -34,14 +35,14 @@ export function gitRepoFromCwd(cwd) {
 export function reportFolder(proxyUrl, presentedKey) {
     const cwd = process.cwd();
     const git = gitRepoFromCwd(cwd);
-    void fetch(`${proxyUrl}/v1/here`, {
+    void requestJson(`${proxyUrl}/v1/here`, {
         method: "POST",
         headers: {
             authorization: `Bearer ${presentedKey}`,
             "content-type": "application/json",
         },
         body: JSON.stringify({ cwd, git }),
-    }).catch(() => {
+    }, fetch, 5_000).catch(() => {
         // The Agent still runs if this misses.
     });
 }