@phnx-labs/agents-cli 1.22.49 → 1.22.51

package/dist/lib/accounting/account-pool.js

@@ -0,0 +1,33 @@
+import { providerAuthenticatesHarness } from '../account-provider-registry.js';
+/**
+ * Which provider accounts can authenticate `agent`. An account is a candidate for
+ * harness H only when its provider adapter has an `envFor(H, kind)` mapping
+ * (`providerAuthenticatesHarness`, the same check the account UI uses) — so a
+ * Cursor key never enters Claude's pool and a Claude setup-token never enters
+ * Codex's. This is registry-driven, no per-harness `else if`: a harness gets a
+ * provider-account pool exactly when the adapter table maps a provider to it —
+ * today claude, codex, grok, cursor, opencode (plus gemini/antigravity). A harness
+ * with only a native OAuth login and no provider adapter — kimi — returns `[]`
+ * here and keeps balancing its native logins only.
+ *
+ * `accountKey` is synthetic here (`${agent}:name=${name}`) — a stable per-account
+ * key so balancing can include it immediately; the real agent-scoped identity
+ * (email / org uuid) is backfilled by identity capture and replaces it. `email`
+ * is null until then, which routes the account as usage-unverified but still a
+ * candidate, never excluded.
+ */
+export function registryPoolCandidates(records, agent) {
+    const out = [];
+    for (const r of records) {
+        if (!providerAuthenticatesHarness(r.provider, r.auth, agent))
+            continue;
+        out.push({
+            accountKey: `${agent}:name=${r.name}`,
+            email: null,
+            name: r.name,
+            provider: r.provider,
+            auth: r.auth,
+        });
+    }
+    return out;
+}

package/dist/lib/accounting/capacity.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Remaining-capacity weighting for account selection — a pure, dependency-free
+ * primitive shared by the version-home router (`rotate.ts`) and the account pool
+ * (`account-pool.ts`). Kept in its own module so either can import it without
+ * dragging in the heavy usage/secrets graph.
+ */
+/**
+ * How far from its projected cap an account must be to keep its FULL headroom
+ * weight. Inside this horizon the weight is scaled down linearly toward the
+ * floor, so an account racing toward its 5h cap loses priority before it maxes.
+ */
+export declare const PROJECTION_HORIZON_MIN = 30;
+/**
+ * Weight one candidate by remaining routing capacity, deprioritized by how soon
+ * it is projected to cap. The base is weekly headroom (`max(1, 100 - used)`);
+ * an account with no live snapshot is treated as full-capacity (100) since there
+ * is no signal to deprioritize it. `minutesToLimit` (the daemon's burn-rate
+ * projection on the 5h session window) then scales that base: >= horizon (or
+ * unknown) keeps full weight, and closer-to-cap scales toward the floor of 1 —
+ * so a launch avoids an account projected to cap soon, not just a 100%-maxed
+ * one. Pure + exported so the deprioritization is unit-tested directly (a
+ * weighted-random draw is not).
+ */
+export declare function capacityWeight(usedPercent: number | null, minutesToLimit: number | null): number;

package/dist/lib/accounting/capacity.js

@@ -0,0 +1,30 @@
+/**
+ * Remaining-capacity weighting for account selection — a pure, dependency-free
+ * primitive shared by the version-home router (`rotate.ts`) and the account pool
+ * (`account-pool.ts`). Kept in its own module so either can import it without
+ * dragging in the heavy usage/secrets graph.
+ */
+/**
+ * How far from its projected cap an account must be to keep its FULL headroom
+ * weight. Inside this horizon the weight is scaled down linearly toward the
+ * floor, so an account racing toward its 5h cap loses priority before it maxes.
+ */
+export const PROJECTION_HORIZON_MIN = 30;
+/**
+ * Weight one candidate by remaining routing capacity, deprioritized by how soon
+ * it is projected to cap. The base is weekly headroom (`max(1, 100 - used)`);
+ * an account with no live snapshot is treated as full-capacity (100) since there
+ * is no signal to deprioritize it. `minutesToLimit` (the daemon's burn-rate
+ * projection on the 5h session window) then scales that base: >= horizon (or
+ * unknown) keeps full weight, and closer-to-cap scales toward the floor of 1 —
+ * so a launch avoids an account projected to cap soon, not just a 100%-maxed
+ * one. Pure + exported so the deprioritization is unit-tested directly (a
+ * weighted-random draw is not).
+ */
+export function capacityWeight(usedPercent, minutesToLimit) {
+    const base = usedPercent === null ? 100 : Math.max(1, 100 - usedPercent);
+    if (minutesToLimit === null || !Number.isFinite(minutesToLimit))
+        return base;
+    const factor = Math.max(0, Math.min(1, minutesToLimit / PROJECTION_HORIZON_MIN));
+    return Math.max(1, base * factor);
+}

package/dist/lib/accounting/rotate.d.ts

@@ -6,6 +6,7 @@
  */
 import type { AgentId, RunStrategy } from '../types.js';
 import type { FallbackEntry } from '../exec.js';
+import { PROJECTION_HORIZON_MIN, capacityWeight } from './capacity.js';
 import { type AccountInfo, type CredentialPresence } from '../agents.js';
 import { type UsageSnapshot } from './usage.js';
 import { type AuthVerdict } from '../auth-health.js';
@@ -49,6 +50,15 @@ export interface RotateCandidate {
      */
     authVerdict: AuthVerdict | null;
     lastActive: Date | null;
+    /**
+     * Set only for a candidate that comes from a provider account bundle rather
+     * than a native version-home login (RUSH-3182): the account name to inject via
+     * the `--account` spawn path (`resolveSpawnAccount` → `accountEnv`). Undefined
+     * for a native login, whose credential already lives in `version`'s home. The
+     * run path routes on this so a balanced pick of a setup-token / API-key account
+     * authenticates through the existing provider-account injection.
+     */
+    providerAccount?: string;
 }
 export interface RotateResult {
     /** The version picked for this run. */
@@ -212,24 +222,7 @@ export declare function checkRunAccountReadiness(agent: AgentId, version: string
  * version so behavior stays predictable.
  */
 export declare function pickBalancedCandidate(candidates: RotateCandidate[], nowMs?: number): RotateResult | null;
-/**
- * How far from its projected cap an account must be to keep its FULL headroom
- * weight. Inside this horizon the weight is scaled down linearly toward the
- * floor, so an account racing toward its 5h cap loses priority before it maxes.
- */
-export declare const PROJECTION_HORIZON_MIN = 30;
-/**
- * Weight one candidate by remaining routing capacity, deprioritized by how soon
- * it is projected to cap. The base is weekly headroom (`max(1, 100 - used)`);
- * an account with no live snapshot is treated as full-capacity (100) since there
- * is no signal to deprioritize it. `minutesToLimit` (the daemon's burn-rate
- * projection on the 5h session window) then scales that base: >= horizon (or
- * unknown) keeps full weight, and closer-to-cap scales toward the floor of 1 —
- * so a launch avoids an account projected to cap soon, not just a 100%-maxed
- * one. Pure + exported so the deprioritization is unit-tested directly (a
- * weighted-random draw is not).
- */
-export declare function capacityWeight(usedPercent: number | null, minutesToLimit: number | null): number;
+export { PROJECTION_HORIZON_MIN, capacityWeight };
 /**
  * Pick an available candidate. Prefers the configured pinned version when that
  * version has usage available; otherwise routes to the candidate with the most

package/dist/lib/accounting/rotate.js

@@ -6,6 +6,7 @@
  */
 import * as fs from 'fs';
 import * as path from 'path';
+import { PROJECTION_HORIZON_MIN, capacityWeight } from './capacity.js';
 import { accountDisplayLabel, getAccountInfo, credentialPresence, ALL_AGENT_IDS, } from '../agents.js';
 import { readMeta, writeMeta, getHelpersDir } from '../state.js';
 import { listInstalledVersions, getVersionHomePath, resolveVersion } from '../installations/versions.js';
@@ -365,30 +366,11 @@ function preferVerified(pool, nowMs, choose, narrowing = 'any-verified') {
         usageUnverified: !isUsageVerified(picked, nowMs),
     };
 }
-/**
- * How far from its projected cap an account must be to keep its FULL headroom
- * weight. Inside this horizon the weight is scaled down linearly toward the
- * floor, so an account racing toward its 5h cap loses priority before it maxes.
- */
-export const PROJECTION_HORIZON_MIN = 30;
-/**
- * Weight one candidate by remaining routing capacity, deprioritized by how soon
- * it is projected to cap. The base is weekly headroom (`max(1, 100 - used)`);
- * an account with no live snapshot is treated as full-capacity (100) since there
- * is no signal to deprioritize it. `minutesToLimit` (the daemon's burn-rate
- * projection on the 5h session window) then scales that base: >= horizon (or
- * unknown) keeps full weight, and closer-to-cap scales toward the floor of 1 —
- * so a launch avoids an account projected to cap soon, not just a 100%-maxed
- * one. Pure + exported so the deprioritization is unit-tested directly (a
- * weighted-random draw is not).
- */
-export function capacityWeight(usedPercent, minutesToLimit) {
-    const base = usedPercent === null ? 100 : Math.max(1, 100 - usedPercent);
-    if (minutesToLimit === null || !Number.isFinite(minutesToLimit))
-        return base;
-    const factor = Math.max(0, Math.min(1, minutesToLimit / PROJECTION_HORIZON_MIN));
-    return Math.max(1, base * factor);
-}
+// capacityWeight + PROJECTION_HORIZON_MIN moved to ./capacity.js (a pure,
+// dependency-free module the account pool can import without this file's heavy
+// graph). Imported at the top for internal use; re-exported here so existing
+// importers keep resolving them from rotate.
+export { PROJECTION_HORIZON_MIN, capacityWeight };
 /**
  * Pick one candidate from `sorted` using weights proportional to remaining
  * routing capacity (see {@link capacityWeight}). Floor each weight at 1 so a

package/dist/lib/claude-statusline.d.ts

@@ -1,4 +1,12 @@
 export declare const CLAUDE_STATUSLINE_COMMAND = "agents __claude-statusline";
+/**
+ * True when `command` re-invokes THIS status-line producer (our private
+ * `__claude-statusline` subcommand) under any binary name or path. Delegating to
+ * such a command is the fork bomb, so both the read side (renderDelegate) and the
+ * write side (installClaudeStatusLine) treat it as "not a real external
+ * producer" and never chain to it.
+ */
+export declare function isStatusLineSelfReference(command: string): boolean;
 interface ClaudeStatusLinePayload {
     cwd?: string;
     workspace?: {
@@ -20,6 +28,7 @@ interface ClaudeStatusLinePayload {
     };
 }
 export declare function ingestClaudeStatusLineUsage(payload: ClaudeStatusLinePayload, versionHome: string): boolean;
+export declare function renderDelegate(payload: string, versionHome: string): string;
 export declare function renderClaudeStatusLine(payload: ClaudeStatusLinePayload, host?: string, delegated?: string): string;
 export declare function runClaudeStatusLine(): Promise<number>;
 export declare function installClaudeStatusLine(versionHome: string): {

package/dist/lib/claude-statusline.js

@@ -7,6 +7,39 @@ import { atomicWriteFileSync } from './fs-atomic.js';
 import { mergeClaudeUsageCacheWindows } from './accounting/usage.js';
 export const CLAUDE_STATUSLINE_COMMAND = 'agents __claude-statusline';
 const DELEGATE_FILE = path.join('.agents', 'claude-statusline-delegate');
+// The private subcommand this feature runs. It is only ever invoked internally,
+// so ANY command that contains it — under any binary name or path (`agents`,
+// `agents-dev`, `ag`, an absolute path, a wrapper) — IS this status-line
+// producer, and delegating to it recurses without bound. Match the subcommand,
+// not the exact `agents __claude-statusline` string, or a delegate seeded with a
+// differently-named binary (e.g. `agents-dev __claude-statusline`) fork-bombs the
+// machine: each render spawns a copy that reads the same delegate and spawns
+// another, forever.
+const STATUSLINE_SUBCOMMAND = '__claude-statusline';
+// Set on the child env before spawning a delegate. If it is already present we
+// are ourselves running as someone's delegate, so we refuse to delegate again —
+// a hard depth-1 backstop that bounds the blast radius even if a self-reference
+// somehow slips past isStatusLineSelfReference(). One hop is the contract:
+// installClaudeStatusLine only ever preserves a single prior command.
+const DELEGATE_GUARD_ENV = 'AGENTS_CLAUDE_STATUSLINE_DELEGATED';
+// A hung or slow delegate must never pin a status-line render open — the render
+// is re-invoked on every refresh, so an unbounded delegate accumulates processes.
+const DELEGATE_TIMEOUT_MS = 5_000;
+/**
+ * True when `command` re-invokes THIS status-line producer (our private
+ * `__claude-statusline` subcommand) under any binary name or path. Delegating to
+ * such a command is the fork bomb, so both the read side (renderDelegate) and the
+ * write side (installClaudeStatusLine) treat it as "not a real external
+ * producer" and never chain to it.
+ */
+export function isStatusLineSelfReference(command) {
+    const trimmed = command.trim();
+    if (!trimmed)
+        return false;
+    if (trimmed === CLAUDE_STATUSLINE_COMMAND)
+        return true;
+    return new RegExp(`(^|\\s)${STATUSLINE_SUBCOMMAND}(\\s|$)`).test(trimmed);
+}
 function isRecord(value) {
     return typeof value === 'object' && value !== null && !Array.isArray(value);
 }
@@ -48,7 +81,10 @@ export function ingestClaudeStatusLineUsage(payload, versionHome) {
 function delegatePath(versionHome) {
     return path.join(versionHome, DELEGATE_FILE);
 }
-function renderDelegate(payload, versionHome) {
+export function renderDelegate(payload, versionHome) {
+    // Already running as a delegate hop — never spawn another. Hard recursion stop.
+    if (process.env[DELEGATE_GUARD_ENV])
+        return '';
     let command = '';
     try {
         command = fs.readFileSync(delegatePath(versionHome), 'utf8').trim();
@@ -56,13 +92,14 @@ function renderDelegate(payload, versionHome) {
     catch {
         return '';
     }
-    if (!command || command === CLAUDE_STATUSLINE_COMMAND)
+    if (!command || isStatusLineSelfReference(command))
         return '';
     const result = spawnSync(command, {
         shell: true,
         input: payload,
         encoding: 'utf8',
-        env: process.env,
+        env: { ...process.env, [DELEGATE_GUARD_ENV]: '1' },
+        timeout: DELEGATE_TIMEOUT_MS,
     });
     return result.status === 0 ? result.stdout.trim() : '';
 }
@@ -117,11 +154,15 @@ export function installClaudeStatusLine(versionHome) {
             : '';
         if (existing === CLAUDE_STATUSLINE_COMMAND)
             return { changed: false };
-        if (existing) {
+        if (existing && !isStatusLineSelfReference(existing)) {
+            // A genuine third-party status-line command → preserve it as a delegate.
             fs.mkdirSync(path.dirname(delegatePath(versionHome)), { recursive: true });
             atomicWriteFileSync(delegatePath(versionHome), `${existing}\n`);
         }
         else {
+            // Empty, or our own subcommand under a different binary name
+            // (`agents-dev __claude-statusline`, an absolute path, …). Saving that as a
+            // delegate is the fork bomb — never persist it. Drop any prior delegate.
             fs.rmSync(delegatePath(versionHome), { force: true });
         }
         settings.statusLine = {

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

@@ -59,11 +59,11 @@ export declare const WIN_HELPER_TOKEN_FILE = "helper-token";
  * the release-asset download (`ensureWinHelperExe`).
  */
 export declare function resolveWinHelperExe(): string | null;
-/** GitHub repo whose `v<version>` releases carry the exe as an asset. */
-export declare const WIN_HELPER_RELEASE_REPO = "phnx-labs/agents-cli";
+/** GitHub repo whose `computer-win/v<version>` releases carry the exe as an asset. */
+export declare const WIN_HELPER_RELEASE_REPO = "phnx-labs/agi-cli";
 /** Cache dir for downloaded helper exes, one subdir per release tag. */
 export declare function winHelperCacheDir(version: string): string;
-/** Release-asset URLs for the exe + its checksum at one exact `v<version>` tag. */
+/** Release-asset URLs for the exe + its checksum at one exact `computer-win/v<version>` tag. */
 export declare function winHelperAssetUrls(version: string): {
     exe: string;
     sha256: string;
@@ -73,10 +73,11 @@ export declare function winHelperAssetUrls(version: string): {
  * a bare hex digest. Throws on anything that does not lead with 64 hex chars.
  */
 /**
- * Download the exe release asset for this CLI version, verify its sha256
+ * Download the exe release asset for this HELPER version, verify its sha256
  * against the published `.sha256` asset, and cache it under the agents cache
- * dir. Only the exact `v<version>` tag is consulted — a missing asset is a
- * hard error naming that tag, never a silent fallback to another release.
+ * dir. Only the exact `computer-win/v<version>` tag is consulted — a missing
+ * asset is a hard error naming that tag, never a silent fallback to another
+ * release. The version is the HELPER's own, not the CLI's.
  */
 export declare function downloadWinHelperExe(version: string): Promise<string>;
 /**

package/dist/lib/computer/ssh-tunnel.js

@@ -127,13 +127,13 @@ export function resolveWinHelperExe() {
     }
     return null;
 }
-/** GitHub repo whose `v<version>` releases carry the exe as an asset. */
-export const WIN_HELPER_RELEASE_REPO = 'phnx-labs/agents-cli';
+/** GitHub repo whose `computer-win/v<version>` releases carry the exe as an asset. */
+export const WIN_HELPER_RELEASE_REPO = 'phnx-labs/agi-cli';
 /** Cache dir for downloaded helper exes, one subdir per release tag. */
 export function winHelperCacheDir(version) {
     return path.join(getCacheDir(), 'computer', 'win-helper', `v${version}`);
 }
-/** Release-asset URLs for the exe + its checksum at one exact `v<version>` tag. */
+/** Release-asset URLs for the exe + its checksum at one exact `computer-win/v<version>` tag. */
 export function winHelperAssetUrls(version) {
     // The helper's OWN tag, not the CLI's. This exe is not an .app bundle so it
     // cannot share helper-download.ts's zip/codesign machinery, but it had the
@@ -148,19 +148,24 @@ export function winHelperAssetUrls(version) {
  * a bare hex digest. Throws on anything that does not lead with 64 hex chars.
  */
 /**
- * Download the exe release asset for this CLI version, verify its sha256
+ * Download the exe release asset for this HELPER version, verify its sha256
  * against the published `.sha256` asset, and cache it under the agents cache
- * dir. Only the exact `v<version>` tag is consulted — a missing asset is a
- * hard error naming that tag, never a silent fallback to another release.
+ * dir. Only the exact `computer-win/v<version>` tag is consulted — a missing
+ * asset is a hard error naming that tag, never a silent fallback to another
+ * release. The version is the HELPER's own, not the CLI's.
  */
 export async function downloadWinHelperExe(version) {
     const cached = path.join(winHelperCacheDir(version), WIN_HELPER_EXE);
     if (fs.existsSync(cached))
         return cached;
-    const tag = `v${version}`;
+    // The SAME tag the URL is built from. This said `v${version}` — the CLI's tag
+    // shape — while winHelperAssetUrls uses helperTag('computer-win', ...), so a
+    // missing asset sent you looking for a tag that does not exist. The mac path
+    // had this fixed already; the Windows path was left behind by the tag split.
+    const tag = helperTag('computer-win', version);
     const { exe: exeUrl, sha256: shaUrl } = winHelperAssetUrls(version);
     const missing = (status, url) => new Error(`no ${WIN_HELPER_EXE} release asset for tag ${tag} (HTTP ${status} on ${url}). ` +
-        `The Windows helper ships as a GitHub release asset per tagged CLI version; ` +
+        `The Windows helper ships as a GitHub release asset on its own helper tag; ` +
         `from a repo checkout you can build it locally instead: bash scripts/build-win.sh`);
     // Checksum first: it is tiny and 404s fast when the tag has no assets.
     const shaRes = await fetch(shaUrl, { signal: AbortSignal.timeout(30_000) });

package/dist/lib/config-keys.d.ts

@@ -28,11 +28,12 @@ export interface ParsedAutoConfigKey {
     scope: 'auto';
     property: 'pool';
 }
-/** A device-scope browser key (self or peer): the profile agents drive, or the
- *  browser that shows the user a page. */
+/** A browser key: the profile agents drive or the browser that shows the user a
+ *  page (both device-scope, self or peer), or `device` — the user-scope fleet
+ *  hub every box drives by default, which is central and never peer-targeted. */
 export interface ParsedBrowserConfigKey {
     scope: 'browser';
-    property: 'profile' | 'viewer';
+    property: 'profile' | 'viewer' | 'device';
     device?: string;
 }
 export interface ParsedProjectConfigKey {

package/dist/lib/config-keys.js

@@ -88,6 +88,9 @@ export function parseConfigKey(key) {
     if (raw === 'browser.viewer') {
         return { scope: 'browser', property: 'viewer' };
     }
+    if (raw === 'browser.device') {
+        return { scope: 'browser', property: 'device' };
+    }
     if (raw === 'project.root') {
         return { scope: 'project', property: 'root' };
     }
@@ -110,7 +113,7 @@ export function parseConfigKey(key) {
         throw new Error(`Invalid auto config key '${key}'. Use auto.pool.`);
     }
     if (raw.startsWith('browser.')) {
-        throw new Error(`Invalid browser config key '${key}'. Use browser.profile or browser.viewer.`);
+        throw new Error(`Invalid browser config key '${key}'. Use browser.profile, browser.viewer, or browser.device.`);
     }
     if (raw.startsWith('project.')) {
         throw new Error(`Invalid project config key '${key}'. Use project.root.`);
@@ -149,7 +152,7 @@ export function listKnownConfigKeys() {
     for (const tier of MODEL_TIERS) {
         keys.push(`run.<agent@version>.tier.${tier}`);
     }
-    keys.push('interactive.host', 'auto.pool', 'browser.profile', 'browser.viewer', 'project.root');
+    keys.push('interactive.host', 'auto.pool', 'browser.profile', 'browser.viewer', 'browser.device', 'project.root');
     for (const prop of DEVICE_CONFIG_PROPERTIES) {
         keys.push(`devices.<name>.${prop}`);
     }
@@ -202,6 +205,10 @@ export function configKeyStorageHint(parsed) {
         case 'auto':
             return 'config.autoPool';
         case 'browser': {
+            if (parsed.property === 'device') {
+                // User scope: one value in the central agents.yaml that syncs fleet-wide.
+                return 'config.defaultBrowserDevice (central agents.yaml; syncs fleet-wide)';
+            }
             const yamlKey = parsed.property === 'viewer' ? 'browserViewer' : 'defaultBrowserProfile';
             return parsed.device
                 ? `devices/${parsed.device}/agents.yaml config.${yamlKey}`

package/dist/lib/device-config.js

@@ -94,6 +94,29 @@ export const CONFIG_KEYS = [
         type: 'string',
         description: 'Browser profile `agents browser start` resolves to without --profile (set via `agents browser use`).',
     },
+    {
+        name: 'browser.device',
+        yamlKey: 'defaultBrowserDevice',
+        // user scope, so a SINGLE value in the central agents.yaml syncs to every box:
+        // the fleet's browser hub. A worker with this set forwards its browser drives
+        // to the hub (as if `--device <hub>` was passed) with no per-command flag, so
+        // every agent shares the hub's one logged-in browser. The hub names itself, so
+        // there it resolves to a self-host and runs locally — which is why one synced
+        // value is safe. Unset = drive this box's own browser (today's behavior).
+        scope: 'user',
+        type: 'string',
+        description: 'Fleet browser hub: the device whose browser `agents browser` drive verbs target by default, with no --device. ' +
+            'The hub itself runs locally; every other box forwards to it. Unset = each box drives its own browser.',
+        validate: (v) => {
+            try {
+                assertValidDeviceName(v);
+                return null;
+            }
+            catch (err) {
+                return err?.message ?? String(err);
+            }
+        },
+    },
     {
         name: 'agents.max-concurrent',
         yamlKey: 'maxAgents',

package/dist/lib/factory/snapshot.d.ts

@@ -13,7 +13,7 @@ export declare const FACTORY_PROJECTS: readonly [{
     readonly repo: "phnx-labs/rush-cli";
 }, {
     readonly name: "Agents CLI";
-    readonly repo: "phnx-labs/agents-cli";
+    readonly repo: "phnx-labs/agi-cli";
 }, {
     readonly name: "Linear CLI";
     readonly repo: "phnx-labs/linear-cli";

package/dist/lib/factory/snapshot.js

@@ -25,7 +25,7 @@ export const FACTORY_PROJECTS = [
     { name: 'Prix', repo: 'phnx-labs/prix' },
     { name: 'Rush App', repo: 'phnx-labs/rush' },
     { name: 'Rush CLI', repo: 'phnx-labs/rush-cli' },
-    { name: 'Agents CLI', repo: 'phnx-labs/agents-cli' },
+    { name: 'Agents CLI', repo: 'phnx-labs/agi-cli' },
     { name: 'Linear CLI', repo: 'phnx-labs/linear-cli' },
 ];
 const defaults = () => ({

package/dist/lib/helper-download.d.ts

@@ -16,8 +16,18 @@
  * lands for both helpers at once.
  */
 import { type HelperName } from './helper-versions.js';
-/** GitHub repo whose `v<version>` releases carry the helper assets. */
-export declare const HELPER_RELEASE_REPO = "phnx-labs/agents-cli";
+/**
+ * GitHub repo whose `<helper>/v<version>` releases carry the helper assets.
+ *
+ * This is the SLUG, which is not the npm package name: the package is still
+ * `@phnx-labs/agents-cli`, but the repository was renamed to `agi-cli`. The old
+ * slug kept working only because GitHub redirects a renamed repo, which is a
+ * poor thing to hang signed-binary delivery on — a redirect is one re-created
+ * repo away from resolving somewhere else. What actually protects the download
+ * is the sha256 + codesign + designated-requirement + Team ID verification
+ * below; this just stops relying on the redirect.
+ */
+export declare const HELPER_RELEASE_REPO = "phnx-labs/agi-cli";
 /** Apple Developer ID Team every helper must be signed by ("Developer ID
  *  Application: Muqit Nawaz"). Defense in depth on top of `spctl` notarization. */
 export declare const EXPECTED_TEAM_ID = "2HTP252L87";

package/dist/lib/helper-download.js

@@ -23,8 +23,18 @@ import { pipeline } from 'node:stream/promises';
 import { getCacheDir } from './state.js';
 import { parseSha256Asset, sha256File } from './sha256-asset.js';
 import { helperTag } from './helper-versions.js';
-/** GitHub repo whose `v<version>` releases carry the helper assets. */
-export const HELPER_RELEASE_REPO = 'phnx-labs/agents-cli';
+/**
+ * GitHub repo whose `<helper>/v<version>` releases carry the helper assets.
+ *
+ * This is the SLUG, which is not the npm package name: the package is still
+ * `@phnx-labs/agents-cli`, but the repository was renamed to `agi-cli`. The old
+ * slug kept working only because GitHub redirects a renamed repo, which is a
+ * poor thing to hang signed-binary delivery on — a redirect is one re-created
+ * repo away from resolving somewhere else. What actually protects the download
+ * is the sha256 + codesign + designated-requirement + Team ID verification
+ * below; this just stops relying on the redirect.
+ */
+export const HELPER_RELEASE_REPO = 'phnx-labs/agi-cli';
 /** Apple Developer ID Team every helper must be signed by ("Developer ID
  *  Application: Muqit Nawaz"). Defense in depth on top of `spctl` notarization. */
 export const EXPECTED_TEAM_ID = '2HTP252L87';

package/dist/lib/installations/migrate.js

@@ -298,7 +298,7 @@ function foldUserHooksYamlIntoAgentsYaml() {
     meta.hooks = merged;
     const header = `# agents-cli metadata
 # Auto-generated - do not edit manually
-# https://github.com/phnx-labs/agents-cli
+# https://github.com/phnx-labs/agi-cli
 
 `;
     try {
@@ -414,7 +414,7 @@ function foldBrowserProfilesIntoAgentsYaml() {
     meta.browser = merged;
     const header = `# agents-cli metadata
 # Auto-generated - do not edit manually
-# https://github.com/phnx-labs/agents-cli
+# https://github.com/phnx-labs/agi-cli
 
 `;
     try {
@@ -1641,7 +1641,7 @@ function migrateVersionResourcesToPatterns() {
         }
     }
     if (changed) {
-        const META_HEADER = '# agents-cli metadata\n# Auto-generated - do not edit manually\n# https://github.com/phnx-labs/agents-cli\n# yaml-language-server: $schema=https://raw.githubusercontent.com/phnx-labs/agents-cli/main/cli/schema/agents-yaml.schema.json\n\n';
+        const META_HEADER = '# agents-cli metadata\n# Auto-generated - do not edit manually\n# https://github.com/phnx-labs/agi-cli\n# yaml-language-server: $schema=https://raw.githubusercontent.com/phnx-labs/agi-cli/main/cli/schema/agents-yaml.schema.json\n\n';
         fs.writeFileSync(metaFile, META_HEADER + yaml.stringify(meta), 'utf-8');
         console.error('Migrated agents.yaml versions: entries to pattern format');
     }
@@ -1668,7 +1668,7 @@ function migrateSplitDeviceLocalMeta() {
     const agents = meta.agents;
     const versions = meta.versions;
     const hasLocal = (!!agents && Object.keys(agents).length > 0) || (!!versions && Object.keys(versions).length > 0);
-    const HEADER = '# agents-cli metadata\n# Auto-generated - do not edit manually\n# https://github.com/phnx-labs/agents-cli\n\n';
+    const HEADER = '# agents-cli metadata\n# Auto-generated - do not edit manually\n# https://github.com/phnx-labs/agi-cli\n\n';
     // Only rewrite central when it actually carries machine-local fields — a
     // machine whose agents.yaml is already portable-only is left untouched.
     if (hasLocal) {

package/dist/lib/installations/store.js

@@ -269,10 +269,13 @@ export function getBinaryPath(agent, version) {
     const agentConfig = AGENTS[agent];
     if (agent === 'grok') {
         const grokDownloads = path.join(getVersionHomePath(agent, version), '.grok', 'downloads');
-        // Best effort: first matching file for this version
+        // The directory token is the stable installation/account label. A
+        // self-updating slot may carry a newer vendor release, whose binary keeps
+        // the release in its filename; resolve through the frozen install record.
+        const releaseVersion = readInstallation(agent, version)?.releaseVersion ?? version;
         try {
             const entries = fs.readdirSync(grokDownloads);
-            const match = entries.find((e) => e.includes(version) && e.startsWith('grok-'));
+            const match = entries.find((e) => e.includes(releaseVersion) && e.startsWith('grok-'));
             if (match)
                 return path.join(grokDownloads, match);
         }
@@ -280,7 +283,7 @@ export function getBinaryPath(agent, version) {
         const fallback = resolveGrokFallbackBinary(grokDownloads);
         if (fallback)
             return fallback;
-        return path.join(grokDownloads, `grok-${version}`);
+        return path.join(grokDownloads, `grok-${releaseVersion}`);
     }
     if (agent === 'droid') {
         // Factory.ai's installer drops a standalone native binary (no npm package,