@phnx-labs/agents-cli 1.22.119 → 1.22.121

package/dist/lib/claude-account-token.js

@@ -5,45 +5,11 @@ import { bundleBackendSync, bundleExistsSync, isSecretsClientError, readAndResol
 import { AUTH_STORE_ALIAS, ReservedBundleWrongBackendError, assertReservedAuthBackend, isReservedBundleBackendError, isReservedStoreName, } from './reserved-stores.js';
 import { ensureSlot, recordSlot } from './accounts/slots.js';
 import { harnessWorkerKinds } from './harness-auth-capabilities.js';
-/**
- * Reserved FILE-BASED secrets bundle holding long-lived, non-rotating Claude
- * setup-tokens. Usage/probe reads authenticate with these instead of Claude
- * Code's ACL-bound login item, so they never pop Touch ID. Keyed strictly
- * per-account (`CLAUDE_CODE_OAUTH_TOKEN_<slug>` from the account email) — never a
- * bare key, so one account's token can't be misapplied to another in a
- * multi-account fleet.
- */
-/** Alias of the reserved-store name so mint/seed shares one source of truth. */
 export const AUTH_BUNDLE = AUTH_STORE_ALIAS;
 export { ReservedBundleWrongBackendError };
-/**
- * A well-formed Claude OAuth setup-token: the `sk-ant-oat01-` prefix followed by
- * token-safe characters only, on a single line. `claude setup-token` mints exactly
- * this; nothing else is a token.
- *
- * The provisioning capture bug behind #1767 stored the raw `claude setup-token`
- * TTY stream — the welcome banner, ANSI control sequences, box-drawing art, and the
- * token buried inside — under a per-account key instead of the parsed value. That
- * blob is not a token: injected as `Authorization: Bearer <blob>` it made Anthropic
- * reject every request and the run crash. agents-cli only *consumes* these tokens
- * (the mint itself is the Rush Cloud / mint-auth path), so this is the boundary
- * where a corrupt bundle entry must be caught before it reaches the auth header.
- */
 const SETUP_TOKEN_RE = /^sk-ant-oat01-[A-Za-z0-9_-]+$/;
-/**
- * Process-local memo of resolved setup-tokens, keyed by the caller's cache key
- * AND the per-account token key — a version home that switches accounts must
- * miss, never be served the previous account's token. Plaintext setup-tokens
- * are never written to another cache. The bundle now
- * lives behind the standalone `secrets` process (one spawn per read), so the
- * memo is what keeps a probe loop over many accounts from re-decrypting the
- * whole `auth` bundle per account; it is bounded by {@link SETUP_TOKEN_MEMO_TTL_MS}
- * so a rotation performed by another process is observed within seconds, and
- * an in-process writer clears it outright ({@link invalidateClaudeSetupTokenCache}).
- */
 const setupTokenCache = new Map();
 const SETUP_TOKEN_MEMO_TTL_MS = 10_000;
-/** Drop every memoized setup-token; called after this process seeds or rotates one. */
 export function invalidateClaudeSetupTokenCache() {
     setupTokenCache.clear();
 }
@@ -82,11 +48,9 @@ function credentialFingerprint(credentialPath) {
         return 'missing';
     }
 }
-/** True only for a clean, single-line `sk-ant-oat01-…` token — see {@link SETUP_TOKEN_RE}. */
 export function isValidClaudeSetupToken(value) {
     return SETUP_TOKEN_RE.test(value);
 }
-/** The per-account key an email maps to inside the `auth` bundle. */
 export function claudeAccountTokenKey(account) {
     const slug = account
         .trim()
@@ -96,7 +60,6 @@ export function claudeAccountTokenKey(account) {
         .replace(/[^A-Z0-9_]/g, '_');
     return `CLAUDE_CODE_OAUTH_TOKEN_${slug}`;
 }
-/** Signed-in account email for a version home, from `.claude.json` (no keychain). */
 export function readClaudeAccountEmail(home) {
     const base = home ?? os.homedir();
     for (const p of [path.join(base, '.claude', '.claude.json'), path.join(base, '.claude.json')]) {
@@ -106,47 +69,20 @@ export function readClaudeAccountEmail(home) {
                 return email.trim();
         }
         catch {
-            // Missing/unreadable at this location — try the next.
         }
     }
     return null;
 }
-/**
- * Resolve a long-lived `claude setup-token` for the account signed into `home`
- * from the reserved FILE-BASED `auth` bundle. Returns the token or null. Reads
- * ONLY when the bundle is file-backed (never keychain), so this path itself can
- * never trigger a Touch ID prompt — that is the entire point: usage/probe reads
- * authenticate with the shareable setup-token, not the ACL-bound login item.
- */
 export function resolveClaudeSetupToken(home) {
-    // Require a known account (email) up front: without it we cannot key a
-    // per-account token, and we must NOT fall back to a bare shared key that
-    // would misapply one account's setup-token to another.
     const email = readClaudeAccountEmail(home)
-        // Self-heal (PHNX-3660): a home provisioned before seed-on-attach carries an
-        // `.oauth_token` but no identity. Recover the email from the bundle and
-        // write it back, so the home converges instead of needing a re-attach.
-        // Explicit-home only: with no home the probe targets the operator's real
-        // ~/.claude.json, which a library read must never rewrite.
         ?? (home ? discoverClaudeAccountEmailFromOauthToken(home) : null);
     if (!email)
         return null;
     return resolveClaudeSetupTokenForEmail(email, home ?? os.homedir());
 }
-/** Negative/positive discovery cache, keyed by home + .oauth_token fingerprint (SHOULD-2). */
 const discoveryCache = new Map();
-/**
- * Recover a home's account email from its `.claude/.oauth_token` by matching
- * the token VALUE against the `auth` bundle (the slug encodes the email, and
- * the re-encode check makes the decode lossless or fail). On a match the
- * identity is written back via {@link seedClaudeWorkerHomeIdentity}, so this
- * runs at most once per home. Returns null — and writes nothing — when the
- * file is missing, malformed, or matches no bundle key: a token that no longer
- * exists in the bundle must not resurrect an account mapping. A no-match
- * result is cached against the token file's fingerprint so a rotated-out home
- * does not re-decrypt the bundle on every probe.
- */
 function discoverClaudeAccountEmailFromOauthToken(home) {
+    // Discovery may rewrite identity only inside the explicit worker home.
     try {
         const tokenPath = path.join(home, '.claude', '.oauth_token');
         const fingerprint = credentialFingerprint(tokenPath);
@@ -189,16 +125,8 @@ function discoverEmailUncached(home, tokenPath) {
     }
     return null;
 }
-/**
- * Decode the email a `CLAUDE_CODE_OAUTH_TOKEN_<slug>` key encodes — or null
- * when the decode is ambiguous. The mapping collapses every non-alphanumeric
- * to `_`, so a `_` surviving in the decoded address cannot be told apart from
- * a folded `.`/`+`/etc. (`FIRST_DOT_LAST_AT_GMAIL_DOT_COM` decodes to
- * `first_dot_last@gmail.com`, which round-trips — wrongly — under the bare
- * re-encode check; review BLOCKER 1). Only a fully unambiguous decode — local
- * and domain pure `[a-z0-9]`, dots in the domain only — is trusted.
- */
 function emailFromTokenKey(key) {
+    // Trust only an unambiguous, losslessly round-tripping token-key slug for identity recovery; underscore ambiguity returns null.
     const prefix = 'CLAUDE_CODE_OAUTH_TOKEN_';
     if (!key.startsWith(prefix))
         return null;
@@ -213,21 +141,8 @@ function emailFromTokenKey(key) {
         return null;
     return email;
 }
-/**
- * Resolve a long-lived setup-token for an EXPLICIT account email, independent of
- * any version home's `.claude.json`. This is what lets worker-slot provisioning
- * seed a headless worker home that has never had an interactive login: the
- * account's non-rotating setup-token is already fleet-synced in the file-based
- * `auth` bundle, keyed by email ({@link claudeAccountTokenKey}), so we can write
- * the home's `.oauth_token` from it without the circular
- * "read the home's email to resolve the home's token" dependency that
- * {@link resolveClaudeSetupToken} has. Same file-backed-only, fail-closed,
- * fingerprint-stable read as the home-keyed path — it is the shared core.
- *
- * `cacheKey` scopes the process-local token cache; callers pass a version home
- * so a home-keyed and email-keyed read of the same account share nothing stale.
- */
 export function resolveClaudeSetupTokenForEmail(email, cacheKey) {
+    // Memoization includes both caller/home and account so tokens cannot cross identities.
     try {
         const trimmed = email.trim();
         if (!trimmed)
@@ -237,10 +152,6 @@ export function resolveClaudeSetupTokenForEmail(email, cacheKey) {
         const cached = setupTokenCache.get(ck);
         if (cached && Date.now() - cached.readAt < SETUP_TOKEN_MEMO_TTL_MS)
             return cached.token;
-        // SEC-GAP-3: a keychain/vault-backed `auth` used to return null here, so
-        // usage/probe fell through to the interactive login (Touch ID) with no
-        // hint that the seeded setup-token was being ignored. readReservedAuthBundle
-        // throws ReservedBundleWrongBackendError instead, which propagates.
         const resolved = readReservedAuthBundle('usage');
         const v = (resolved?.env[key] ?? '').trim();
         const token = v.length > 0 && isValidClaudeSetupToken(v) ? v : null;
@@ -253,23 +164,6 @@ export function resolveClaudeSetupTokenForEmail(email, cacheKey) {
         return null;
     }
 }
-/**
- * Seed a keychain-less Linux worker's Claude version-home identity so an account's
- * fleet-synced setup-token resolves for it. A worker home never had an interactive
- * browser login, so its `.claude.json` carries no `oauthAccount.emailAddress` and
- * the account reads "signed out" even though its non-rotating setup-token is present
- * in the `auth` bundle. This writes ONLY the descriptive identity (the email), merged
- * into both `.claude.json` locations Claude Code reads, preserving every other field.
- * It never copies a rotating OAuth credential (`.credentials.json`) — the setup-token
- * stays the credential of record.
- */
-/**
- * Write a Claude worker slot's `.oauth_token` (0600) from a durable setup-token,
- * the way the pre-slot worker home was provisioned. Refuses a malformed token so
- * a corrupt bundle entry can never reach the auth header (see {@link SETUP_TOKEN_RE}).
- * `home` is the slot dir; the claude adapter shim reads `$CLAUDE_CONFIG_DIR/.oauth_token`
- * where `CLAUDE_CONFIG_DIR` is `<home>/.claude`. Returns the written path.
- */
 export function writeClaudeWorkerOauthToken(home, token) {
     if (!isValidClaudeSetupToken(token)) {
         throw new Error('Refusing to write a malformed Claude setup-token to a worker slot.');
@@ -279,18 +173,6 @@ export function writeClaudeWorkerOauthToken(home, token) {
     fs.writeFileSync(tokenPath, token, { mode: 0o600 });
     return tokenPath;
 }
-/**
- * Read one non-rotating credential value from a reserved store by its storage
- * key. Returns null when the bundle or key is absent. Used to materialize a
- * worker slot from a synced durable credential (setup-token / API key).
- *
- * A reserved `__<harness>__` store is file-backed by design (headless, fleet-
- * shareable) and its item is read directly, symmetric with how it is written —
- * `readAndResolveBundleEnv`'s name validation does not yet accept a reserved
- * name on the READ path (a secrets-track seam; see the PR body). A non-reserved
- * bundle (the legacy `auth` alias, a provider bundle) goes through the normal
- * resolver so refs/expiry/lease gates still apply.
- */
 export function readReservedCredential(bundle, key) {
     try {
         if (isReservedStoreName(bundle) && bundle.startsWith('__')) {
@@ -315,39 +197,22 @@ export function readReservedCredential(bundle, key) {
         return null;
     }
 }
-/**
- * Materialize a worker slot for a portable account from its synced durable
- * credential (PHNX-3940 T6 — the generalization of the pre-slot Claude worker-home
- * provisioning). Creates the HOME-shaped slot dir (T1 `ensureSlot`), then, for a
- * durable harness, writes the credential into it the way the Claude worker home is
- * provisioned today: for `claude`, the setup-token → `.oauth_token` (0600) + the
- * seeded identity email (the read-side join in agent-spec then completes the uuids
- * from the registry row). API-key harnesses need no file — the key is injected at
- * spawn from the reserved store (T5) — so their slot is created and recorded
- * `durable` with no write. A per-device harness (`worker: 'none'`) gets a
- * `per-device` slot and no credential — it logs in per box.
- *
- * This is worker-side reconciliation: it runs on the box where the key landed and
- * NEVER transports anything (the SSH push that delivered the key is the daemon's
- * job — invariant 1). Fails loud when a durable claude account has no resolvable
- * token on this device rather than recording a slot that cannot authenticate.
- */
 export function provisionWorkerSlot(account) {
     const harness = account.agent;
     const durable = harnessWorkerKinds(harness).some((kind) => kind === 'setup-token' || kind.startsWith('api-key'));
     const slot = ensureSlot(harness, account.id);
     const checkedAt = new Date().toISOString();
     if (!durable) {
+        // Per-device harnesses keep an explicit unconfigured slot until that worker performs its own login.
         const record = { ...slot, authMode: 'per-device', verdict: 'unconfigured', checkedAt };
         recordSlot(account.id, record);
         return record;
     }
     if (harness === 'claude') {
         const cred = account.workerCredential;
+        // Pre-T1 rows lack workerCredential, so retain the legacy email-keyed auth-bundle lookup.
         const token = cred
             ? readReservedCredential(cred.bundle, cred.key)
-            // Claude row predating T1 (no workerCredential): the legacy `auth` bundle
-            // keys the token by the account email.
             : account.identityLabel
                 ? resolveClaudeSetupTokenForEmail(account.identityLabel, slot.slotDir)
                 : null;
@@ -360,17 +225,10 @@ export function provisionWorkerSlot(account) {
         if (account.identityLabel)
             seedClaudeWorkerHomeIdentity(slot.slotDir, account.identityLabel);
     }
-    // API-key harnesses: the key rides the reserved store and is injected at spawn
-    // (T5); nothing is written into the slot here.
     const record = { ...slot, authMode: 'durable', verdict: 'unverified', checkedAt };
     recordSlot(account.id, record);
     return record;
 }
-/**
- * True when a claude worker slot carries everything provisioning seeds: the
- * identity email AND the completed-onboarding flag. A slot provisioned before
- * onboarding was seeded answers false, so the daemon's reconcile re-seeds it.
- */
 export function isClaudeWorkerHomeSeeded(home) {
     for (const p of [path.join(home, '.claude', '.claude.json'), path.join(home, '.claude.json')]) {
         try {
@@ -387,24 +245,9 @@ export function isClaudeWorkerHomeSeeded(home) {
     }
     return true;
 }
-/**
- * Seed a worker slot's `.claude.json` (both locations Claude Code reads) with
- * the account identity AND `hasCompletedOnboarding`. A worker never has a human
- * at it, so nothing else can complete Claude Code's first-run onboarding (theme
- * picker, "Let's get started"); without the flag every slot launch re-onboarded.
- * Everything else in the document is preserved.
- *
- * Without an email only the onboarding flag is seeded: a provider (setup-token)
- * launch runs in the shared version home, whose identity belongs to whatever
- * native login lives there, so it must not be rewritten. A document already
- * carrying the requested state is left untouched, so a launch never rewrites a
- * config Claude Code is using.
- */
 export function seedClaudeWorkerHomeIdentity(versionHome, email) {
+    // Follow an existing config symlink; replacing it would split Claude's configuration.
     const trimmed = email?.trim() || undefined;
-    // A version home usually links `.claude/.claude.json -> ../.claude.json`. The
-    // temp-write + rename below would replace that link with a regular file and
-    // split one config into two, so write through a link to the file it names.
     const targets = new Set();
     for (const p of [
         path.join(versionHome, '.claude', '.claude.json'),
@@ -416,7 +259,6 @@ export function seedClaudeWorkerHomeIdentity(versionHome, email) {
                 target = path.resolve(path.dirname(p), fs.readlinkSync(p));
         }
         catch {
-            // Missing: written fresh below.
         }
         targets.add(target);
     }
@@ -426,9 +268,6 @@ export function seedClaudeWorkerHomeIdentity(versionHome, email) {
             doc = JSON.parse(fs.readFileSync(p, 'utf-8'));
         }
         catch (err) {
-            // Missing file → write a fresh minimal document. A file that EXISTS but
-            // does not parse is being concurrently rewritten by Claude Code itself —
-            // skip it rather than overwrite a live config with the minimal doc.
             if (err.code !== 'ENOENT')
                 continue;
         }
@@ -441,7 +280,6 @@ export function seedClaudeWorkerHomeIdentity(versionHome, email) {
             doc.oauthAccount = { ...existing, emailAddress: trimmed };
         doc.hasCompletedOnboarding = true;
         fs.mkdirSync(path.dirname(p), { recursive: true });
-        // Temp-write + rename: a reader mid-write never sees a truncated doc.
         const tmp = `${p}.agents-${process.pid}.tmp`;
         try {
             fs.writeFileSync(tmp, JSON.stringify(doc));
@@ -451,7 +289,7 @@ export function seedClaudeWorkerHomeIdentity(versionHome, email) {
             try {
                 fs.rmSync(tmp, { force: true });
             }
-            catch { /* best effort */ }
+            catch { }
         }
     }
 }

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

@@ -1,13 +1,6 @@
 import { type ClaudeHomeIdentity } from './agent-spec/agents.js';
 import { type NativeAccount } from './account-registry.js';
 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;
@@ -31,47 +24,13 @@ interface ClaudeStatusLinePayload {
     };
 }
 export declare function ingestClaudeStatusLineUsage(payload: ClaudeStatusLinePayload, identity: ClaudeHomeIdentity | null, versionHome?: string | null): boolean;
-/**
- * Where the running Claude keeps the config this render attributes to: the version
- * home when the launch shim set CLAUDE_CONFIG_DIR, otherwise the real HOME — the
- * same resolution Claude Code applies, so a Claude launched without the shim (IDE
- * extension, direct binary) still shows the account it is actually signed into.
- */
 export declare function claudeHomeFromEnv(env: NodeJS.ProcessEnv): string;
-/**
- * The identity of the running Claude, read ONCE per render from the `.claude.json`
- * of the home it is actually running with: it keys the usage ingest above and
- * names the account part below. Null when the home has never signed in. Sync and
- * file-only on purpose — this runs on every status-line refresh.
- */
 export declare function readClaudeIdentity(claudeHome: string): ClaudeHomeIdentity | null;
-/**
- * The registered native account for the running Claude's identity (`agents
- * accounts` — `work`, `dev`, …), or null when that login is unnamed.
- */
 export declare function resolveNativeAccount(identity: ClaudeHomeIdentity | null): NativeAccount | null;
-/**
- * Format the signed-in account as a statusline part ('' when never signed in).
- * A named login renders its registered NAME — the short handle the owner chose
- * (`work`, `dev`), which is what tells eight same-harness logins apart at a
- * glance. An unnamed login renders the label every other account-aware surface
- * (`agents view`, `agents accounts`) uses: the email, plus the org name for a
- * multi-seat Team/Enterprise seat.
- */
 export declare function formatAccountPart(identity: ClaudeHomeIdentity | null, account: NativeAccount | null): string;
 export declare function renderDelegate(payload: string, versionHome: string): string;
-/**
- * Format a reminder as a dimmed statusline part (empty string when none). The
- * ◆ marker distinguishes it from the host/model/usage parts, and the ANSI dim
- * keeps it quiet next to the live figures.
- */
 export declare function formatReminderPart(short: string | undefined): string;
 export declare function renderClaudeStatusLine(payload: ClaudeStatusLinePayload, host?: string, delegated?: string, reminder?: string, account?: string): string;
-/**
- * Resolve the per-session reminder for the statusline, or '' when none is
- * configured. A malformed reminders file is swallowed here on purpose — a broken
- * prompt is worse than a missing reminder — while `agents reminders` surfaces it.
- */
 export declare function resolveReminderPart(sessionId?: string): string;
 export declare function runClaudeStatusLine(): Promise<number>;
 export declare function installClaudeStatusLine(versionHome: string): {

package/dist/lib/claude-statusline.js

@@ -12,31 +12,9 @@ import { machineId } from './machine-id.js';
 import { recordRunAuthOutcome } from './auth-health.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)
@@ -81,55 +59,26 @@ export function ingestClaudeStatusLineUsage(payload, identity, versionHome) {
         windows,
         freshness: { source: 'statusline', poller: machineId() },
     });
-    // A status-line payload with rate_limits IS a real inference response — the
-    // token authenticated moments ago. Record that as the per-account auth FACT
-    // (`last used ok`), keyed to the account this box actually ran (PHNX-4116).
     recordRunAuthOutcome({
         agent: 'claude',
         accountId: resolveNativeAccount(identity)?.id ?? null,
         home: versionHome ?? null,
         outcome: { ok: true },
     });
-    // Keep this box's own state file current so the next placement probe or
-    // usage-sync fan-out carries this reading; the file is local, no transport.
     void import('./accounting/usage-sync.js')
         .then((mod) => mod.publishUsageSnapshotToSharedStore())
         .catch(() => { });
     return true;
 }
-/**
- * Where the running Claude keeps the config this render attributes to: the version
- * home when the launch shim set CLAUDE_CONFIG_DIR, otherwise the real HOME — the
- * same resolution Claude Code applies, so a Claude launched without the shim (IDE
- * extension, direct binary) still shows the account it is actually signed into.
- */
 export function claudeHomeFromEnv(env) {
     return versionHomeFromEnv(env) ?? os.homedir();
 }
-/**
- * The identity of the running Claude, read ONCE per render from the `.claude.json`
- * of the home it is actually running with: it keys the usage ingest above and
- * names the account part below. Null when the home has never signed in. Sync and
- * file-only on purpose — this runs on every status-line refresh.
- */
 export function readClaudeIdentity(claudeHome) {
     return readClaudeHomeConfig(claudeHome)?.identity ?? null;
 }
-/**
- * The registered native account for the running Claude's identity (`agents
- * accounts` — `work`, `dev`, …), or null when that login is unnamed.
- */
 export function resolveNativeAccount(identity) {
     return identity ? findNativeAccountByIdentity(readMeta(), 'claude', identity) : null;
 }
-/**
- * Format the signed-in account as a statusline part ('' when never signed in).
- * A named login renders its registered NAME — the short handle the owner chose
- * (`work`, `dev`), which is what tells eight same-harness logins apart at a
- * glance. An unnamed login renders the label every other account-aware surface
- * (`agents view`, `agents accounts`) uses: the email, plus the org name for a
- * multi-seat Team/Enterprise seat.
- */
 export function formatAccountPart(identity, account) {
     if (!identity)
         return '';
@@ -141,7 +90,6 @@ function delegatePath(versionHome) {
     return path.join(versionHome, DELEGATE_FILE);
 }
 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 = '';
@@ -162,19 +110,12 @@ export function renderDelegate(payload, versionHome) {
     });
     return result.status === 0 ? result.stdout.trim() : '';
 }
-/**
- * Format a reminder as a dimmed statusline part (empty string when none). The
- * ◆ marker distinguishes it from the host/model/usage parts, and the ANSI dim
- * keeps it quiet next to the live figures.
- */
 export function formatReminderPart(short) {
     const text = short?.trim();
     return text ? `\x1b[2m◆ ${text}\x1b[22m` : '';
 }
 export function renderClaudeStatusLine(payload, host = os.hostname().split('.')[0] || os.hostname(), delegated = '', reminder = '', account = '') {
     const model = payload.model?.display_name?.trim() || payload.model?.id?.trim() || 'model pending';
-    // host · account · model: who is running, as which account, on which model —
-    // the account sits before the model so a glance answers "whose quota is this".
     const parts = [host];
     if (account)
         parts.push(account);
@@ -191,11 +132,6 @@ export function renderClaudeStatusLine(payload, host = os.hostname().split('.')[
         parts.push(reminder);
     return parts.join(' · ');
 }
-/**
- * Resolve the per-session reminder for the statusline, or '' when none is
- * configured. A malformed reminders file is swallowed here on purpose — a broken
- * prompt is worse than a missing reminder — while `agents reminders` surfaces it.
- */
 export function resolveReminderPart(sessionId) {
     try {
         return formatReminderPart(pickReminderForSession(loadReminders(), sessionId)?.short);
@@ -244,14 +180,10 @@ export function installClaudeStatusLine(versionHome) {
         if (existing === CLAUDE_STATUSLINE_COMMAND)
             return { changed: false };
         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/cli-entry.d.ts

@@ -1,33 +1,7 @@
 export declare const BUN_VIRTUAL_ROOT: RegExp;
 export declare function getAgentsBinPath(argv1?: string | undefined, execPath?: string): string;
-/**
- * Directory that contains the `agents` launcher usable for PATH resolution.
- *
- * When the running entry IS the launcher (a compiled binary or an extension-less
- * shim named `agents`), this is just `dirname(getAgentsBinPath())`. When the
- * running entry is a script inside `dist/` reached via a symlink/shim elsewhere
- * (the npm global-install shape), we look for a launcher whose realpath points at
- * the same entry and return that launcher's directory. Falls back to the entry's
- * own directory when no launcher is found.
- */
 export declare function getAgentsBinDir(): string;
-/**
- * A CLI entry must be launched through the Node runtime when it is a Node
- * script — a `.js`/`.cjs`/`.mjs` file, OR a symlink/extension-less shim whose
- * shebang names `node`. Package installs link `bin/agents` to a `dist/index.js`
- * (a symlink) or drop an extension-less `#!/usr/bin/env node` shim, so an
- * extension check alone misses them and they get run directly. A real compiled
- * binary (Mach-O/ELF/PE) has no `#!node` shebang, so it takes the direct branch
- * and owns its own runtime resolution.
- */
 export declare function isNodeScriptEntry(agentsBin: string): boolean;
-/**
- * Build the `{ command, args }` to re-invoke this CLI with `sub` as its argv,
- * resolving the JS-vs-standalone shape above. This is the single primitive behind
- * both the daemon launch and the secrets-broker spawn — never hand-roll
- * `[process.execPath, process.argv[1], …]`, which appends the bun virtual entry
- * as a bogus subcommand on standalone builds.
- */
 export declare function getCliLaunch(sub: string[], agentsBin?: string): {
     command: string;
     args: string[];

package/dist/lib/cli-entry.js

@@ -1,22 +1,3 @@
-/**
- * Resolve how to re-invoke THIS `agents` CLI as a child process, correctly across
- * both install shapes:
- *
- *   1. **JS install** — `agents` is a `dist/index.js` (or a symlink / `#!node`
- *      shim to it). `process.execPath` is `node`, `process.argv[1]` is the script.
- *      Relaunch as `node <entry> <sub…>`.
- *   2. **Bun standalone binary** (#315) — `agents` is a compiled Mach-O/ELF/PE.
- *      `process.execPath` is the physical signed binary, and `process.argv[1]` is
- *      the *virtual* embedded entry `/$bunfs/root/agents`, which Bun reports as an
- *      existing path. Passing that virtual path as an argv element makes the CLI
- *      receive it as a subcommand and die with `unknown command '/$bunfs/root/agents'`.
- *      Relaunch by executing the physical binary directly: `<binary> <sub…>`.
- *
- * Both `getDaemonLaunch` (daemon.ts) and the secrets-broker `cliSpawn`
- * (secrets/agent.ts) route through here so the two never drift. This module is a
- * leaf — it imports nothing from `lib/` — so it can be pulled into either without
- * an import cycle (daemon.ts ↔ secrets/agent.ts already form one).
- */
 import { execFileSync } from 'child_process';
 import * as fs from 'fs';
 import * as os from 'os';
@@ -31,18 +12,8 @@ function resolveBunStandaloneEntry(entry, execPath) {
     return execPath;
 }
 export function getAgentsBinPath(argv1 = process.argv[1], execPath = process.execPath) {
-    // Prefer the binary actively executing this code. `which agents` returns
-    // whatever happens to be first on PATH, which means a side-by-side dev
-    // build at ~/.local/bin would silently spawn the registry-installed
-    // daemon and run stale code. For a JS install, process.argv[1] is the
-    // absolute entrypoint the user actually invoked. A Bun standalone instead
-    // exposes its embedded /$bunfs/root entry at argv[1] and its physical signed
-    // executable at process.execPath; Bun reports both as existing paths.
     const runningEntry = argv1 ? resolveBunStandaloneEntry(argv1, execPath) : undefined;
     if (runningEntry && fs.existsSync(runningEntry)) {
-        // The package's browser/computer entrypoints are sibling shims without a
-        // `daemon` command. A daemon started as their IPC side effect must launch
-        // through the main agents entrypoint instead of replaying the shim path.
         const entryName = path.basename(runningEntry);
         const compiledShim = /^(browser|computer)\.(c|m)?js$/.test(entryName);
         const installedShim = /^(browser|computer)$/.test(entryName);
@@ -62,16 +33,6 @@ export function getAgentsBinPath(argv1 = process.argv[1], execPath = process.exe
         return 'agents';
     }
 }
-/**
- * Directory that contains the `agents` launcher usable for PATH resolution.
- *
- * When the running entry IS the launcher (a compiled binary or an extension-less
- * shim named `agents`), this is just `dirname(getAgentsBinPath())`. When the
- * running entry is a script inside `dist/` reached via a symlink/shim elsewhere
- * (the npm global-install shape), we look for a launcher whose realpath points at
- * the same entry and return that launcher's directory. Falls back to the entry's
- * own directory when no launcher is found.
- */
 export function getAgentsBinDir() {
     const bin = getAgentsBinPath();
     const base = path.basename(bin);
@@ -102,28 +63,17 @@ export function getAgentsBinDir() {
                 if (fs.realpathSync(launcher) === realBin)
                     return dir;
             }
-            catch { /* ignore */ }
+            catch { }
         }
     }
     return path.dirname(bin);
 }
-/**
- * A CLI entry must be launched through the Node runtime when it is a Node
- * script — a `.js`/`.cjs`/`.mjs` file, OR a symlink/extension-less shim whose
- * shebang names `node`. Package installs link `bin/agents` to a `dist/index.js`
- * (a symlink) or drop an extension-less `#!/usr/bin/env node` shim, so an
- * extension check alone misses them and they get run directly. A real compiled
- * binary (Mach-O/ELF/PE) has no `#!node` shebang, so it takes the direct branch
- * and owns its own runtime resolution.
- */
 export function isNodeScriptEntry(agentsBin) {
     let resolved = agentsBin;
     try {
         resolved = fs.realpathSync(agentsBin);
     }
     catch {
-        // Unresolvable (e.g. a template path that does not exist on this box): fall
-        // back to the extension check on the path as given.
     }
     if (/\.(c|m)?js$/.test(resolved))
         return true;
@@ -143,17 +93,7 @@ export function isNodeScriptEntry(agentsBin) {
         return false;
     }
 }
-/**
- * Build the `{ command, args }` to re-invoke this CLI with `sub` as its argv,
- * resolving the JS-vs-standalone shape above. This is the single primitive behind
- * both the daemon launch and the secrets-broker spawn — never hand-roll
- * `[process.execPath, process.argv[1], …]`, which appends the bun virtual entry
- * as a bogus subcommand on standalone builds.
- */
 export function getCliLaunch(sub, agentsBin = getAgentsBinPath()) {
-    // Resolve a bun virtual entry to the physical executable even when a caller
-    // passes agentsBin explicitly (getAgentsBinPath already does this for the
-    // default), so a `/$bunfs/root/agents` never becomes the command or an argv.
     const bin = resolveBunStandaloneEntry(agentsBin, process.execPath);
     if (isNodeScriptEntry(bin)) {
         return { command: process.execPath, args: [bin, ...sub] };