@phnx-labs/agents-cli 1.20.63 → 1.20.65

package/dist/commands/sessions.js

@@ -16,7 +16,7 @@ import { truncate, padRight } from '../lib/format.js';
 import ora from 'ora';
 import { SESSION_AGENTS } from '../lib/session/types.js';
 import { discoverArtifacts, readArtifact, resolveArtifact } from '../lib/session/artifacts.js';
-import { looksLikePath, toComparablePath, homeDir, needsWindowsShell, findExecutable } from '../lib/platform/index.js';
+import { looksLikePath, toComparablePath, homeDir, needsWindowsShell, findExecutable, composeWin32CommandLine } from '../lib/platform/index.js';
 import { getActiveSessions } from '../lib/session/active.js';
 import { enumerateGhosttyTabs, assignGhosttyTabs } from '../lib/session/ghostty-tabs.js';
 import { mapPanesToTargets, listClients } from '../lib/tmux/session.js';
@@ -25,6 +25,7 @@ import { machineId, normalizeHost } from '../lib/session/sync/config.js';
 import { gatherRemoteActive, NO_FANOUT_ENV } from '../lib/session/remote-active.js';
 import { gatherRemoteList, runOnPeer } from '../lib/session/remote-list.js';
 import { stringWidth, truncateToWidth, padToWidth, terminalWidth } from '../lib/session/width.js';
+import { inferSessionState } from '../lib/session/state.js';
 import { discoverSessions, countSessionsInScope, resolveSessionById, searchContentIndex, getSessionRoots } from '../lib/session/discover.js';
 import { filterTeamSessions } from '../lib/session/team-filter.js';
 import { parseSession } from '../lib/session/parse.js';
@@ -44,6 +45,8 @@ import { registerSessionsResumeCommand } from './sessions-resume.js';
 import { registerGoCommand } from './go.js';
 import { registerFocusCommand } from './focus.js';
 import { registerSessionsInjectCommand } from './sessions-inject.js';
+import { registerSessionsExportCommand } from './sessions-export.js';
+import { registerSessionsImportCommand } from './sessions-import.js';
 import { runBrowserSessions } from '../lib/browser/sessions-list.js';
 const SESSION_AGENT_FILTER_HELP = `Filter by agent, e.g. claude, codex, claude@2.0.65`;
 /**
@@ -1321,9 +1324,9 @@ async function renderSession(session, mode, filters, options = {}) {
         return;
     }
     const spinner = ora(`Parsing ${session.agent} session...`).start();
-    let events = parseSession(session.filePath, session.agent);
+    const parsedEvents = parseSession(session.filePath, session.agent);
     spinner.stop();
-    events = filterEvents(events, filters);
+    let events = filterEvents(parsedEvents, filters);
     const agentColor = colorAgent(session.agent);
     console.log('');
     if (mode === 'summary') {
@@ -1365,7 +1368,11 @@ async function renderSession(session, mode, filters, options = {}) {
     // engine (plan text, PR, worktree, ticket). Pre-1.20.51 emitted a bare event
     // array; consumers that JSON.parse this now read `output.events` for the
     // array. See issue #743 (plan surfaced) and CHANGELOG for the shape change.
-    process.stdout.write(renderJson(events, session));
+    // `todos` (RUSH-1503) is computed from the UNFILTERED transcript so the
+    // checklist reflects true session state regardless of any `--include` filter;
+    // it lets the Factory panel read the CLI's checklist instead of re-parsing.
+    const todos = inferSessionState(parsedEvents, { cwd: session.cwd }).todos;
+    process.stdout.write(renderJson(events, todos ? { ...session, todos } : session));
 }
 function renderTopicCell(label, topic, query, visibleWidth, paddedWidth) {
     const lbl = (label ?? '').trim();
@@ -1611,11 +1618,35 @@ export async function resumeSessionInPlace(session) {
     }
     await spawnResumeCommand(resume, cwd);
 }
+/**
+ * Map a resume argv to the spawn(command, args, {shell}) triple.
+ *
+ * On Windows the agent launcher is a `.cmd`/PATHEXT shim and needs shell:true.
+ * With shell:true, Node concatenates args into the cmd.exe line unescaped
+ * (DEP0190 + injection). A session.id derived from a filename can carry
+ * metacharacters (`&|<>`); compose a fully-quoted line and pass an EMPTY args
+ * array so cmd.exe cannot reparse them (RUSH-1753). See composeWin32CommandLine.
+ *
+ * `platform` is injectable so the win32 shell path is unit-testable on any host.
+ */
+export function resumeSpawnInvocation(cmd, platform = process.platform) {
+    const shell = needsWindowsShell(cmd[0], platform);
+    if (shell) {
+        return {
+            command: composeWin32CommandLine(cmd[0], cmd.slice(1)),
+            args: [],
+            shell: true,
+        };
+    }
+    return { command: cmd[0], args: cmd.slice(1), shell: false };
+}
 /**
  * Spawn a resume command as a foreground takeover (inherited stdio), resolving
  * when it exits. On Windows the agent launcher is a `.cmd`/PATHEXT shim that
  * `spawn` can't exec directly — a bare-name `shell:false` spawn throws
  * `EFTYPE`/`ENOENT` there — so we go through the shell via `needsWindowsShell`.
+ * When shell:true, argv is composed via resumeSpawnInvocation (quoted line +
+ * empty args) so an untrusted session.id cannot inject through cmd.exe.
  * The spawn is guarded because such a failure can be thrown synchronously;
  * without the guard it would surface under an unrelated "Failed to discover
  * sessions" catch upstream instead of a truthful launch error.
@@ -1624,10 +1655,11 @@ function spawnResumeCommand(cmd, cwd) {
     return new Promise((resolve) => {
         let child;
         try {
-            child = spawn(cmd[0], cmd.slice(1), {
+            const { command, args, shell } = resumeSpawnInvocation(cmd);
+            child = spawn(command, args, {
                 cwd,
                 stdio: 'inherit',
-                shell: needsWindowsShell(cmd[0]),
+                shell,
             });
         }
         catch (err) {
@@ -2122,6 +2154,8 @@ export function registerSessionsCommands(program) {
     registerGoCommand(sessionsCmd);
     registerFocusCommand(sessionsCmd);
     registerSessionsInjectCommand(sessionsCmd);
+    registerSessionsExportCommand(sessionsCmd);
+    registerSessionsImportCommand(sessionsCmd);
 }
 function formatNoSessionsMessage(showAll, project) {
     const projectQuery = project?.trim();

package/dist/commands/ssh.js

@@ -15,9 +15,11 @@ import * as os from 'os';
 import * as path from 'path';
 import chalk from 'chalk';
 import ora from 'ora';
-import { readAndResolveBundleEnv } from '../lib/secrets/bundles.js';
+import { readAndResolveBundleEnv, isHeadlessSecretsContext } from '../lib/secrets/bundles.js';
 import { machineId } from '../lib/session/sync/config.js';
 import { addIgnored, getDevice, loadDevices, loadIgnored, removeDevice, removeIgnored, upsertDevice, } from '../lib/devices/registry.js';
+import { addControlToken } from '../lib/serve/token.js';
+import { DEFAULT_SERVE_PORT } from '../lib/serve/server.js';
 import { nodeToDeviceInput, parseTailscaleStatus, tailscaleStatusJson, } from '../lib/devices/tailscale.js';
 import { localLoginUser, planDeviceReconciliation, runDeviceSync, withDefaultUser } from '../lib/devices/sync.js';
 import { resolveDeviceTarget, splitUserHost } from '../lib/devices/resolve-target.js';
@@ -26,6 +28,7 @@ import { isInteractiveTerminal, isPromptCancelled } from './utils.js';
 import { hostNameFor, renderSshConfig } from '../lib/devices/ssh-config.js';
 import { ASKPASS_BUNDLE_ENV, ASKPASS_KEY_ENV, buildSshInvocation, writeAskpassShim, } from '../lib/devices/connect.js';
 import { planFleetTargets, runFleet, skipLabel, upgradeCommand, } from '../lib/devices/fleet.js';
+import { fleetCapacity, fmtBytes, headroom, probeFleetStats, } from '../lib/devices/health.js';
 /** One-line summary of a device for `list`. `isSelf` marks the machine this
  * command is running on so it stands out from the rest of the tailnet. */
 function deviceSummary(d, isSelf = false) {
@@ -41,6 +44,80 @@ function deviceSummary(d, isSelf = false) {
     const here = isSelf ? chalk.cyan('  ← this machine') : '';
     return `${marker}${name} ${String(d.platform).padEnd(8)} ${(d.user ? d.user + '@' : '') + addr}  ${online}${reach}${here}`;
 }
+const HEADROOM_BADGE = {
+    idle: chalk.green('○ idle'),
+    light: chalk.green('● light'),
+    busy: chalk.yellow('● busy'),
+    loaded: chalk.red('● loaded'),
+    unknown: chalk.gray('· —'),
+};
+/** A right-aligned percentage cell, colored by severity (green/yellow/red). */
+function pctCell(v, width) {
+    if (v === undefined)
+        return chalk.gray('—'.padStart(width));
+    const s = `${Math.round(v)}%`.padStart(width);
+    if (v < 40)
+        return chalk.green(s);
+    if (v < 75)
+        return chalk.yellow(s);
+    return chalk.red(s);
+}
+/**
+ * Render the device list. When `statsMap` is provided, resource columns are
+ * appended — normalized load, memory, a headroom badge, and (in `full` mode)
+ * core count and free/total memory — so it's obvious which boxes have room.
+ * Without it (probe skipped) the classic reachability line is used. A fleet
+ * capacity summary is appended whenever stats were gathered.
+ */
+function renderDeviceTable(reg, names, self, statsMap, full = false) {
+    if (!statsMap)
+        return names.map((n) => deviceSummary(reg[n], n === self));
+    const lines = [];
+    const head = '  ' +
+        chalk.gray('device'.padEnd(16)) +
+        chalk.gray('platform'.padEnd(8)) +
+        ' ' +
+        (full ? chalk.gray('cores'.padStart(6)) : '') +
+        chalk.gray('load'.padStart(5)) +
+        chalk.gray('mem'.padStart(6)) +
+        (full ? '  ' + chalk.gray('free/total'.padEnd(12)) : '') +
+        '  ' +
+        chalk.gray('headroom');
+    lines.push(head);
+    for (const name of names) {
+        const d = reg[name];
+        const isSelf = name === self;
+        const marker = isSelf ? chalk.cyan('▸ ') : '  ';
+        const label = isSelf ? chalk.bold.cyan(name.padEnd(16)) : chalk.bold(name.padEnd(16));
+        const plat = String(d.platform).padEnd(8);
+        const offline = d.tailscale && !d.tailscale.online;
+        const stats = statsMap.get(name);
+        if (offline) {
+            lines.push(`${marker}${label}${plat} ${chalk.gray('offline')}`);
+            continue;
+        }
+        const relay = !isSelf && d.tailscale?.online && !d.tailscale.direct ? chalk.yellow(' relay') : '';
+        const cores = full ? chalk.gray(String(stats?.ncpu ?? '—').padStart(6)) : '';
+        const load = pctCell(stats?.loadPercent, 5);
+        const mem = pctCell(stats?.memPercent, 6);
+        const freeTotal = full
+            ? '  ' +
+                (stats?.reachable && stats.memTotalBytes
+                    ? `${fmtBytes(stats.memFreeBytes)}/${fmtBytes(stats.memTotalBytes)}`.padEnd(12)
+                    : chalk.gray('—'.padEnd(12)))
+            : '';
+        const badge = HEADROOM_BADGE[headroom(stats)];
+        const here = isSelf ? chalk.cyan('  ← this machine') : '';
+        lines.push(`${marker}${label}${plat} ${cores}${load}${mem}${freeTotal}  ${badge}${relay}${here}`);
+    }
+    // Fleet capacity summary — total cores + how much RAM is free right now.
+    const cap = fleetCapacity(statsMap.values());
+    if (cap.reachable > 0) {
+        const freePct = cap.memTotalBytes > 0 ? Math.round((cap.memFreeBytes / cap.memTotalBytes) * 100) : 0;
+        lines.push(chalk.gray(`  Fleet capacity: ${cap.cores} cores · ${fmtBytes(cap.memFreeBytes)} free / ${fmtBytes(cap.memTotalBytes)} RAM (${freePct}% free) across ${cap.reachable} reachable device${cap.reachable === 1 ? '' : 's'}`));
+    }
+    return lines;
+}
 /** Resolve a device or exit with a clear error. */
 async function mustGetDevice(name) {
     const d = await getDevice(name);
@@ -230,12 +307,15 @@ Typical workflow:
     devicesCmd
         .command('list')
         .alias('ls')
-        .description('List registered devices with platform, address, and reachability.')
+        .description('List registered devices with platform, address, reachability, and live resource headroom.')
         .option('--json', 'output the registry as a JSON array (for scripts and hooks)')
+        .option('--no-stats', 'skip the live resource probe (instant; names/addresses only)')
+        .option('-f, --full', 'full mode: add per-device core count and free/total memory')
         .action(async (opts) => {
         const reg = await loadDevices();
         const names = Object.keys(reg).sort();
         if (opts.json) {
+            // Registry-only, always fast — the Factory extension polls this path.
             process.stdout.write(JSON.stringify(names.map((n) => reg[n]), null, 2) + '\n');
             return;
         }
@@ -244,9 +324,26 @@ Typical workflow:
             return;
         }
         const self = machineId();
+        let statsMap;
+        if (opts.stats !== false) {
+            // Probe only reachable devices, in parallel, bounded by the per-probe
+            // timeout — a slow box degrades to "—", it never hangs the table.
+            const probeable = planFleetTargets(reg)
+                .filter((t) => !t.skip)
+                .map((t) => t.device);
+            const spinner = isInteractiveTerminal()
+                ? ora(`Probing ${probeable.length} device${probeable.length === 1 ? '' : 's'}…`).start()
+                : undefined;
+            try {
+                statsMap = await probeFleetStats(probeable, { selfName: self });
+            }
+            finally {
+                spinner?.stop();
+            }
+        }
         console.log(chalk.bold(`Devices (${names.length})`));
-        for (const name of names)
-            console.log(deviceSummary(reg[name], name === self));
+        for (const line of renderDeviceTable(reg, names, self, statsMap, opts.full))
+            console.log(line);
     });
     devicesCmd
         .command('show <name>')
@@ -305,6 +402,47 @@ Typical workflow:
             process.exit(1);
         }
     });
+    devicesCmd
+        .command('pair-ios [name]')
+        .description('Pair an iPhone/iPad cockpit (RUSH-1733): mint a control token for `agents serve --control` and mark the device control-only. The token is shown ONCE — enter it in the app. Run this on the anchor.')
+        .option('--port <n>', 'Anchor control port to advertise to the app', String(DEFAULT_SERVE_PORT))
+        .action(async (name, opts) => {
+        const label = (name || 'iphone').trim();
+        // Mint the bearer token — hash-only on disk, raw shown once (see serve/token.ts).
+        const { id, token } = addControlToken(label);
+        // If a device with this name is already registered (e.g. discovered over
+        // Tailscale as an `unknown`-platform node), mark it control-only so the
+        // fleet stops trying to dial it for sessions/placement.
+        let marked = false;
+        let unknownName = false;
+        if (name) {
+            const existing = await getDevice(name);
+            if (existing) {
+                await upsertDevice(name, { role: 'control' });
+                marked = true;
+            }
+            else {
+                unknownName = true;
+            }
+        }
+        const port = parseInt(opts.port ?? '', 10) || DEFAULT_SERVE_PORT;
+        console.log(chalk.green(`Paired cockpit '${label}'`) + chalk.gray(` (token id ${id})`));
+        if (marked)
+            console.log(chalk.gray(`Marked device '${name}' role=control — the fleet won't dial it.`));
+        if (unknownName) {
+            console.log(chalk.yellow(`Note: no registered device named '${name}' — token minted, but no device was marked role=control.`) +
+                chalk.gray(` Run \`agents devices sync\` first if this phone should appear in the fleet.`));
+        }
+        console.log();
+        console.log(chalk.bold('Control token (shown once — enter it in the app):'));
+        console.log('  ' + chalk.cyan(token));
+        console.log();
+        console.log('On the anchor, expose the control server on your tailnet:');
+        console.log(chalk.gray(`  agents serve --control --bind <anchor-tailnet-ip> --port ${port}`));
+        console.log('Then point the app at:');
+        console.log(chalk.gray(`  http://<anchor-tailnet-ip>:${port}   (Bearer: the token above)`));
+        console.log(chalk.yellow('Keep the control server on the tailnet — never public Funnel.'));
+    });
     devicesCmd
         .command('rm <name>')
         .alias('remove')
@@ -449,7 +587,7 @@ async function runAskpass() {
         process.exit(1);
     }
     try {
-        const { env } = readAndResolveBundleEnv(bundle, { caller: 'agents ssh' });
+        const { env } = readAndResolveBundleEnv(bundle, { caller: 'agents ssh', agentOnly: isHeadlessSecretsContext() });
         const value = env[key];
         if (value === undefined) {
             console.error(`askpass: key '${key}' not found in bundle '${bundle}'`);

package/dist/commands/usage.d.ts

@@ -4,6 +4,8 @@
  * Lists every installed agent with the best available usage snapshot:
  *   - claude: live OAuth API call (cached for 2 minutes)
  *   - codex:  parsed from latest session log's rate_limits event
+ *   - kimi:   live Kimi Code /usages API call (cached for 2 minutes)
+ *   - droid:  live Factory billing/limits API call (cached for 2 minutes)
  *   - others: marked as "not exposed by CLI" (Gemini, OpenCode, Cursor, etc.
  *     don't publish per-account usage today)
  */

package/dist/commands/usage.js

@@ -3,8 +3,13 @@ import chalk from 'chalk';
 import { ALL_AGENT_IDS, AGENTS, getAccountInfo, agentLabel, resolveAgentName, formatAgentError, } from '../lib/agents.js';
 import { listInstalledVersions, getGlobalDefault, getVersionHomePath } from '../lib/versions.js';
 import { formatUsageSection, getUsageInfoForIdentity } from '../lib/usage.js';
-/** Agents whose CLI surfaces usage data we can read today. */
-const USAGE_SUPPORTED = new Set(['claude', 'codex']);
+/**
+ * Agents whose CLI surfaces usage data we can read today. Kept in sync with the
+ * live/last-seen sources `getUsageInfo` dispatches on in `../lib/usage.js`
+ * (claude, codex, kimi, droid) — an agent with a usage source but missing here
+ * would wrongly print "does not publish usage data" for a signed-in account.
+ */
+const USAGE_SUPPORTED = new Set(['claude', 'codex', 'kimi', 'droid']);
 export function registerUsageCommand(program) {
     addHostOption(program.command('usage [agent]'))
         .description('Show rate-limit / quota usage per agent')

package/dist/commands/versions.js

@@ -4,7 +4,7 @@ import ora from 'ora';
 import * as fs from 'fs';
 import * as path from 'path';
 import { select, confirm, checkbox } from '@inquirer/prompts';
-import { AGENTS, ALL_AGENT_IDS, getAccountEmail, getAccountInfo, agentLabel, warnAgentDeprecated, isSelfUpdatingAgent, } from '../lib/agents.js';
+import { AGENTS, ALL_AGENT_IDS, accountOrgBadge, getAccountEmail, getAccountInfo, agentLabel, warnAgentDeprecated, isSelfUpdatingAgent, } from '../lib/agents.js';
 import { formatUsageSummary, getUsageInfoForIdentity, getUsageInfoByIdentity, getUsageLookupKey, } from '../lib/usage.js';
 import { viewAction } from './view.js';
 import { readManifest, writeManifest, createDefaultManifest } from '../lib/manifest.js';
@@ -32,8 +32,12 @@ function fixSessionFilePaths(agent, version, oldVersionDir) {
 }
 function formatAccountHint(info, usage) {
     const parts = [];
-    if (info.email)
-        parts.push(info.email);
+    if (info.email) {
+        // Same-email accounts can live in different orgs (personal Max vs a Team
+        // seat) — the badge is what makes the picker disambiguate them.
+        const badge = accountOrgBadge(info);
+        parts.push(badge ? `${info.email} (${badge})` : info.email);
+    }
     const usageSummary = formatUsageSummary(info.plan, usage);
     if (usageSummary)
         parts.push(usageSummary);

package/dist/commands/view.d.ts

@@ -7,8 +7,23 @@
  * rules, hooks, and promptcuts synced to that version.
  */
 import type { Command } from 'commander';
+import type { AccountInfo } from '../lib/agents.js';
 import type { AgentId } from '../lib/types.js';
 import { type ProfileSummary } from '../lib/profiles.js';
+/**
+ * Text for the account (email) column. Prefers the real email; otherwise, for a
+ * signed-in agent whose credential carries no email but does carry an opaque
+ * account id (Kimi's user_id), show `id:<user_id>` so distinct accounts read
+ * distinctly instead of a generic "signed in". Falls back to "signed in" when we
+ * have neither (Antigravity), and empty when signed out.
+ *
+ * When the account carries a Claude organizationType, the org badge is appended
+ * — "email (Turing Labs · Team)" — so two installs signed into the same email
+ * under different orgs (personal Max vs a Team seat) read distinctly. The
+ * suffix is plain text inside the label so the existing column-width pass
+ * measures and pads it for free.
+ */
+export declare function accountColumnLabel(info?: Pick<AccountInfo, 'email' | 'accountId' | 'signedIn' | 'organizationType' | 'organizationName'> | null): string;
 type SyncState = 'synced' | 'new' | 'modified' | 'deleted';
 /** Per-section filter flags. When any are true, only those sections render. */
 export interface ViewSectionFilter {
@@ -32,6 +47,8 @@ export interface ViewJsonVersion {
     signedIn: boolean;
     email: string | null;
     accountId?: string | null;
+    organizationType?: string | null;
+    organizationName?: string | null;
     plan: string | null;
     usageStatus: 'available' | 'rate_limited' | 'out_of_credits' | null;
     overageCredits?: {
@@ -39,7 +56,7 @@ export interface ViewJsonVersion {
         currency: string;
     } | null;
     windows: Array<{
-        key: 'session' | 'week' | 'sonnet_week';
+        key: 'session' | 'week' | 'sonnet_week' | 'month';
         usedPercent: number;
         resetsAt: string | null;
     }>;
@@ -86,6 +103,15 @@ export declare function parseResourceSections(options: {
     resources?: string | boolean;
     detailed?: boolean;
 } & ViewSectionFilter, jsonMode: boolean): Set<ResourceSection>;
+/**
+ * Identity key for duplicate-install detection. Prefers accountKey — which
+ * encodes account AND org — over the bare email: two installs can share an
+ * email yet belong to different orgs (a personal Max plan and a Team seat),
+ * and grouping those by email alone would propose pruning a live account.
+ * Falls back to the lowercased email for agents whose credentials expose no
+ * identity key. Null when there is no usable identity.
+ */
+export declare function pruneGroupKey(info: Pick<AccountInfo, 'accountKey' | 'email'>): string | null;
 /**
  * Prune older installed versions that share an email with a newer installed
  * version. Keeps the highest semver per email, skips the global default (with

package/dist/commands/view.js

@@ -4,7 +4,7 @@ import { visibleWidth, termLink } from '../lib/format.js';
 import ora from 'ora';
 import * as fs from 'fs';
 import * as path from 'path';
-import { AGENTS, ALL_AGENT_IDS, getAllCliStates, getAccountInfo, resolveAgentName, formatAgentError, agentLabel, colorAgent, } from '../lib/agents.js';
+import { AGENTS, ALL_AGENT_IDS, accountOrgBadge, getAllCliStates, getAccountInfo, resolveAgentName, formatAgentError, agentLabel, colorAgent, } from '../lib/agents.js';
 import { deriveUsageStatusFromSnapshot, formatUsageSection, formatUsageSummary, formatUsageStatusBadge, getUsageInfoForIdentity, getUsageInfoByIdentity, getUsageLookupKey, } from '../lib/usage.js';
 import { readManifest } from '../lib/manifest.js';
 import { listInstalledVersions, listInstalledVersionDirs, getGlobalDefault, getVersionHomePath, getVersionDir, getAvailableResources, getActuallySyncedResources, getNewResources, getProjectOnlyResources, hasNewResources, promptNewResourceSelection, syncResourcesToVersion, removeVersion, printTrashFooter, reconcileStaleLatestForAgent, isGlobalBinaryAgent, getLiveVersion, } from '../lib/versions.js';
@@ -34,12 +34,20 @@ const SIGNED_IN_LABEL = 'signed in';
  * account id (Kimi's user_id), show `id:<user_id>` so distinct accounts read
  * distinctly instead of a generic "signed in". Falls back to "signed in" when we
  * have neither (Antigravity), and empty when signed out.
+ *
+ * When the account carries a Claude organizationType, the org badge is appended
+ * — "email (Turing Labs · Team)" — so two installs signed into the same email
+ * under different orgs (personal Max vs a Team seat) read distinctly. The
+ * suffix is plain text inside the label so the existing column-width pass
+ * measures and pads it for free.
  */
-function accountColumnLabel(info) {
+export function accountColumnLabel(info) {
     if (!info)
         return '';
-    if (info.email)
-        return info.email;
+    if (info.email) {
+        const badge = accountOrgBadge(info);
+        return badge ? `${info.email} (${badge})` : info.email;
+    }
     if (info.signedIn)
         return info.accountId ? `id:${info.accountId}` : SIGNED_IN_LABEL;
     return '';
@@ -1149,6 +1157,8 @@ async function collectAgentsJson(filterAgentId, resourceSections) {
             signedIn: info.signedIn,
             email: info.email,
             accountId: info.accountId,
+            organizationType: info.organizationType ?? null,
+            organizationName: info.organizationName ?? null,
             plan: info.plan,
             usageStatus: info.usageStatus,
             overageCredits: info.overageCredits,
@@ -1184,6 +1194,17 @@ async function collectAgentsJson(filterAgentId, resourceSections) {
     }
     return out;
 }
+/**
+ * Identity key for duplicate-install detection. Prefers accountKey — which
+ * encodes account AND org — over the bare email: two installs can share an
+ * email yet belong to different orgs (a personal Max plan and a Team seat),
+ * and grouping those by email alone would propose pruning a live account.
+ * Falls back to the lowercased email for agents whose credentials expose no
+ * identity key. Null when there is no usable identity.
+ */
+export function pruneGroupKey(info) {
+    return info.accountKey ?? info.email?.toLowerCase() ?? null;
+}
 async function buildAgentPrunePlan(agentId) {
     const dirInfos = listInstalledVersionDirs(agentId);
     const entries = await Promise.all(dirInfos.map(async ({ version, hasBinary }) => {
@@ -1198,16 +1219,18 @@ async function buildAgentPrunePlan(agentId) {
     // working binary — those are the things that compete for "the live install
     // for this account."
     const installed = entries.filter((e) => e.hasBinary);
-    const byEmail = new Map();
+    const byAccount = new Map();
     for (const e of installed) {
         if (!e.info.email)
             continue;
-        const key = e.info.email.toLowerCase();
-        const list = byEmail.get(key) ?? [];
+        const key = pruneGroupKey(e.info);
+        if (!key)
+            continue;
+        const list = byAccount.get(key) ?? [];
         list.push(e);
-        byEmail.set(key, list);
+        byAccount.set(key, list);
     }
-    for (const [, group] of byEmail) {
+    for (const [, group] of byAccount) {
         if (group.length < 2)
             continue;
         const sorted = [...group].sort((a, b) => compareVersions(b.version, a.version));

package/dist/commands/webhook.js

@@ -1,6 +1,8 @@
+import * as path from 'path';
 import chalk from 'chalk';
-import { readAndResolveBundleEnv } from '../lib/secrets/bundles.js';
-import { startWebhookServer } from '../lib/triggers/webhook.js';
+import { readAndResolveBundleEnv, isHeadlessSecretsContext } from '../lib/secrets/bundles.js';
+import { createFileDeliveryStore, startWebhookServer } from '../lib/triggers/webhook.js';
+import { getRuntimeStateDir } from '../lib/state.js';
 const DEFAULT_HOST = '127.0.0.1';
 const DEFAULT_PORT = 8787;
 function positiveInt(value, fallback) {
@@ -10,6 +12,9 @@ function positiveInt(value, fallback) {
 function readWebhookSecrets(bundleName) {
     const { env } = readAndResolveBundleEnv(bundleName, {
         caller: 'webhook serve',
+        // `webhook serve` is a long-running background server; when started detached
+        // (no TTY) it must resolve broker-only rather than pop an unanswerable prompt.
+        agentOnly: isHeadlessSecretsContext(),
     });
     const secrets = {};
     if (env.GITHUB_WEBHOOK_SECRET)
@@ -69,6 +74,9 @@ export function registerWebhookCommand(program) {
                 port,
                 secrets,
                 rateLimitPerMinute: rateLimit,
+                // Durable delivery dedup: replays survive a receiver restart (an
+                // in-memory store would forget every seen delivery on restart).
+                deliveryStore: createFileDeliveryStore(path.join(getRuntimeStateDir(), 'webhook', 'deliveries.json')),
                 onDelivery: (webhook, fired) => {
                     console.log(`${new Date().toISOString()} ${webhook.source}:${webhook.event} ` +
                         `${fired.length ? `fired ${fired.map((f) => f.jobName).join(', ')}` : 'no match'}`);

package/dist/index.js

@@ -26,7 +26,7 @@ const __dirname = path.dirname(fileURLToPath(import.meta.url));
 const packageJsonPath = path.join(__dirname, '..', 'package.json');
 const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf-8'));
 const VERSION = packageJson.version;
-import { NPM_PACKAGE_NAME, deriveGlobalPrefix, detectPackageManager, installPackageIntoPrefix, installPackageWithBun, verifyInstalledVersion, refreshAliasShims, } from './lib/self-update.js';
+import { NPM_PACKAGE_NAME, deriveGlobalPrefix, detectPackageManager, installPackageIntoPrefix, installPackageWithBun, verifyInstalledVersion, refreshAliasShims, downloadVerifiedTarball, } from './lib/self-update.js';
 // Detect dev/working-tree builds and default the noisy startup steps off.
 // Three cases trip this:
 //   1. Dev install (scripts/install.sh) — package.json version stamped 0.0.0-dev.<sha>
@@ -50,7 +50,7 @@ if (IS_DEV_BUILD) {
 // module on each invocation (which loaded the whole ~50-module tree before the
 // first byte of output), the registry maps a command name to a thunk that
 // imports only what that command needs. See src/lib/startup/command-registry.ts.
-import { COMMAND_LOADERS, LAZY_COMMAND_NAMES, loadView, loadInspect, loadFeedback, loadCommands, loadHooks, loadSkills, loadRules, loadMemory, loadPermissions, loadMcp, loadCli, loadSubagents, loadPlugins, loadWorkflows, loadWorktree, loadVersions, loadImport, loadPackages, loadDaemon, loadRoutines, loadRun, loadDefaults, loadModels, loadPrune, loadTrash, loadRestore, loadDoctor, loadCheck, loadStatus, loadProfiles, loadSecrets, loadWallet, loadHelper, loadMenubar, loadBeta, loadSync, loadLock, loadRefreshRules, loadDrive, loadFactory, loadUsage, loadCost, loadOutput, loadBudget, loadAlias, loadPty, loadTmux, loadWatchdog, loadBrowser, loadComputer, loadHosts, loadLogs, loadEvents, loadAudit, loadWebhook, loadFunnel, loadSsh, loadPull, loadPush, loadRepo, loadSetup, loadFeed, } from './lib/startup/command-registry.js';
+import { COMMAND_LOADERS, LAZY_COMMAND_NAMES, loadView, loadInspect, loadFeedback, loadCommands, loadHooks, loadSkills, loadRules, loadMemory, loadPermissions, loadMcp, loadCli, loadSubagents, loadPlugins, loadWorkflows, loadWorktree, loadVersions, loadImport, loadPackages, loadDaemon, loadRoutines, loadMonitors, loadRun, loadDefaults, loadModels, loadPrune, loadTrash, loadRestore, loadDoctor, loadApply, loadCheck, loadStatus, loadProfiles, loadSecrets, loadWallet, loadHelper, loadMenubar, loadBeta, loadSync, loadLock, loadRefreshRules, loadDrive, loadFactory, loadUsage, loadCost, loadOutput, loadBudget, loadAlias, loadPty, loadTmux, loadWatchdog, loadBrowser, loadComputer, loadHosts, loadLogs, loadEvents, loadAudit, loadWebhook, loadFunnel, loadSsh, loadPull, loadPush, loadRepo, loadSetup, loadFeed, loadMailboxes, } from './lib/startup/command-registry.js';
 import { applyGlobalHelpConventions } from './lib/help.js';
 import { renderWhatsNew } from './lib/whats-new.js';
 import { emit, redactArgs } from './lib/events.js';
@@ -315,10 +315,12 @@ async function fetchNpmPackageMetadata(versionOrTag = 'latest', timeoutMs = 5000
         throw new Error('Could not reach npm registry');
     }
     const data = await response.json();
-    if (typeof data.version !== 'string' || typeof data.dist?.integrity !== 'string') {
-        throw new Error('npm registry response did not include version and integrity');
+    if (typeof data.version !== 'string' ||
+        typeof data.dist?.integrity !== 'string' ||
+        typeof data.dist?.tarball !== 'string') {
+        throw new Error('npm registry response did not include version, integrity, and tarball');
     }
-    return { version: data.version, integrity: data.dist.integrity };
+    return { version: data.version, integrity: data.dist.integrity, tarball: data.dist.tarball };
 }
 function printResolvedPackage(metadata) {
     console.log(chalk.gray(`Resolved: ${NPM_PACKAGE_NAME}@${metadata.version}`));
@@ -326,16 +328,32 @@ function printResolvedPackage(metadata) {
 }
 async function installResolvedPackage(metadata) {
     const packageRoot = path.resolve(__dirname, '..');
-    const spec = `${NPM_PACKAGE_NAME}@${metadata.version}`;
-    // Upgrade with the package manager that owns this install. A bun global
-    // install lives at <bunGlobalDir>/node_modules/... (no `lib` segment), so an
-    // `npm install --prefix` would write to <bunGlobalDir>/lib/node_modules and
-    // never touch the running copy — npm exits 0, the verify below fails.
-    if (detectPackageManager(packageRoot) === 'bun') {
-        await installPackageWithBun(spec);
+    // Download the published tarball and prove its bytes match the registry
+    // integrity BEFORE installing anything. A `name@version` spec would let the
+    // package manager fetch and install whatever the registry serves with no
+    // hash check on our side; instead we verify here and install the LOCAL, now
+    // trusted .tgz. A mismatch throws and nothing below runs — fail closed.
+    const tarball = await downloadVerifiedTarball(metadata.tarball, metadata.integrity);
+    try {
+        // Upgrade with the package manager that owns this install. A bun global
+        // install lives at <bunGlobalDir>/node_modules/... (no `lib` segment), so an
+        // `npm install --prefix` would write to <bunGlobalDir>/lib/node_modules and
+        // never touch the running copy — npm exits 0, the verify below fails.
+        if (detectPackageManager(packageRoot) === 'bun') {
+            await installPackageWithBun(tarball);
+        }
+        else {
+            await installPackageIntoPrefix(tarball, deriveGlobalPrefix(packageRoot));
+        }
     }
-    else {
-        await installPackageIntoPrefix(spec, deriveGlobalPrefix(packageRoot));
+    finally {
+        // Best-effort cleanup of the verified tarball and its temp dir.
+        try {
+            fs.rmSync(path.dirname(tarball), { recursive: true, force: true });
+        }
+        catch {
+            /* leave it for the OS temp sweep */
+        }
     }
     verifyInstalledVersion(packageRoot, metadata.version);
     refreshAliasShims(packageRoot);
@@ -669,6 +687,7 @@ async function registerAllEagerCommands() {
     await reg(loadPackages);
     await reg(loadDaemon);
     await reg(loadRoutines);
+    await reg(loadMonitors);
     await reg(loadRun);
     await reg(loadDefaults);
     await reg(loadModels);
@@ -676,6 +695,7 @@ async function registerAllEagerCommands() {
     await reg(loadTrash);
     await reg(loadRestore);
     await reg(loadDoctor);
+    await reg(loadApply);
     await reg(loadCheck);
     await reg(loadStatus);
     registerExecAliasCommand(program);
@@ -707,6 +727,7 @@ async function registerAllEagerCommands() {
     await reg(loadWebhook);
     await reg(loadFunnel);
     await reg(loadFeed);
+    await reg(loadMailboxes);
     await reg(loadSsh);
     registerJobsCronAliasCommand(program, 'jobs');
     registerJobsCronAliasCommand(program, 'cron');