@phnx-labs/agents-cli 1.22.35 → 1.22.37

package/dist/commands/wallet.js

@@ -1,216 +0,0 @@
-/**
- * `agents wallet` — a device-local credit-card vault backed by macOS Keychain.
- *
- * UX intent matches Apple Wallet: list cards freely (no biometric), reveal
- * a card with Touch ID. Card numbers never leave the device. This is NOT
- * Apple Pay — we store the real PAN, not a network DPAN, and do not generate
- * per-transaction cryptograms. The help text reflects this.
- *
- * Bundle layout:
- *   ~/.agents/wallet/cards.json                   metadata (id, last4, brand, exp)
- *   agents-cli.secrets.wallet.<id>                JSON {pan, cvc, cardholder}
- */
-import chalk from 'chalk';
-import { terminalWidth, truncateToWidth } from '../lib/session/width.js';
-import { addCard, detectBrand, isValidLuhn, listCards, removeCard, renameCard, showCard, } from '../lib/wallet/index.js';
-import { isInteractiveTerminal, isPromptCancelled } from './utils.js';
-import { setHelpSections } from '../lib/help.js';
-function brandLabel(b) {
-    switch (b) {
-        case 'visa': return 'Visa';
-        case 'mastercard': return 'Mastercard';
-        case 'amex': return 'American Express';
-        case 'discover': return 'Discover';
-        case 'diners': return 'Diners Club';
-        case 'jcb': return 'JCB';
-        case 'unionpay': return 'UnionPay';
-        default: return 'Card';
-    }
-}
-function formatExp(month, year) {
-    return `${month}/${year.slice(-2)}`;
-}
-/** Width of the id column (incl. its 2-space gap): full UUID >=104, short id >=80, none below. */
-export function walletIdWidth(cols) {
-    return cols >= 104 ? 2 + 36 : cols >= 80 ? 2 + 8 : 0;
-}
-/** Nickname column width. Shrinks so the whole row fits even at the 60-col floor. */
-export function walletNickWidth(cols) {
-    const rest = 2 + 1 + 18 + 1 + 10 + 1 + 9 + walletIdWidth(cols); // everything but the nickname
-    return Math.max(8, Math.min(24, cols - rest));
-}
-export function renderRow(c, cols = terminalWidth()) {
-    const nickW = walletNickWidth(cols);
-    const nick = truncateToWidth(c.nickname, nickW).padEnd(nickW);
-    const brand = brandLabel(c.brand).padEnd(18);
-    const last4 = `•••• ${c.last4}`.padEnd(10);
-    const exp = formatExp(c.exp_month, c.exp_year);
-    // Full 36-char UUID pushed rows to ~106 chars; size the id to the terminal.
-    const id = cols >= 104 ? c.id : cols >= 80 ? c.id.slice(0, 8) : '';
-    const idCol = id ? `  ${chalk.gray(id)}` : '';
-    return `  ${chalk.cyan(nick)} ${brand} ${last4} ${chalk.gray('exp ' + exp)}${idCol}`;
-}
-async function promptString(message, validate) {
-    const { input } = await import('@inquirer/prompts');
-    return await input({ message, validate });
-}
-async function promptSecret(message) {
-    const { password } = await import('@inquirer/prompts');
-    return await password({ message, mask: true });
-}
-function requireTTY(action) {
-    if (!isInteractiveTerminal()) {
-        throw new Error(`'agents wallet ${action}' requires an interactive terminal.`);
-    }
-}
-export function registerWalletCommands(program) {
-    const cmd = program
-        .command('wallet')
-        .description('Device-local credit-card vault backed by macOS Keychain (Touch ID required to reveal). ' +
-        'Encrypted at rest, never leaves your device. Not Apple Pay — stores real PANs, no tokenization.');
-    setHelpSections(cmd, {
-        examples: `
-      $ agents wallet add                              # interactive: PAN, CVC, expiry, nickname
-      $ agents wallet list                             # last 4 only, no Touch ID prompt
-      $ agents wallet show personal-amex               # Touch ID required, reveals full card
-      $ agents wallet rename personal-amex "Travel"
-      $ agents wallet remove personal-amex
-    `,
-    });
-    cmd
-        .command('add')
-        .description('Add a card to the vault. Interactive prompt for PAN, CVC, expiry, cardholder, nickname.')
-        .option('--nickname <name>', 'Set the nickname non-interactively (still prompts for PAN/CVC)')
-        .option('--stdin-json', 'Read all fields as a JSON object on stdin (for IPC callers). Emits the new card metadata as JSON to stdout.')
-        .action(async (opts) => {
-        try {
-            if (opts.stdinJson) {
-                const raw = await new Promise((resolve, reject) => {
-                    const chunks = [];
-                    process.stdin.on('data', (c) => {
-                        chunks.push(typeof c === 'string' ? Buffer.from(c) : c);
-                    });
-                    process.stdin.on('end', () => resolve(Buffer.concat(chunks).toString('utf-8')));
-                    process.stdin.on('error', reject);
-                });
-                const input = JSON.parse(raw);
-                const meta = addCard(input);
-                process.stdout.write(JSON.stringify({ card: meta }) + '\n');
-                return;
-            }
-            requireTTY('add');
-            const pan = (await promptSecret('Card number')).replace(/\s+/g, '');
-            if (!/^\d+$/.test(pan))
-                throw new Error('PAN must contain only digits.');
-            if (!isValidLuhn(pan))
-                throw new Error('PAN failed Luhn checksum — typo?');
-            const brand = detectBrand(pan);
-            console.log(chalk.gray(`Detected: ${brandLabel(brand)} •••• ${pan.slice(-4)}`));
-            const exp_month = await promptString('Expiration month (MM)', (v) => {
-                const n = Number(v);
-                return Number.isInteger(n) && n >= 1 && n <= 12 ? true : 'Month must be 1-12';
-            });
-            const exp_year = await promptString('Expiration year (YY or YYYY)', (v) => {
-                const d = v.replace(/\D/g, '');
-                return d.length === 2 || d.length === 4 ? true : 'Year must be 2 or 4 digits';
-            });
-            const cvc = (await promptSecret('CVC')).replace(/\s+/g, '');
-            if (!/^\d{3,4}$/.test(cvc))
-                throw new Error('CVC must be 3 or 4 digits.');
-            const cardholder = await promptString('Cardholder name (as printed)');
-            const nickname = opts.nickname?.trim() || await promptString('Nickname (e.g. Personal Amex)', (v) => v.trim() ? true : 'Required');
-            const meta = addCard({ nickname, pan, cvc, cardholder, exp_month, exp_year });
-            console.log(chalk.green(`Added ${brandLabel(meta.brand)} •••• ${meta.last4} as '${meta.nickname}' (id: ${meta.id})`));
-        }
-        catch (err) {
-            if (isPromptCancelled(err))
-                return;
-            console.error(chalk.red(err.message));
-            process.exit(1);
-        }
-    });
-    cmd
-        .command('list')
-        .alias('ls')
-        .description('List stored cards (metadata only — last 4, brand, expiry). No biometric prompt.')
-        .option('--json', 'Emit JSON to stdout')
-        .action((opts) => {
-        try {
-            const cards = listCards();
-            if (opts.json) {
-                process.stdout.write(JSON.stringify({ cards }, null, 2) + '\n');
-                return;
-            }
-            if (cards.length === 0) {
-                console.log(chalk.gray('No cards in wallet. Try: agents wallet add'));
-                return;
-            }
-            const walletCols = terminalWidth();
-            const nickW = walletNickWidth(walletCols);
-            const idHeader = walletIdWidth(walletCols) ? '        ID' : '';
-            console.log(chalk.bold(`  ${'NICKNAME'.padEnd(nickW)} ${'BRAND'.padEnd(18)} ${'LAST4'.padEnd(10)} EXP${idHeader}`));
-            for (const c of cards)
-                console.log(renderRow(c, walletCols));
-        }
-        catch (err) {
-            console.error(chalk.red(err.message));
-            process.exit(1);
-        }
-    });
-    cmd
-        .command('show <id>')
-        .description('Reveal a card. Touch ID required. Argument is a card id or nickname.')
-        .option('--json', 'Emit JSON to stdout (still triggers Touch ID)')
-        .action((id, opts) => {
-        try {
-            const full = showCard(id);
-            if (opts.json) {
-                process.stdout.write(JSON.stringify(full, null, 2) + '\n');
-                return;
-            }
-            console.log();
-            console.log(chalk.bold(`  ${full.nickname}`));
-            console.log(`  ${chalk.gray('Brand     ')} ${brandLabel(full.brand)}`);
-            console.log(`  ${chalk.gray('Number    ')} ${full.pan.match(/.{1,4}/g)?.join(' ') ?? full.pan}`);
-            console.log(`  ${chalk.gray('CVC       ')} ${full.cvc}`);
-            console.log(`  ${chalk.gray('Expires   ')} ${formatExp(full.exp_month, full.exp_year)}`);
-            console.log(`  ${chalk.gray('Holder    ')} ${full.cardholder}`);
-            console.log();
-        }
-        catch (err) {
-            console.error(chalk.red(err.message));
-            process.exit(1);
-        }
-    });
-    cmd
-        .command('remove <id>')
-        .alias('rm')
-        .description('Remove a card from the vault. Argument is a card id or nickname.')
-        .action((id) => {
-        try {
-            const meta = removeCard(id);
-            if (!meta) {
-                console.error(chalk.red(`No card found matching '${id}'.`));
-                process.exit(1);
-            }
-            console.log(chalk.green(`Removed '${meta.nickname}' (${brandLabel(meta.brand)} •••• ${meta.last4}).`));
-        }
-        catch (err) {
-            console.error(chalk.red(err.message));
-            process.exit(1);
-        }
-    });
-    cmd
-        .command('rename <id> <new-nickname>')
-        .description('Rename a card. Argument is the current id or nickname.')
-        .action((id, newNickname) => {
-        try {
-            const meta = renameCard(id, newNickname);
-            console.log(chalk.green(`Renamed to '${meta.nickname}'.`));
-        }
-        catch (err) {
-            console.error(chalk.red(err.message));
-            process.exit(1);
-        }
-    });
-}

package/dist/commands/worktree.d.ts

@@ -1,19 +0,0 @@
-/**
- * agents worktree -- provision, release, and prune per-terminal git worktrees.
- *
- * Used by surfaces that want to spawn each agent terminal in an isolated
- * working tree (Companion extension opt-in toggle). Mirrors the in-process
- * worktree helpers in lib/teams/worktree.ts but exposes them as a CLI so
- * other processes (IDE extensions, shell aliases, hooks) can call them.
- *
- *   agents worktree provision <terminal-id>   -> prints absolute worktree path
- *   agents worktree release   <terminal-id>   -> removes if clean + merged
- *   agents worktree prune                     -> removes every clean+merged one
- *
- * Worktrees live at <repo>/.agents/worktrees/<terminal-id>, on a branch
- * named agents/<terminal-id>. New branches start at the freshly-fetched
- * origin/<default> (not local HEAD), matching lib/teams/worktree.ts and the
- * agent-system rule that keeps coding-agent worktrees under .agents/.
- */
-import type { Command } from 'commander';
-export declare function registerWorktreeCommands(program: Command): void;

package/dist/commands/worktree.js

@@ -1,272 +0,0 @@
-import chalk from 'chalk';
-import { die } from '../lib/format.js';
-import { getGitRoot } from '../lib/git.js';
-import { execFile } from 'child_process';
-import { promisify } from 'util';
-import * as fs from 'fs/promises';
-import * as fsSync from 'fs';
-import * as path from 'path';
-import { setHelpSections } from '../lib/help.js';
-const execFileAsync = promisify(execFile);
-const WORKTREE_SUBDIR = path.join('.agents', 'worktrees');
-const BRANCH_PREFIX = 'agents/';
-function isValidTerminalId(id) {
-    // Allow letters, digits, dot, dash, underscore. Reject anything else so a
-    // hostile or buggy caller can't inject path traversal or shell metachars.
-    return /^[A-Za-z0-9._-]+$/.test(id) && id.length > 0 && id.length <= 128;
-}
-// Thin command-layer wrapper over the shared lib/git.ts `getGitRoot`: turns its
-// throw into a clean `die()` message. The git plumbing lives in one place now.
-async function gitRoot(cwd) {
-    try {
-        return await getGitRoot(cwd);
-    }
-    catch {
-        die(`Not inside a git repo: ${cwd}`);
-    }
-}
-function worktreePathFor(root, terminalId) {
-    return path.join(root, WORKTREE_SUBDIR, terminalId);
-}
-function branchNameFor(terminalId) {
-    return `${BRANCH_PREFIX}${terminalId}`;
-}
-async function inspect(root, terminalId) {
-    const wt = worktreePathFor(root, terminalId);
-    const branch = branchNameFor(terminalId);
-    const exists = fsSync.existsSync(wt);
-    if (!exists) {
-        return { exists: false, dirty: false, aheadOfUpstream: false, hasUpstream: false, branchMerged: false };
-    }
-    let dirty = false;
-    try {
-        const { stdout } = await execFileAsync('git', ['status', '--porcelain'], { cwd: wt });
-        dirty = stdout.trim().length > 0;
-    }
-    catch {
-        dirty = true; // err on the side of caution
-    }
-    let hasUpstream = false;
-    let aheadOfUpstream = false;
-    try {
-        await execFileAsync('git', ['rev-parse', '--abbrev-ref', '@{u}'], { cwd: wt });
-        hasUpstream = true;
-        const { stdout } = await execFileAsync('git', ['rev-list', '--count', '@{u}..HEAD'], { cwd: wt });
-        aheadOfUpstream = parseInt(stdout.trim(), 10) > 0;
-    }
-    catch {
-        hasUpstream = false; // never pushed -- treat as "has commits we'd lose"
-    }
-    let branchMerged = false;
-    try {
-        const { stdout } = await execFileAsync('git', ['branch', '--merged', 'origin/main', '--list', branch], { cwd: root });
-        branchMerged = stdout.trim().length > 0;
-    }
-    catch {
-        branchMerged = false;
-    }
-    return { exists, dirty, aheadOfUpstream, hasUpstream, branchMerged };
-}
-/** Resolve origin/HEAD → default branch name; falls back to `main`. */
-async function defaultBranch(root) {
-    try {
-        await execFileAsync('git', ['remote', 'set-head', 'origin', '--auto'], { cwd: root });
-    }
-    catch {
-        // offline / no origin
-    }
-    try {
-        const { stdout } = await execFileAsync('git', ['symbolic-ref', '--short', 'refs/remotes/origin/HEAD'], { cwd: root });
-        const base = stdout.trim().replace(/^origin\//, '');
-        if (base)
-            return base;
-    }
-    catch {
-        // no origin/HEAD
-    }
-    return 'main';
-}
-async function provision(root, terminalId) {
-    const wt = worktreePathFor(root, terminalId);
-    const branch = branchNameFor(terminalId);
-    if (fsSync.existsSync(wt))
-        return wt;
-    await fs.mkdir(path.dirname(wt), { recursive: true });
-    // If the branch already exists (e.g. left over from a previous run), reuse
-    // it instead of failing. Surfaces typically reuse a terminal-id when
-    // restoring a session.
-    let branchExists = false;
-    try {
-        await execFileAsync('git', ['rev-parse', '--verify', `refs/heads/${branch}`], { cwd: root });
-        branchExists = true;
-    }
-    catch {
-        branchExists = false;
-    }
-    if (branchExists) {
-        await execFileAsync('git', ['worktree', 'add', wt, branch], { cwd: root });
-        return wt;
-    }
-    // New branch: fetch + base on origin/<default>, never local HEAD (stale trap).
-    const base = await defaultBranch(root);
-    try {
-        await execFileAsync('git', ['fetch', 'origin'], { cwd: root });
-    }
-    catch (err) {
-        const detail = (err?.stderr || err?.message || String(err)).toString().trim();
-        die(`git fetch origin failed in ${root}` +
-            (detail ? `: ${detail}` : '') +
-            `. Cannot provision a worktree from a stale remote-tracking ref.`);
-    }
-    await execFileAsync('git', ['worktree', 'add', '-b', branch, wt, `origin/${base}`], { cwd: root });
-    return wt;
-}
-async function release(root, terminalId, force) {
-    const wt = worktreePathFor(root, terminalId);
-    const branch = branchNameFor(terminalId);
-    if (!fsSync.existsSync(wt)) {
-        // Already gone; treat as success but tell the caller.
-        return { removed: false, reason: 'worktree does not exist' };
-    }
-    if (!force) {
-        const report = await inspect(root, terminalId);
-        if (report.dirty)
-            return { removed: false, reason: 'worktree has uncommitted changes' };
-        if (!report.hasUpstream) {
-            // Local-only commits exist if HEAD differs from origin/main.
-            try {
-                const { stdout } = await execFileAsync('git', ['rev-list', '--count', 'origin/main..HEAD'], { cwd: wt });
-                if (parseInt(stdout.trim(), 10) > 0) {
-                    return { removed: false, reason: 'branch has local commits not on origin/main' };
-                }
-            }
-            catch {
-                return { removed: false, reason: 'cannot verify branch state vs origin/main' };
-            }
-        }
-        if (report.aheadOfUpstream)
-            return { removed: false, reason: 'branch has unpushed commits' };
-    }
-    try {
-        await execFileAsync('git', ['worktree', 'remove', force ? '--force' : '', wt].filter(Boolean), { cwd: root });
-    }
-    catch (err) {
-        if (err.message?.includes('is not a working tree')) {
-            await execFileAsync('git', ['worktree', 'prune'], { cwd: root });
-        }
-        else {
-            throw err;
-        }
-    }
-    // Delete the branch if it's safe to do so. -d (lowercase) refuses to drop
-    // an unmerged branch by itself, which is exactly the safety net we want.
-    try {
-        await execFileAsync('git', ['branch', '-d', branch], { cwd: root });
-    }
-    catch {
-        // Branch may not exist or may not be merged. We already validated above;
-        // leaving the branch behind is preferable to silently dropping commits.
-    }
-    return { removed: true };
-}
-async function listAgentWorktrees(root) {
-    const dir = path.join(root, WORKTREE_SUBDIR);
-    if (!fsSync.existsSync(dir))
-        return [];
-    const entries = await fs.readdir(dir, { withFileTypes: true });
-    return entries.filter(e => e.isDirectory()).map(e => e.name);
-}
-export function registerWorktreeCommands(program) {
-    const wt = program
-        .command('worktree')
-        .description('Provision, release, and prune per-terminal git worktrees for agent isolation.');
-    setHelpSections(wt, {
-        examples: `
-      # Create (or reuse) an isolated worktree for an agent terminal — prints the path
-      agents worktree provision CC-1747509823-3
-
-      # Remove the worktree if it's clean and merged/pushed
-      agents worktree release CC-1747509823-3
-
-      # Preview what 'prune' would release across all agent worktrees
-      agents worktree prune --dry-run
-
-      # Release every agent worktree that's safe to remove
-      agents worktree prune
-    `,
-        notes: `
-      Worktrees live at <repo>/.agents/worktrees/<terminal-id> on branch agents/<terminal-id>.
-      Use --force on 'release' to skip safety checks (DANGEROUS — discards unpushed work).
-    `,
-    });
-    wt.command('provision <terminal-id>')
-        .description('Create (or reuse) an isolated worktree for an agent terminal. Prints the absolute path.')
-        .option('--root <path>', 'Repo root (defaults to current working directory)')
-        .action(async (terminalId, opts) => {
-        if (!isValidTerminalId(terminalId)) {
-            die(`Invalid terminal-id: ${terminalId} (allowed: [A-Za-z0-9._-], <=128 chars)`);
-        }
-        const root = await gitRoot(opts.root ?? process.cwd());
-        const wtPath = await provision(root, terminalId);
-        console.log(wtPath);
-    });
-    wt.command('release <terminal-id>')
-        .description('Remove the worktree if clean and the branch is merged or has no unpushed commits.')
-        .option('--root <path>', 'Repo root (defaults to current working directory)')
-        .option('--force', 'Skip safety checks (DANGEROUS: discards unpushed work)')
-        .action(async (terminalId, opts) => {
-        if (!isValidTerminalId(terminalId)) {
-            die(`Invalid terminal-id: ${terminalId} (allowed: [A-Za-z0-9._-], <=128 chars)`);
-        }
-        const root = await gitRoot(opts.root ?? process.cwd());
-        const result = await release(root, terminalId, Boolean(opts.force));
-        if (result.removed) {
-            console.log(chalk.green(`removed ${worktreePathFor(root, terminalId)}`));
-        }
-        else {
-            console.log(chalk.yellow(`kept ${worktreePathFor(root, terminalId)} (${result.reason})`));
-        }
-    });
-    wt.command('prune')
-        .description('Try to release every agent worktree under .agents/worktrees/. Skips dirty or unpushed ones.')
-        .option('--root <path>', 'Repo root (defaults to current working directory)')
-        .option('--dry-run', 'Report what would be removed without touching anything')
-        .action(async (opts) => {
-        const root = await gitRoot(opts.root ?? process.cwd());
-        const ids = await listAgentWorktrees(root);
-        if (ids.length === 0) {
-            console.log(chalk.gray('no agent worktrees to prune'));
-            return;
-        }
-        for (const id of ids) {
-            if (!isValidTerminalId(id)) {
-                console.log(chalk.yellow(`skip ${id} (name not in expected format)`));
-                continue;
-            }
-            if (opts.dryRun) {
-                const report = await inspect(root, id);
-                const blocker = report.dirty
-                    ? 'dirty'
-                    : report.aheadOfUpstream
-                        ? 'unpushed'
-                        : !report.hasUpstream
-                            ? 'never pushed'
-                            : null;
-                if (blocker) {
-                    console.log(chalk.yellow(`keep   ${id} (${blocker})`));
-                }
-                else {
-                    console.log(chalk.green(`remove ${id}`));
-                }
-                continue;
-            }
-            const result = await release(root, id, false);
-            if (result.removed) {
-                console.log(chalk.green(`removed ${id}`));
-            }
-            else {
-                console.log(chalk.yellow(`kept    ${id} (${result.reason})`));
-            }
-        }
-    });
-}

package/dist/lib/account-labels.d.ts

@@ -1,24 +0,0 @@
-import type { AgentId } from './types.js';
-export interface AccountLabel {
-    agent: AgentId;
-    fingerprint: string;
-}
-export interface AccountLabelsDocument {
-    labels: Record<string, AccountLabel>;
-}
-export interface DiscoveredAccount {
-    agent: AgentId;
-    fingerprint: string;
-    display: string;
-    versions: string[];
-    label: string | null;
-}
-export declare function identityFingerprint(agent: string, accountKey: string): string;
-export declare function accountLabelsPath(base?: string): string;
-export declare function readAccountLabels(base?: string): AccountLabelsDocument;
-export declare function nameAccount(label: string, agent: AgentId, fingerprint: string, base?: string): void;
-export declare function renameAccountLabel(oldLabel: string, newLabel: string, base?: string): void;
-export declare function removeAccountLabel(label: string, base?: string): void;
-export declare function labelForFingerprint(agent: AgentId, fingerprint: string, doc?: AccountLabelsDocument): string | null;
-export declare function discoverAccounts(agentIds?: readonly AgentId[]): Promise<DiscoveredAccount[]>;
-export declare function resolveAccountLabel(agent: AgentId, label: string): Promise<string>;

package/dist/lib/account-labels.js

@@ -1,72 +0,0 @@
-import * as crypto from 'crypto';
-import * as fs from 'fs';
-import * as path from 'path';
-import * as yaml from 'yaml';
-import { atomicWriteFileSync } from './fs-atomic.js';
-import { getUserAgentsDir } from './state.js';
-import { ACCOUNT_INSPECTION_AGENT_IDS } from './agents.js';
-import { collectRunCandidates, pickBalancedCandidate } from './rotate.js';
-function emptyDocument() { return { labels: {} }; }
-export function identityFingerprint(agent, accountKey) { return crypto.createHash('sha256').update(`${agent}\0${accountKey}`).digest('hex'); }
-export function accountLabelsPath(base = getUserAgentsDir()) { return path.join(base, 'accounts.yaml'); }
-export function readAccountLabels(base = getUserAgentsDir()) {
-    const file = accountLabelsPath(base);
-    if (!fs.existsSync(file))
-        return emptyDocument();
-    const value = yaml.parse(fs.readFileSync(file, 'utf8'));
-    if (!value || typeof value !== 'object' || Array.isArray(value))
-        throw new Error(`Account labels corrupted at ${file}: expected a YAML map.`);
-    const doc = value;
-    doc.labels ??= {};
-    return doc;
-}
-function writeAccountLabels(doc, base = getUserAgentsDir()) { const file = accountLabelsPath(base); fs.mkdirSync(path.dirname(file), { recursive: true }); atomicWriteFileSync(file, yaml.stringify(doc)); }
-function assertLabel(label) { if (!/^[a-zA-Z0-9][a-zA-Z0-9._-]*$/.test(label))
-    throw new Error('Label must start with a letter or number and contain only letters, numbers, dot, underscore, or dash.'); }
-export function nameAccount(label, agent, fingerprint, base = getUserAgentsDir()) {
-    assertLabel(label);
-    const doc = readAccountLabels(base);
-    for (const [other, account] of Object.entries(doc.labels))
-        if (other !== label && account.agent === agent && account.fingerprint === fingerprint)
-            throw new Error(`This ${agent} account is already named '${other}'.`);
-    if (doc.labels[label] && (doc.labels[label].agent !== agent || doc.labels[label].fingerprint !== fingerprint))
-        throw new Error(`Account label '${label}' already names another account.`);
-    doc.labels[label] = { agent, fingerprint };
-    writeAccountLabels(doc, base);
-}
-export function renameAccountLabel(oldLabel, newLabel, base = getUserAgentsDir()) { assertLabel(newLabel); const doc = readAccountLabels(base); if (!doc.labels[oldLabel])
-    throw new Error(`Unknown account label '${oldLabel}'.`); if (doc.labels[newLabel])
-    throw new Error(`Account label '${newLabel}' already exists.`); doc.labels[newLabel] = doc.labels[oldLabel]; delete doc.labels[oldLabel]; writeAccountLabels(doc, base); }
-export function removeAccountLabel(label, base = getUserAgentsDir()) { const doc = readAccountLabels(base); if (!doc.labels[label])
-    throw new Error(`Unknown account label '${label}'.`); delete doc.labels[label]; writeAccountLabels(doc, base); }
-export function labelForFingerprint(agent, fingerprint, doc = readAccountLabels()) { return Object.entries(doc.labels).find(([, account]) => account.agent === agent && account.fingerprint === fingerprint)?.[0] ?? null; }
-export async function discoverAccounts(agentIds = ACCOUNT_INSPECTION_AGENT_IDS) {
-    const labels = readAccountLabels();
-    const grouped = new Map();
-    await Promise.all(agentIds.map(async (agent) => {
-        for (const candidate of await collectRunCandidates(agent)) {
-            if (!candidate.signedIn || !candidate.accountKey)
-                continue;
-            const fingerprint = identityFingerprint(agent, candidate.accountKey);
-            const key = `${agent}:${fingerprint}`;
-            const existing = grouped.get(key);
-            if (existing)
-                existing.versions.push(candidate.version);
-            else
-                grouped.set(key, { agent, fingerprint, display: candidate.accountLabel || 'signed-in account', versions: [candidate.version], label: labelForFingerprint(agent, fingerprint, labels) });
-        }
-    }));
-    return [...grouped.values()].sort((a, b) => a.agent.localeCompare(b.agent) || a.display.localeCompare(b.display));
-}
-export async function resolveAccountLabel(agent, label) {
-    const account = readAccountLabels().labels[label];
-    if (!account)
-        throw new Error(`Unknown account label '${label}'.`);
-    if (account.agent !== agent)
-        throw new Error(`Account label '${label}' names a ${account.agent} account, not ${agent}.`);
-    const candidates = (await collectRunCandidates(agent)).filter(candidate => candidate.accountKey && identityFingerprint(agent, candidate.accountKey) === account.fingerprint);
-    const result = pickBalancedCandidate(candidates);
-    if (!result)
-        throw new Error(`No healthy installed ${agent} version is currently signed into account '${label}'.`);
-    return result.picked.version;
-}

package/dist/lib/auto-dispatch-linear.d.ts

@@ -1,18 +0,0 @@
-/**
- * Concrete Linear gateway for auto-dispatch.
- *
- * Talks to the Linear GraphQL API. The API key is read from the LINEAR_API_KEY
- * env var, falling back to the macOS keychain generic-password `linear-api-key`
- * (how the rest of the stack stores it). If no key is resolvable, the gateway is
- * absent and the daemon skips auto-dispatch entirely.
- *
- * "Started" (Doing) and "unstarted" (Todo) are Linear state *types*, so we never
- * hardcode a team's custom state names. `startIssue` resolves the team's first
- * started-type state (cached per team) and moves the issue there — the existing
- * factory webhook turns that transition into a real run.
- */
-import type { LinearGateway } from './auto-dispatch.js';
-/** Resolve the Linear API key from env or (on macOS) the keychain. Null if absent. */
-export declare function resolveLinearApiKey(): string | null;
-/** Build a real Linear gateway, or null when no API key is configured. */
-export declare function createLinearGateway(): LinearGateway | null;