@phnx-labs/agents-cli 1.20.41 → 1.20.43

package/dist/lib/session/run-names.js

@@ -0,0 +1,63 @@
+/**
+ * Run-name index: the join between a `agents run --name <slug>` handle and the
+ * session id of the run it named.
+ *
+ * `agents run` records `<sessionId>.json` here at launch whenever both a name
+ * and a session id are known up front (Claude pre-mints its id — see
+ * spawnAgent). The session-discovery pass reads these sidecars and applies the
+ * names onto the SQLite index by id (via syncNames), the same idempotent,
+ * re-applied-every-scan pattern as Claude `/rename` labels. Names therefore
+ * survive transcript rescans without being parsed out of the transcript itself.
+ *
+ * Mirrors the host-task sidecar convention (`~/.agents/.cache/hosts/<id>.json`),
+ * one small JSON per run under `~/.agents/.cache/run-names/`.
+ */
+import * as fs from 'fs';
+import * as path from 'path';
+import { getCacheDir } from '../state.js';
+export function runNamesDir() {
+    return path.join(getCacheDir(), 'run-names');
+}
+function recordFile(sessionId) {
+    return path.join(runNamesDir(), `${sessionId}.json`);
+}
+/**
+ * Record a run's `--name` handle keyed by its session id. Best-effort: a failed
+ * write must never break the run itself. No-op without both a name and id.
+ */
+export function recordRunName(rec) {
+    if (!rec.sessionId || !rec.name)
+        return;
+    try {
+        fs.mkdirSync(runNamesDir(), { recursive: true });
+        fs.writeFileSync(recordFile(rec.sessionId), JSON.stringify({ ...rec, ts: Date.now() }, null, 2));
+    }
+    catch {
+        /* the run is already launching; the name is a convenience, not load-bearing */
+    }
+}
+/**
+ * Build the sessionId → name map from every run-name sidecar, for syncNames to
+ * apply onto the index. Returns an empty map when the dir doesn't exist yet.
+ */
+export function buildRunNameMap() {
+    const map = new Map();
+    let files;
+    try {
+        files = fs.readdirSync(runNamesDir()).filter((f) => f.endsWith('.json'));
+    }
+    catch {
+        return map;
+    }
+    for (const f of files) {
+        try {
+            const rec = JSON.parse(fs.readFileSync(path.join(runNamesDir(), f), 'utf-8'));
+            if (rec.sessionId && rec.name)
+                map.set(rec.sessionId, rec.name);
+        }
+        catch {
+            /* skip a corrupt sidecar */
+        }
+    }
+    return map;
+}

package/dist/lib/session/types.d.ts

@@ -67,6 +67,14 @@ export interface SessionMeta {
     topic?: string;
     /** Custom name the user gave the session (e.g. Claude Code /rename). */
     label?: string;
+    /**
+     * Durable launch handle from `agents run --name <slug>` — an alias chosen at
+     * launch (not derived from the session id), used to resolve the run in
+     * `agents sessions <name>`. Distinct from `label` (post-hoc /rename): a run's
+     * name is immutable; both are searchable. Absent for runs launched without
+     * `--name`.
+     */
+    name?: string;
     /** Set when this session was spawned by `agents teams`. */
     teamOrigin?: TeamOrigin;
     /** Durable state signals extracted at scan time by the session-state engine. */

package/dist/lib/session/viewing-in.d.ts

@@ -0,0 +1,54 @@
+/**
+ * "Viewing in <app> tab N" for tmux-hosted agent sessions.
+ *
+ * A tmux-wrapped agent (see src/lib/exec.ts `runInTmux`) runs detached on the
+ * shared socket; a terminal only *displays* it while a client is attached. This
+ * resolver answers "which app + tab is looking at this session right now" by
+ * matching the session to its attached tmux client(s) and reusing the app/tab
+ * resolvers we already have:
+ *
+ *   - app  — the client's terminal PID walked up the process ancestry via the
+ *            shared HOST_MATCHERS logic (`hostFromPid`).
+ *   - tab  — per app: Ghostty via `assignGhosttyTabs` (cwd + title match), iTerm
+ *            via the `t<n>` field of the client's `$ITERM_SESSION_ID`, and
+ *            VS Code / Cursor / Codium via the extension-published `tabIndex` in
+ *            live-terminals.json (keyed by session id).
+ *
+ * No client attached => `undefined` (the session is running detached). Every
+ * lookup is best-effort; a miss degrades to `{ app }` with no tab, never throws.
+ */
+import type { TmuxClient } from '../tmux/session.js';
+import type { ActiveSession } from './active.js';
+import { type GhosttySurface } from './ghostty-tabs.js';
+/** Where a tmux-hosted session is currently displayed. */
+export interface ViewingIn {
+    /** Host app of the attached client — 'ghostty', 'iterm', 'code', 'codium', … */
+    app: string;
+    /** 1-based tab number within that app, when it can be resolved. */
+    tab?: number;
+}
+/** Injection seams so `resolveViewingIn` is unit-testable without a live tmux/ps/osascript. */
+export interface ViewingInDeps {
+    /** Ghostty surfaces (window/tab/cwd/title). Enumerated once by the caller and shared. */
+    ghosttySurfaces?: GhosttySurface[];
+    /** pane id -> `session:window.pane`, from `mapPanesToTargets`. Used to find the session name. */
+    paneToTarget?: Map<string, string>;
+    /** client pid -> host app. Defaults to the real `hostFromPid`. */
+    resolveApp?: (pid: number) => Promise<string | undefined>;
+    /** client pid -> raw env. Defaults to reading /proc (Linux) or `ps eww` (macOS). */
+    readClientEnv?: (pid: number) => Promise<Record<string, string> | undefined>;
+    /** session id -> VS Code editor-tab index, from live-terminals.json. Defaults to the real read. */
+    tabIndexForSession?: (sessionId: string | undefined) => number | undefined;
+}
+/**
+ * Resolve where a single tmux-hosted session is being viewed. Returns undefined
+ * when the session isn't tmux-hosted, can't be located, or has no client
+ * attached (detached). Pure aside from the injected (defaulted) probes.
+ */
+export declare function resolveViewingIn(session: ActiveSession, clients: TmuxClient[], deps?: ViewingInDeps): Promise<ViewingIn | undefined>;
+/**
+ * iTerm tab from the attaching client's `$ITERM_SESSION_ID` (`w<n>t<n>p<n>:UUID`).
+ * The `t<n>` field is iTerm2's 0-based tab index; we present it 1-based to match
+ * Ghostty's `index of tab`. Exported for the parser test.
+ */
+export declare function itermTabFromSessionId(value: string | undefined): number | undefined;

package/dist/lib/session/viewing-in.js

@@ -0,0 +1,155 @@
+/**
+ * "Viewing in <app> tab N" for tmux-hosted agent sessions.
+ *
+ * A tmux-wrapped agent (see src/lib/exec.ts `runInTmux`) runs detached on the
+ * shared socket; a terminal only *displays* it while a client is attached. This
+ * resolver answers "which app + tab is looking at this session right now" by
+ * matching the session to its attached tmux client(s) and reusing the app/tab
+ * resolvers we already have:
+ *
+ *   - app  — the client's terminal PID walked up the process ancestry via the
+ *            shared HOST_MATCHERS logic (`hostFromPid`).
+ *   - tab  — per app: Ghostty via `assignGhosttyTabs` (cwd + title match), iTerm
+ *            via the `t<n>` field of the client's `$ITERM_SESSION_ID`, and
+ *            VS Code / Cursor / Codium via the extension-published `tabIndex` in
+ *            live-terminals.json (keyed by session id).
+ *
+ * No client attached => `undefined` (the session is running detached). Every
+ * lookup is best-effort; a miss degrades to `{ app }` with no tab, never throws.
+ */
+import * as path from 'path';
+import * as fs from 'fs';
+import { execFile } from 'child_process';
+import { promisify } from 'util';
+import { readFile } from 'fs/promises';
+import { hostFromPid } from './active.js';
+import { enumerateGhosttyTabs, assignGhosttyTabs } from './ghostty-tabs.js';
+import { getTerminalsDir } from '../state.js';
+const execFileAsync = promisify(execFile);
+/** Apps whose tab index is published by the extension via live-terminals.json. */
+const EDITOR_APPS = new Set(['code', 'cursor', 'codium', 'windsurf']);
+/** The tmux session name a session's pane belongs to, from `session:window.pane`. */
+function sessionNameFor(session, paneToTarget) {
+    const pane = session.provenance?.mux?.pane;
+    const target = (pane && paneToTarget?.get(pane)) ?? session.tmuxTarget;
+    if (!target)
+        return undefined;
+    const name = target.split(':')[0];
+    return name || undefined;
+}
+/**
+ * Resolve where a single tmux-hosted session is being viewed. Returns undefined
+ * when the session isn't tmux-hosted, can't be located, or has no client
+ * attached (detached). Pure aside from the injected (defaulted) probes.
+ */
+export async function resolveViewingIn(session, clients, deps = {}) {
+    if (session.provenance?.mux?.kind !== 'tmux' || !session.provenance.mux.pane)
+        return undefined;
+    const sessName = sessionNameFor(session, deps.paneToTarget);
+    if (!sessName)
+        return undefined;
+    const attached = clients.filter((c) => c.target.split(':')[0] === sessName);
+    if (attached.length === 0)
+        return undefined; // running detached — no viewer
+    const client = attached[0];
+    const resolveApp = deps.resolveApp ?? hostFromPid;
+    const app = (await resolveApp(client.pid)) ?? 'terminal';
+    let tab;
+    if (app === 'ghostty') {
+        tab = await ghosttyTab(session, deps.ghosttySurfaces);
+    }
+    else if (app === 'iterm') {
+        tab = await itermTab(client.pid, deps.readClientEnv ?? readClientEnv);
+    }
+    else if (EDITOR_APPS.has(app)) {
+        const lookup = deps.tabIndexForSession ?? tabIndexFromLiveTerminals;
+        tab = lookup(session.sessionId);
+    }
+    return { app, tab };
+}
+/** Ghostty tab via the existing cwd+title matcher, reusing shared surfaces when provided. */
+async function ghosttyTab(session, surfaces) {
+    const s = surfaces ?? (await enumerateGhosttyTabs());
+    if (s.length === 0)
+        return undefined;
+    // assignGhosttyTabs only considers host === 'ghostty' sessions; use a probe
+    // clone so we don't mutate the real row's host.
+    const probe = { ...session, host: 'ghostty' };
+    return assignGhosttyTabs([probe], s).get(probe);
+}
+/**
+ * iTerm tab from the attaching client's `$ITERM_SESSION_ID` (`w<n>t<n>p<n>:UUID`).
+ * The `t<n>` field is iTerm2's 0-based tab index; we present it 1-based to match
+ * Ghostty's `index of tab`. Exported for the parser test.
+ */
+export function itermTabFromSessionId(value) {
+    if (!value)
+        return undefined;
+    const m = value.match(/t(\d+)/);
+    if (!m)
+        return undefined;
+    const n = parseInt(m[1], 10);
+    return Number.isFinite(n) ? n + 1 : undefined;
+}
+async function itermTab(pid, readEnv) {
+    const env = await readEnv(pid);
+    return itermTabFromSessionId(env?.ITERM_SESSION_ID);
+}
+/** Read a process's env (best-effort): /proc on Linux, `ps eww` on macOS. */
+async function readClientEnv(pid) {
+    if (process.platform === 'linux') {
+        try {
+            const buf = await readFile(`/proc/${pid}/environ`, 'utf8');
+            const env = {};
+            for (const pair of buf.split('\0')) {
+                const eq = pair.indexOf('=');
+                if (eq > 0)
+                    env[pair.slice(0, eq)] = pair.slice(eq + 1);
+            }
+            return env;
+        }
+        catch {
+            return undefined;
+        }
+    }
+    if (process.platform === 'darwin') {
+        try {
+            const { stdout } = await execFileAsync('ps', ['eww', '-p', String(pid), '-o', 'command='], {
+                encoding: 'utf8',
+                maxBuffer: 1024 * 1024,
+            });
+            // ITERM_SESSION_ID is a single token (no spaces): grab it out of the flat line.
+            const m = stdout.match(/(?:^|\s)ITERM_SESSION_ID=(\S+)/);
+            return m ? { ITERM_SESSION_ID: m[1] } : {};
+        }
+        catch {
+            return undefined;
+        }
+    }
+    return undefined;
+}
+/**
+ * VS Code editor-tab index for a session, from the extension's live-terminals.json
+ * (`tabIndex` per entry — the DATA CONTRACT with the extension teammate). Read
+ * directly (not via active.ts's readLiveTerminals, which strips tabIndex).
+ */
+function tabIndexFromLiveTerminals(sessionId) {
+    if (!sessionId)
+        return undefined;
+    let parsed;
+    try {
+        parsed = JSON.parse(fs.readFileSync(path.join(getTerminalsDir(), 'live-terminals.json'), 'utf8'));
+    }
+    catch {
+        return undefined;
+    }
+    if (!parsed || typeof parsed !== 'object')
+        return undefined;
+    for (const slice of Object.values(parsed)) {
+        for (const e of (slice?.entries ?? [])) {
+            if (e?.sessionId === sessionId && typeof e.tabIndex === 'number')
+                return e.tabIndex;
+        }
+    }
+    return undefined;
+}

package/dist/lib/ssh-tunnel.d.ts

@@ -47,7 +47,7 @@ export declare function startSSHTunnel(user: string, host: string, localPort: nu
 export declare const REMOTE_HELPER_PORT = 8765;
 /** Task Scheduler task name for the daemon. Stable so setup/stop pair up. */
 export declare const REMOTE_TASK_NAME = "AgentsComputerHelper";
-/** Basename of the cross-published exe under packages/computer-helper-win/dist. */
+/** Basename of the cross-published exe under native/computer-win/dist. */
 export declare const WIN_HELPER_EXE = "computer-helper-win.exe";
 /**
  * Locate the cross-published Windows daemon exe. Only the local build output is

package/dist/lib/ssh-tunnel.js

@@ -86,7 +86,7 @@ export function startSSHTunnel(user, host, localPort, remotePort, opts = {}) {
 export const REMOTE_HELPER_PORT = 8765;
 /** Task Scheduler task name for the daemon. Stable so setup/stop pair up. */
 export const REMOTE_TASK_NAME = 'AgentsComputerHelper';
-/** Basename of the cross-published exe under packages/computer-helper-win/dist. */
+/** Basename of the cross-published exe under native/computer-win/dist. */
 export const WIN_HELPER_EXE = 'computer-helper-win.exe';
 /**
  * Locate the cross-published Windows daemon exe. Only the local build output is
@@ -95,8 +95,8 @@ export const WIN_HELPER_EXE = 'computer-helper-win.exe';
 export function resolveWinHelperExe() {
     const here = path.dirname(fileURLToPath(import.meta.url));
     const candidates = [
-        // Running from the agents-cli checkout (src/lib -> repo root).
-        path.resolve(here, '..', '..', 'packages', 'computer-helper-win', 'dist', WIN_HELPER_EXE),
+        // Running from the agents-cli checkout. apps/cli/dist/lib -> repo root (4 up) -> native/computer-win.
+        path.resolve(here, '..', '..', '..', '..', 'native', 'computer-win', 'dist', WIN_HELPER_EXE),
         // Bundled with the npm package (dist/lib -> package root).
         path.resolve(here, '..', 'computer-helper-win', WIN_HELPER_EXE),
     ];

package/dist/lib/tmux/session.d.ts

@@ -22,6 +22,13 @@ export interface SessionMeta {
     source: 'cli' | 'extension' | 'teams' | 'external';
     /** Free-form labels callers can stamp (e.g. `{ agent: 'claude', vscodePid: 1234 }`). */
     labels?: Record<string, string>;
+    /**
+     * The first pane's id (`%N`) captured at creation. The exact send-keys /
+     * attach handle for the agent that runs in this session — recorded so
+     * `agents sessions --active` and the spawn-wrap path (src/lib/exec.ts) don't
+     * have to re-query it. Absent for pre-existing/`attach-existing` sessions.
+     */
+    pane?: string;
 }
 export interface CreateSessionOptions {
     name: string;
@@ -80,6 +87,45 @@ export declare function killAll(socket?: string): Promise<number>;
  * failure (tmux gone, foreign socket) so callers fall back to the raw pane id.
  */
 export declare function mapPanesToTargets(socket?: string): Promise<Map<string, string>>;
+/** One tmux client attached to the shared server. */
+export interface TmuxClient {
+    /** Controlling TTY of the terminal running `tmux attach` (e.g. '/dev/ttys004'). */
+    tty: string;
+    /** PID of the `tmux attach` client process — the leaf whose ancestry names the host app. */
+    pid: number;
+    /** The `session:window.pane` the client is currently displaying. */
+    target: string;
+}
+/**
+ * List every client attached to the shared server, with the terminal PID and
+ * the session/window/pane it's viewing. This is how "viewing in <app> tab N"
+ * resolves: a client's `pid` walks the process ancestry to name the host app,
+ * and its `target` says which session it's attached to. Best-effort — returns
+ * an empty list on any failure (no server, foreign socket) so the renderer
+ * degrades to "detached".
+ */
+export declare function listClients(socket?: string): Promise<TmuxClient[]>;
+/** A dead pane's exit status, read from tmux while the pane lingers under remain-on-exit. */
+export interface PaneExit {
+    /** True once the process that ran in the pane has exited (pane is dead). */
+    dead: boolean;
+    /** Exit status of the dead pane's process, when tmux reports it. */
+    status?: number;
+}
+/**
+ * Read whether a pane's process has exited and, if so, its exit status. Used by
+ * the spawn-wrap path to recover the wrapped agent's exit code after the attach
+ * client returns. Returns `{ dead: false }` when tmux can't answer (session gone,
+ * pane missing) so the caller treats an unreadable pane as "still alive / detach".
+ */
+export declare function paneExitStatus(pane: string, socket?: string): Promise<PaneExit>;
+/**
+ * Bind a per-session hook. Used by the spawn-wrap path to install a `pane-died`
+ * hook that detaches the attach client the instant the wrapped agent exits (the
+ * global `remain-on-exit on` otherwise leaves the client staring at a dead pane).
+ * Best-effort — a failed hook just means the user Ctrl-b d's out manually.
+ */
+export declare function setSessionHook(name: string, hook: string, command: string, socket?: string): Promise<void>;
 /**
  * List live sessions on the socket. Reconciles meta JSONs against tmux's view:
  *  - tmux session with no meta → returned without `meta` (external session)

package/dist/lib/tmux/session.js

@@ -76,7 +76,9 @@ export async function createSession(opts) {
     // exit the server, and the follow-up `set-option` would race with "no
     // server running". Server-wide (`-g`) is applied in the same tmux
     // invocation as new-session so they share one server lifetime.
-    const args = ['set-option', '-g', 'remain-on-exit', 'on', ';', 'new-session', '-d', '-s', opts.name];
+    // `-P -F '#{pane_id}'` prints the new session's first pane id on stdout so we
+    // can record the exact `%N` handle without a follow-up `list-panes`.
+    const args = ['set-option', '-g', 'remain-on-exit', 'on', ';', 'new-session', '-d', '-s', opts.name, '-P', '-F', '#{pane_id}'];
     if (opts.width)
         args.push('-x', String(opts.width));
     if (opts.height)
@@ -88,7 +90,9 @@ export async function createSession(opts) {
     if (opts.cmd) {
         args.push('--', 'sh', '-c', opts.cmd);
     }
-    await runTmux({ socket, args, env: opts.env });
+    const res = await runTmux({ socket, args, env: opts.env });
+    // Only the new-session command in the `;`-chained invocation emits output.
+    const pane = /^%\d+$/.test(res.stdout.trim()) ? res.stdout.trim() : undefined;
     const meta = {
         name: opts.name,
         socket,
@@ -97,6 +101,7 @@ export async function createSession(opts) {
         cwd: opts.cwd,
         source: opts.source ?? 'cli',
         labels: opts.labels,
+        pane,
     };
     writeSessionMeta(meta);
     return meta;
@@ -187,6 +192,83 @@ export async function mapPanesToTargets(socket) {
     }
     return out;
 }
+/**
+ * List every client attached to the shared server, with the terminal PID and
+ * the session/window/pane it's viewing. This is how "viewing in <app> tab N"
+ * resolves: a client's `pid` walks the process ancestry to name the host app,
+ * and its `target` says which session it's attached to. Best-effort — returns
+ * an empty list on any failure (no server, foreign socket) so the renderer
+ * degrades to "detached".
+ */
+export async function listClients(socket) {
+    let res;
+    try {
+        res = await runTmux({
+            socket,
+            args: ['list-clients', '-F', '#{client_tty} #{client_pid} #{session_name}:#{window_index}.#{pane_index}'],
+            throwOnError: false,
+        });
+    }
+    catch {
+        return [];
+    }
+    if (res.code !== 0)
+        return [];
+    const out = [];
+    for (const line of res.stdout.split('\n')) {
+        const t = line.trim();
+        if (!t)
+            continue;
+        const sp1 = t.indexOf(' ');
+        if (sp1 < 0)
+            continue;
+        const sp2 = t.indexOf(' ', sp1 + 1);
+        if (sp2 < 0)
+            continue;
+        const tty = t.slice(0, sp1);
+        const pid = parseInt(t.slice(sp1 + 1, sp2), 10);
+        const target = t.slice(sp2 + 1).trim();
+        if (!Number.isFinite(pid) || !target)
+            continue;
+        out.push({ tty, pid, target });
+    }
+    return out;
+}
+/**
+ * Read whether a pane's process has exited and, if so, its exit status. Used by
+ * the spawn-wrap path to recover the wrapped agent's exit code after the attach
+ * client returns. Returns `{ dead: false }` when tmux can't answer (session gone,
+ * pane missing) so the caller treats an unreadable pane as "still alive / detach".
+ */
+export async function paneExitStatus(pane, socket) {
+    let res;
+    try {
+        res = await runTmux({
+            socket,
+            args: ['display-message', '-pt', pane, '-p', '#{pane_dead} #{pane_dead_status}'],
+            throwOnError: false,
+        });
+    }
+    catch {
+        return { dead: false };
+    }
+    if (res.code !== 0)
+        return { dead: false };
+    const [deadRaw, statusRaw] = res.stdout.trim().split(/\s+/);
+    const status = statusRaw !== undefined && statusRaw !== '' ? parseInt(statusRaw, 10) : undefined;
+    return { dead: deadRaw === '1', status: Number.isFinite(status) ? status : undefined };
+}
+/**
+ * Bind a per-session hook. Used by the spawn-wrap path to install a `pane-died`
+ * hook that detaches the attach client the instant the wrapped agent exits (the
+ * global `remain-on-exit on` otherwise leaves the client staring at a dead pane).
+ * Best-effort — a failed hook just means the user Ctrl-b d's out manually.
+ */
+export async function setSessionHook(name, hook, command, socket) {
+    assertValidSessionName(name);
+    const sock = socket ?? getDefaultSocketPath();
+    await runTmux({ socket: sock, args: ['set-hook', '-t', name, hook, command], throwOnError: false }).catch(() => { });
+}
 /**
  * List live sessions on the socket. Reconciles meta JSONs against tmux's view:
  *  - tmux session with no meta → returned without `meta` (external session)

package/dist/lib/usage.d.ts

@@ -88,9 +88,11 @@ export declare function getUsageInfoForIdentity(input: UsageIdentityInput): Prom
 export declare function formatUsageSummary(plan: string | null, snapshot: UsageSnapshot | null, planWidth?: number): string;
 /**
  * Derive an account's real throttle state from its live usage windows — the
- * same signal `agents usage` shows and balanced rotation trusts
- * (`getRoutingUsedPercent` in rotate.ts). A window at 100% utilization means
- * the account is throttled until that window resets.
+ * single signal both the `agents view` badge and run-rotation eligibility share
+ * (`hasUsageAvailable` in rotate.ts treats a `rate_limited` verdict here as
+ * ineligible). A window at 100% utilization means the account is throttled until
+ * that window resets. Rotation *weighting* still ranks eligible accounts by
+ * weekly headroom (`getRoutingUsedPercent`); this function is the yes/no gate.
  *
  * Returns `null` when there is no snapshot, so callers render no badge rather
  * than a misleading one. This deliberately never consults

package/dist/lib/usage.js

@@ -212,9 +212,11 @@ export function formatUsageSummary(plan, snapshot, planWidth = 3) {
 }
 /**
  * Derive an account's real throttle state from its live usage windows — the
- * same signal `agents usage` shows and balanced rotation trusts
- * (`getRoutingUsedPercent` in rotate.ts). A window at 100% utilization means
- * the account is throttled until that window resets.
+ * single signal both the `agents view` badge and run-rotation eligibility share
+ * (`hasUsageAvailable` in rotate.ts treats a `rate_limited` verdict here as
+ * ineligible). A window at 100% utilization means the account is throttled until
+ * that window resets. Rotation *weighting* still ranks eligible accounts by
+ * weekly headroom (`getRoutingUsedPercent`); this function is the yes/no gate.
  *
  * Returns `null` when there is no snapshot, so callers render no badge rather
  * than a misleading one. This deliberately never consults

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@phnx-labs/agents-cli",
-  "version": "1.20.41",
+  "version": "1.20.43",
   "description": "One CLI for all your AI coding agents - versions, config, cloud dispatch, sessions, and teams (now with first-class Grok Build CLI support)",
   "type": "module",
   "main": "dist/index.js",