@phnx-labs/agents-cli 1.22.7 → 1.22.9

package/dist/commands/sessions-render.d.ts

@@ -0,0 +1,12 @@
+import type { Command } from 'commander';
+import type { SessionMeta } from '../lib/session/types.js';
+export declare const MARKDOWN_RENDER_AGENTS: readonly ["claude", "codex", "gemini", "antigravity", "opencode", "grok", "rush", "hermes", "kimi", "droid", "cursor"];
+export type ReasoningMode = 'omit' | 'fold' | 'include';
+/** Build one shareable Markdown document from the canonical preview and event model. */
+export declare function renderSessionMarkdownDocument(session: SessionMeta, options?: {
+    redact?: boolean;
+    reasoning?: ReasoningMode;
+    knownSecrets?: readonly string[];
+    maxToolOutputChars?: number;
+}): string;
+export declare function registerSessionsRenderCommand(sessionsCmd: Command): void;

package/dist/commands/sessions-render.js

@@ -0,0 +1,124 @@
+/** Render selected normalized session transcripts as redacted Markdown documents. */
+import * as fs from 'fs';
+import { stripVTControlCharacters } from 'node:util';
+import chalk from 'chalk';
+import { setHelpSections } from '../lib/help.js';
+import { knownSecretValuesFromEnv, redactSecrets } from '../lib/redact.js';
+import { discoverSessions } from '../lib/session/discover.js';
+import { parseSession } from '../lib/session/parse.js';
+import { extractSessionTopic, isSyntheticUserMessage } from '../lib/session/prompt.js';
+import { renderConversationMarkdown } from '../lib/session/render.js';
+import { buildPreview } from './sessions-picker.js';
+import { parseAgentFilter } from './sessions.js';
+import { selectSessions } from './sessions-export.js';
+export const MARKDOWN_RENDER_AGENTS = [
+    'claude',
+    'codex',
+    'gemini',
+    'antigravity',
+    'opencode',
+    'grok',
+    'rush',
+    'hermes',
+    'kimi',
+    'droid',
+    'cursor',
+];
+function parseReasoning(value) {
+    if (value === 'omit' || value === 'fold' || value === 'include')
+        return value;
+    throw new Error(`Unknown reasoning mode "${value}". Expected omit, fold, or include.`);
+}
+function quotePreview(preview) {
+    return preview.split('\n').map((line) => `> ${line}`).join('\n');
+}
+/** Build one shareable Markdown document from the canonical preview and event model. */
+export function renderSessionMarkdownDocument(session, options = {}) {
+    if (!MARKDOWN_RENDER_AGENTS.includes(session.agent)) {
+        throw new Error(`Cannot render ${session.agent} session ${session.shortId || session.id}: Markdown rendering supports ${MARKDOWN_RENDER_AGENTS.join(', ')}.`);
+    }
+    // Preserve normalized tool output here so the Markdown renderer owns the
+    // visible cap and can report exactly how much it omitted.
+    const events = parseSession(session.filePath, session.agent, { maxToolOutputChars: Infinity });
+    if (events.length === 0) {
+        throw new Error(`Cannot render ${session.agent} session ${session.shortId || session.id}: transcript produced no normalized events.`);
+    }
+    const shouldRedact = options.redact !== false;
+    const sanitize = (text) => shouldRedact ? redactSecrets(text, options.knownSecrets) : text;
+    const preview = sanitize(stripVTControlCharacters(buildPreview(session)));
+    const shareEvents = events.filter((event) => !(event.type === 'message' && event._synthetic));
+    const firstPrompt = shareEvents.find((event) => event.type === 'message' && event.role === 'user')?.content;
+    const title = sanitize(session.label || (firstPrompt ? extractSessionTopic(firstPrompt) : undefined) ||
+        (session.topic && !isSyntheticUserMessage(session.topic) ? session.topic : undefined) ||
+        `${session.agent} session ${session.shortId || session.id}`);
+    const conversation = renderConversationMarkdown(shareEvents, {
+        redact: shouldRedact,
+        knownSecrets: options.knownSecrets,
+        reasoning: options.reasoning ?? 'omit',
+        maxToolOutputChars: options.maxToolOutputChars,
+    });
+    return `# ${title}\n\n## Session preview\n\n${quotePreview(preview)}\n\n## Conversation\n\n${conversation}\n`;
+}
+export function registerSessionsRenderCommand(sessionsCmd) {
+    const cmd = sessionsCmd
+        .command('render <selectors...>')
+        .description('Render one or more sessions as readable, redacted Markdown for review or sharing.')
+        .option('--format <format>', 'Output format (md or markdown)', 'md')
+        .option('-o, --output <path>', 'Write the rendered document to a file instead of stdout')
+        .option('--reasoning <mode>', 'Reasoning visibility: omit, fold, or include', 'omit');
+    setHelpSections(cmd, {
+        examples: `# Render one redacted session for a confidential gist
+agents sessions render a1b2c3d4 -o session.md
+
+# Combine several sessions into one Markdown document
+agents sessions render a1b2c3d4 d4c3b2a1 -o delivery-sessions.md
+
+# Keep reasoning locally in collapsible sections and opt out of redaction
+agents sessions render a1b2c3d4 --reasoning fold --no-redact`,
+        notes: `Markdown is redacted by default, including credential-shaped values and local home paths.
+The preview at the top is the same preview shown by 'agents sessions'. Tool output is truncated
+with an explicit note. Use --no-redact only for local output that will not be shared.`,
+    });
+    cmd.action(async (selectors, options, command) => {
+        const globals = command.optsWithGlobals();
+        if (!['md', 'markdown'].includes(options.format.toLowerCase())) {
+            throw new Error(`Unknown format "${options.format}". Expected md or markdown.`);
+        }
+        const reasoning = parseReasoning(options.reasoning);
+        const limit = Math.max(1, Number.parseInt(globals.limit || '100', 10) || 100);
+        const agent = parseAgentFilter(globals.agent).agent;
+        const sessions = selectSessions(await discoverSessions({
+            all: globals.all !== false,
+            since: globals.since,
+            limit,
+            agent: agent ?? undefined,
+        }), selectors);
+        if (sessions.length === 0) {
+            process.stderr.write(chalk.yellow('No sessions matched the selection.\n'));
+            process.exitCode = 1;
+            return;
+        }
+        const knownSecrets = globals.redact === false ? undefined : knownSecretValuesFromEnv();
+        const rendered = sessions.map((session) => ({
+            id: session.id,
+            agent: session.agent,
+            markdown: renderSessionMarkdownDocument(session, {
+                redact: globals.redact !== false,
+                reasoning,
+                knownSecrets,
+            }),
+        }));
+        const markdown = rendered.map((item) => item.markdown.trimEnd()).join('\n\n---\n\n') + '\n';
+        if (options.output)
+            fs.writeFileSync(options.output, markdown, { mode: 0o600 });
+        if (globals.json) {
+            process.stdout.write(JSON.stringify({ redacted: globals.redact !== false, reasoning, sessions: rendered }, null, 2) + '\n');
+        }
+        else if (!options.output) {
+            process.stdout.write(markdown);
+        }
+        else {
+            process.stderr.write(chalk.green(`Rendered ${rendered.length} session${rendered.length === 1 ? '' : 's'} to ${options.output}\n`));
+        }
+    });
+}

package/dist/commands/sessions.js

@@ -56,6 +56,7 @@ import { registerDetachCommand } from './detach.js';
 import { registerAttachCommand } from './attach.js';
 import { registerSessionsInjectCommand } from './sessions-inject.js';
 import { registerSessionsExportCommand } from './sessions-export.js';
+import { registerSessionsRenderCommand } from './sessions-render.js';
 import { registerSessionsImportCommand } from './sessions-import.js';
 import { registerSessionsMigrateCommand, registerSessionsMigrationsCommand } from './sessions-migrate.js';
 import { registerSessionsBackfillCommand } from './sessions-backfill.js';
@@ -3584,7 +3585,7 @@ export function registerSessionsCommands(program) {
         .option('--query <clause>', 'Search text; repeat with --include tools to require distinct matching calls', collectQueryClause, [])
         .option('--resolve <selector>', 'Resolve one full ID, unique prefix, or keyword query to safe session metadata (requires --json; searches the fleet unless --local)')
         .addOption(new Option('--resolve-safe-v1 <selector>').hideHelp())
-        .description('Find, browse, and read agent conversation transcripts across Claude, Codex, Gemini, and OpenCode.')
+        .description('Find, browse, and read agent conversation transcripts. Live roster: `agents sessions --active` (alias: `agents roster`).')
         .option('-a, --agent <agent>', 'Filter by agent type and version (e.g., claude, codex@0.116.0)')
         .option('--claude', 'Shorthand for --agent claude')
         .option('--codex', 'Shorthand for --agent codex')
@@ -3735,11 +3736,37 @@ export function registerSessionsCommands(program) {
     registerAttachCommand(sessionsCmd);
     registerSessionsInjectCommand(sessionsCmd);
     registerSessionsExportCommand(sessionsCmd);
+    registerSessionsRenderCommand(sessionsCmd);
     registerSessionsImportCommand(sessionsCmd);
     registerSessionsMigrateCommand(sessionsCmd);
     registerSessionsMigrationsCommand(sessionsCmd);
     registerSessionsBackfillCommand(sessionsCmd);
     registerSessionsStatsCommand(sessionsCmd);
+    // Observe-umbrella alias (Phase 3): roster → sessions --active.
+    registerSessionsObserveAliases(program);
+}
+/**
+ * `roster` → sessions --active. Registered with the sessions module so the
+ * lazy loader for `roster` also registers the real `sessions` command for re-parse.
+ */
+function registerSessionsObserveAliases(program) {
+    program
+        .command('roster')
+        .description('Live agent roster (alias of `agents sessions --active`). Who is running right now.')
+        .allowUnknownOption()
+        .allowExcessArguments()
+        .action(async () => {
+        const { expandObserveAlias } = await import('../lib/observe-aliases.js');
+        const rest = process.argv.slice(3);
+        const expanded = expandObserveAlias('roster', rest);
+        if (!expanded) {
+            console.error(chalk.red('Unknown observe alias: roster'));
+            process.exit(1);
+        }
+        if (process.stderr.isTTY)
+            process.stderr.write(chalk.gray(`${expanded.note}\n`));
+        await program.parseAsync(['node', 'agents', ...expanded.argv]);
+    });
 }
 function formatNoSessionsMessage(showAll, project) {
     const projectQuery = project?.trim();

package/dist/commands/snapshot.d.ts

@@ -0,0 +1,11 @@
+/**
+ * `agents snapshot` — one-process consumer snapshot for pollers.
+ *
+ * Replaces the N× `view --json` + `sessions --active --json` (+ optional feed)
+ * fork storm with a single command. Does NOT replace `agents status`, which
+ * remains the UnifiedSyncStatus sync contract for menubar / Agency drift.
+ *
+ * JSON shape: {@link FleetSnapshot} in `lib/snapshot.ts` (version: 1).
+ */
+import type { Command } from 'commander';
+export declare function registerSnapshotCommand(program: Command): void;

package/dist/commands/snapshot.js

@@ -0,0 +1,107 @@
+/**
+ * `agents snapshot` — one-process consumer snapshot for pollers.
+ *
+ * Replaces the N× `view --json` + `sessions --active --json` (+ optional feed)
+ * fork storm with a single command. Does NOT replace `agents status`, which
+ * remains the UnifiedSyncStatus sync contract for menubar / Agency drift.
+ *
+ * JSON shape: {@link FleetSnapshot} in `lib/snapshot.ts` (version: 1).
+ */
+import chalk from 'chalk';
+import { addHostOption } from '../lib/hosts/option.js';
+import { setHelpSections } from '../lib/help.js';
+import { resolveAgentName, AGENTS } from '../lib/agents.js';
+import { computeSnapshot } from '../lib/snapshot.js';
+import { resolveSurface } from './utils.js';
+function resolveAgentFilter(raw) {
+    if (!raw)
+        return undefined;
+    const name = resolveAgentName(raw.split('@')[0]);
+    if (!name) {
+        console.error(chalk.red(`Unknown agent "${raw}".`));
+        process.exit(1);
+    }
+    return name;
+}
+/** Compact human summary — the JSON path is the real contract. */
+function renderHuman(snap) {
+    console.log(chalk.bold('Fleet snapshot') + chalk.gray(`  ·  ${snap.host}  ·  ${snap.capturedAt}`));
+    const invParts = [];
+    for (const a of snap.inventory) {
+        if (a.versions.length === 0)
+            continue;
+        const def = a.versions.find((v) => v.isDefault) ?? a.versions[0];
+        const label = AGENTS[a.agent]?.name ?? a.agent;
+        const signed = def.signedIn ? chalk.green('in') : chalk.gray('out');
+        invParts.push(`${label}@${def.version} (${signed})`);
+    }
+    console.log(`  ${'Inventory'.padEnd(12)} ${invParts.length ? invParts.join(chalk.gray(' · ')) : chalk.gray('(none installed)')}`);
+    const { running, live, byContext, byAgent } = snap.agents;
+    const ctx = Object.entries(byContext)
+        .map(([k, n]) => `${k}:${n}`)
+        .join(' ');
+    const ag = Object.entries(byAgent)
+        .map(([k, n]) => `${k}:${n}`)
+        .join(' ');
+    console.log(`  ${'Sessions'.padEnd(12)} ${live} live · ${running} running` +
+        (snap.remoteDeviceCount > 0 ? chalk.gray(` · ${snap.remoteDeviceCount} remote device(s)`) : '') +
+        (ctx ? chalk.gray(` · ${ctx}`) : '') +
+        (ag ? chalk.gray(` · ${ag}`) : ''));
+    if (snap.feed) {
+        console.log(`  ${'Feed'.padEnd(12)} ${snap.feed.openBlocks} open block${snap.feed.openBlocks === 1 ? '' : 's'}`);
+    }
+    if (snap.sync) {
+        const need = snap.sync.agents.filter((a) => a.needsSync).length;
+        const sys = snap.sync.system.unknown
+            ? 'system unknown'
+            : snap.sync.system.behind > 0
+                ? `system ${snap.sync.system.behind} behind`
+                : 'system ok';
+        console.log(`  ${'Sync'.padEnd(12)} ${sys} · ${need} version${need === 1 ? '' : 's'} need sync`);
+    }
+    console.log(chalk.gray('\n  Machine-readable: agents snapshot --json\n' +
+        '  Sync-only (unchanged): agents status --json'));
+}
+export function registerSnapshotCommand(program) {
+    const cmd = addHostOption(program
+        .command('snapshot')
+        .description('One-process poll snapshot: install inventory + active sessions (optional feed/sync). Not the sync-status command — use `agents status` for drift.'))
+        .option('--json', 'Emit the machine-readable FleetSnapshot contract (version 1)')
+        .option('--all-hosts', 'Include remote devices in the sessions gather (same fan-out as `sessions --active`; default is this machine only)')
+        .option('--with-feed', 'Include open feed-block summary (needs-you count + compact rows)')
+        .option('--with-sync', 'Include UnifiedSyncStatus (same engine as `agents status`; opt-in)')
+        .option('--agent <name>', 'Restrict inventory to one agent (e.g. claude)');
+    setHelpSections(cmd, {
+        examples: `
+      # One-shot inventory + local active sessions (JSON)
+      agents snapshot --json
+
+      # Same, plus open feed blocks for needs-you polls
+      agents snapshot --json --with-feed
+
+      # Fleet-wide active sessions (matches sessions --active scope)
+      agents snapshot --json --all-hosts
+
+      # Inventory for one harness only (Factory-style usage poll)
+      agents snapshot --json --agent claude
+
+      # Run the whole snapshot on another device
+      agents snapshot --json --host yosemite-s0
+    `,
+    });
+    cmd.action(async (opts, command) => {
+        const surface = resolveSurface(command);
+        const agent = resolveAgentFilter(opts.agent);
+        const snap = await computeSnapshot({
+            agent,
+            local: opts.allHosts !== true,
+            withFeed: opts.withFeed === true,
+            withSync: opts.withSync === true,
+        });
+        if (surface.json || opts.json) {
+            console.log(JSON.stringify(snap, null, 2));
+            return;
+        }
+        renderHuman(snap);
+    });
+}

package/dist/commands/ssh.js

@@ -18,6 +18,7 @@ import ora from 'ora';
 import { getCliVersion } from '../lib/version.js';
 import { readAndResolveBundleEnv, isHeadlessSecretsContext } from '../lib/secrets/bundles.js';
 import { machineId } from '../lib/session/sync/config.js';
+import { isDeviceAuto, resolveDeviceAffinity } from '../lib/smart-launch.js';
 import { registerFleetCaptureCommand } from './fleet-capture.js';
 import { registerFleetApplyAlias } from './apply.js';
 import { addIgnored, getDevice, loadDevices, loadIgnored, removeDevice, removeIgnored, setAutoLaunchEnabled, setAutoLaunchPreferred, upsertDevice, writeReachability, } from '../lib/devices/registry.js';
@@ -1413,9 +1414,12 @@ Examples:
   agents ssh win-mini                       # interactive login
   agents ssh win-mini hostname              # run a command (PowerShell on Windows)
   agents ssh yosemite-s0 uptime             # run a command (POSIX)
+  agents ssh auto                           # affinity-pick a device (same engine as 'agents run --device auto')
 
 Devices come from 'agents devices'. Password auth pulls the secret from a
 secrets bundle via an askpass shim — the password never touches argv.
+'auto' picks a remote device by 14-day usage; a pick landing on this machine
+is refused with a clear message instead of self-dialing.
 `)
         .action(async (name, cmd) => {
         // Hidden askpass bridge: ssh execs the shim, which re-invokes us here.
@@ -1423,16 +1427,35 @@ secrets bundle via an askpass shim — the password never touches argv.
             await runAskpass();
             return;
         }
+        // `auto` is the same affinity sentinel `agents run --device auto` resolves
+        // (RUSH-2185) — pick the concrete device up front via the SAME engine
+        // (resolveDeviceAffinity), rather than leaning on matchHost's generic
+        // self-resolution (../lib/hosts/registry.js): `agents ssh` connects OUT to
+        // a remote device, so a pick that lands on THIS machine is refused with a
+        // clear message instead of self-SSHing — which also holds when this
+        // machine was never itself enrolled as a device (matchHost would have
+        // nothing to resolve "self" to, and mis-report the pick as "Unknown
+        // device").
+        let target = name;
+        if (isDeviceAuto(name)) {
+            const plan = resolveDeviceAffinity({});
+            if (!plan.host) {
+                console.error(chalk.red(`'auto' picked this machine — 'agents ssh' connects to a remote device. Pass a device name; see 'agents devices list'.`));
+                process.exit(1);
+            }
+            process.stderr.write(chalk.gray(`[agents] device=auto → ${plan.host}\n`));
+            target = plan.host;
+        }
         // Accept the full fleet target grammar: a registered `name`, a
         // `user@device` (same device, login user overridden — dialed via its
         // Tailscale route, not LAN DNS), or an ad-hoc `user@host`/`host` literal.
         // A bare unregistered alias still errors as "Unknown device".
-        const device = await resolveDeviceTarget(name);
+        const device = await resolveDeviceTarget(target);
         if (!device) {
             // Not a registered device — it may be a leased crabbox box slug. ssh into
             // it directly (crabbox@<tailnet|ip>:2222) before giving up.
-            trySshLeasedBox(name, cmd); // exits the process on a match
-            console.error(chalk.red(`Unknown device '${name}'. See 'agents devices list'.`));
+            trySshLeasedBox(target, cmd); // exits the process on a match
+            console.error(chalk.red(`Unknown device '${target}'. See 'agents devices list'.`));
             process.exit(1);
         }
         // Preflight: a device Tailscale last saw offline would otherwise hang

package/dist/commands/teams.js

@@ -17,6 +17,7 @@ import { createTeam, ensureTeam, getTeam, loadTeams, removeTeam, teamExists, } f
 import { setHelpSections } from '../lib/help.js';
 import { createWorktree, isGitRepo, hasUncommittedChanges, removeWorktree, } from '../lib/teams/worktree.js';
 import { resolveHost } from '../lib/hosts/registry.js';
+import { isDeviceAuto, resolveDeviceAffinity } from '../lib/smart-launch.js';
 import { sshTargetFor } from '../lib/hosts/types.js';
 import { ensureHostReady } from '../lib/hosts/ready.js';
 import { remoteShellFor } from '../lib/hosts/remote-cmd.js';
@@ -275,7 +276,8 @@ function throttleWarningLine(agent, version, r) {
     const acct = r.email ? ` (${r.email})` : '';
     const reason = r.reason === 'out_of_credits' ? 'is out of credits'
         : r.reason === 'signed_out' ? 'is not signed in'
-            : 'is rate-limited right now';
+            : r.reason === 'revoked' ? 'needs re-login (its token was revoked)'
+                : 'is rate-limited right now';
     return (chalk.yellow(`⚠ ${who}${acct} ${reason}.`) +
         chalk.gray(`\n  A pinned version skips account rotation, so it will launch on this account and may immediately hit its limit.` +
             `\n  Use a bare \`${agent}\` teammate to let the team pick a healthy account, or pass --force to silence this.`));
@@ -1329,7 +1331,7 @@ export function registerTeamsCommands(program) {
         // `--device`/`--host` are aliases (addHostOption registers both). For `teams
         // add` the passthrough special-cases them as PLACEMENT, not routing, so the
         // local action reads them here. Reject a conflicting pair.
-        const explicitDevice = (() => {
+        let explicitDevice = (() => {
             const h = opts.host;
             const d = opts.device;
             if (h && d && h !== d) {
@@ -1337,6 +1339,16 @@ export function registerTeamsCommands(program) {
             }
             return h ?? d ?? null;
         })();
+        // `auto` is the same affinity sentinel `agents run --device auto` resolves
+        // (RUSH-2185) — pick the concrete device name up front so the local-machine
+        // check right below (and every dieFriction message further down) sees the
+        // real target instead of the literal string "auto".
+        if (explicitDevice && isDeviceAuto(explicitDevice)) {
+            const plan = resolveDeviceAffinity({});
+            const picked = plan.host ?? machineId();
+            process.stderr.write(chalk.gray(`[teams] device=auto → ${picked === machineId() ? 'local' : picked}\n`));
+            explicitDevice = picked;
+        }
         // Distributed teams: --device <name> PINS this teammate to a machine over
         // SSH. Resolve + validate the placement here so a bad target fails at `add`
         // time, not silently at launch. Persisted (hostName/hostTarget/repoPath) so

package/dist/commands/view.d.ts

@@ -129,6 +129,13 @@ export declare function parseResourceSections(options: {
     resources?: string | boolean;
     detailed?: boolean;
 } & ViewSectionFilter, jsonMode: boolean): Set<ResourceSection>;
+/**
+ * Collect structured info for one or more agents without rendering to the
+ * terminal. Used by `--json` output and any programmatic consumer (e.g. the
+ * agents-cli extension's "resume current session in best available version"
+ * command).
+ */
+export declare function collectAgentsJson(filterAgentId?: AgentId, resourceSections?: Set<ResourceSection>): Promise<ViewJsonAgent[]>;
 /**
  * Identity key for duplicate-install detection. Prefers accountKey — which
  * encodes account AND org — over the bare email: two installs can share an

package/dist/commands/view.js

@@ -1242,7 +1242,7 @@ export function parseResourceSections(options, jsonMode) {
  * agents-cli extension's "resume current session in best available version"
  * command).
  */
-async function collectAgentsJson(filterAgentId, resourceSections) {
+export async function collectAgentsJson(filterAgentId, resourceSections) {
     const agentsToShow = filterAgentId ? [filterAgentId] : ALL_AGENT_IDS;
     const wantResources = !!resourceSections && resourceSections.size > 0;
     // Only pay for the git-status + resource scans when resources were requested.

package/dist/index.js

@@ -94,7 +94,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, loadExport, loadPackages, loadRoutines, loadMonitors, loadProjects, loadRun, loadFork, loadDefaults, loadSet, loadModels, loadPrune, loadTrash, loadRestore, loadDoctor, loadApply, loadStatus, loadProfiles, loadHarness, loadSecrets, loadLogin, loadWallet, loadHelper, loadMenubar, loadBeta, loadSync, loadLock, loadRefreshRules, loadFactory, loadUsage, loadCost, loadPerf, loadTrends, loadOutput, loadBudget, loadAlias, loadMine, loadPty, loadTmux, loadWatchdog, loadBrowser, loadComputer, loadHosts, loadLogs, loadEvents, loadAudit, loadWebhook, loadFunnel, loadSsh, loadPull, loadPush, loadRepo, loadSetup, loadUninstall, loadShare, loadSend, loadFeed, loadMailboxes, } 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, loadExport, loadPackages, loadRoutines, loadMonitors, loadProjects, loadRun, loadFork, loadDefaults, loadSet, loadModels, loadPrune, loadTrash, loadRestore, loadDoctor, loadApply, loadStatus, loadSnapshot, loadProfiles, loadHarness, loadSecrets, loadLogin, loadWallet, loadHelper, loadMenubar, loadBeta, loadSync, loadLock, loadRefreshRules, loadFactory, loadUsage, loadCost, loadPerf, loadTrends, loadOutput, loadBudget, loadAlias, loadMine, loadPty, loadTmux, loadWatchdog, loadBrowser, loadComputer, loadHosts, loadLogs, loadEvents, loadAudit, loadWebhook, loadFunnel, loadSsh, loadPull, loadPush, loadRepo, loadSetup, loadUninstall, loadShare, loadSend, loadFeed, loadMailboxes, } from './lib/startup/command-registry.js';
 import { applyGlobalHelpConventions } from './lib/help.js';
 import { renderWhatsNew } from './lib/whats-new.js';
 import { getCliLaunch } from './lib/cli-entry.js';
@@ -310,6 +310,15 @@ Run and dispatch:
   browser                         Automate a browser — navigate, click, screenshot, console, network
   pty                             Drive interactive terminal programs (REPLs, TUIs) via a persistent PTY session
 
+Observe (read the fleet — no store merge; aliases point at the real readers):
+  feed / inbox                    Needs-you inbox (open blocks waiting on you)
+  timeline                        Agent progress stream (= feed --filter updates)
+  roster                          Live agents (= sessions --active)
+  events                          Unified ops + activity event trail
+  audit                           Tamper-evident run-dispatch log (not events)
+  snapshot                        One-process inventory + active sessions poll
+  status                          Sync/drift only (not the live fleet snapshot)
+
 Credentials and profiles:
   profile                         Activate resource profiles across skills, MCP, permissions, and secrets
   profiles                        Bundles of (host CLI, endpoint, model, auth)
@@ -938,6 +947,7 @@ async function registerAllEagerCommands() {
     registerCheckTombstoneCommand(program);
     await reg(loadApply);
     await reg(loadStatus);
+    await reg(loadSnapshot);
     registerExecAliasCommand(program);
     await reg(loadProfiles);
     await reg(loadHarness);

package/dist/lib/browser/ipc.js

@@ -178,6 +178,8 @@ export class BrowserIPCServer {
                     url: request.url,
                     endpointName: request.endpoint,
                     skipDomainSkill: request.skipDomainSkill,
+                    actor: request.actor,
+                    launchId: request.launchId,
                 });
                 return {
                     ok: true,

package/dist/lib/browser/remote-control.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Consent gate for driving THIS machine's browser from another fleet machine.
+ *
+ * `browser --host <device>` routes a browser command to `<device>` over SSH (the
+ * fleet passthrough) and runs `agents browser ...` there. Every such remote
+ * invocation carries the {@link FLEET_REMOTE_ENV} marker, set once at the fleet
+ * dispatch site (`maybeRunOnHost`). A machine only accepts being driven when its
+ * owner has opted in via `agents browser remote-control on` (the device-scope
+ * `browser.remote-control` config key, never synced).
+ *
+ * Local invocations (no marker) are never gated — this only governs cross-machine
+ * drives. Read-only queries are not gated here; the gate sits at the drive entry
+ * point (`browser start`), the one command that opens/attaches a browser.
+ */
+/** Env marker set on every remote `agents` invocation by `buildRemoteAgentsInvocation`. */
+export declare const FLEET_REMOTE_ENV = "AGENTS_FLEET_REMOTE";
+/** True when this process was dispatched to this machine by a fleet `--host` run. */
+export declare function isFleetRemoteInvocation(env?: NodeJS.ProcessEnv): boolean;
+/**
+ * Whether this machine allows other fleet machines to drive its browser. Reads
+ * the device-scope `browser.remote-control` config key. Unset = off (deny).
+ */
+export declare function remoteControlEnabled(): boolean;
+/**
+ * Guard the browser-drive entry point. A fleet-remote invocation may only drive
+ * this machine's browser when the owner opted in; otherwise throw a clear,
+ * actionable error. A local invocation is never gated.
+ *
+ * `env` and `enabled` are injectable so the decision is unit-testable without a
+ * real remote hop or a real config store.
+ */
+export declare function assertRemoteControlAllowed(opts?: {
+    env?: NodeJS.ProcessEnv;
+    enabled?: boolean;
+}): void;

package/dist/lib/browser/remote-control.js

@@ -0,0 +1,48 @@
+/**
+ * Consent gate for driving THIS machine's browser from another fleet machine.
+ *
+ * `browser --host <device>` routes a browser command to `<device>` over SSH (the
+ * fleet passthrough) and runs `agents browser ...` there. Every such remote
+ * invocation carries the {@link FLEET_REMOTE_ENV} marker, set once at the fleet
+ * dispatch site (`maybeRunOnHost`). A machine only accepts being driven when its
+ * owner has opted in via `agents browser remote-control on` (the device-scope
+ * `browser.remote-control` config key, never synced).
+ *
+ * Local invocations (no marker) are never gated — this only governs cross-machine
+ * drives. Read-only queries are not gated here; the gate sits at the drive entry
+ * point (`browser start`), the one command that opens/attaches a browser.
+ */
+import { getConfigValue } from '../device-config.js';
+/** Env marker set on every remote `agents` invocation by `buildRemoteAgentsInvocation`. */
+export const FLEET_REMOTE_ENV = 'AGENTS_FLEET_REMOTE';
+/** True when this process was dispatched to this machine by a fleet `--host` run. */
+export function isFleetRemoteInvocation(env = process.env) {
+    return env[FLEET_REMOTE_ENV] === '1';
+}
+/**
+ * Whether this machine allows other fleet machines to drive its browser. Reads
+ * the device-scope `browser.remote-control` config key. Unset = off (deny).
+ */
+export function remoteControlEnabled() {
+    return getConfigValue('browser.remote-control').value === true;
+}
+/**
+ * Guard the browser-drive entry point. A fleet-remote invocation may only drive
+ * this machine's browser when the owner opted in; otherwise throw a clear,
+ * actionable error. A local invocation is never gated.
+ *
+ * `env` and `enabled` are injectable so the decision is unit-testable without a
+ * real remote hop or a real config store.
+ */
+export function assertRemoteControlAllowed(opts) {
+    const env = opts?.env ?? process.env;
+    if (!isFleetRemoteInvocation(env))
+        return;
+    const enabled = opts?.enabled ?? remoteControlEnabled();
+    if (enabled)
+        return;
+    const who = env.AGENTS_ACTOR_HOST || env.AGENTS_ACTOR || 'A fleet machine';
+    throw new Error(`${who} tried to drive this machine's browser over \`browser --host\`, but remote ` +
+        `browser control is off here. To allow it, run on THIS machine:\n` +
+        `  agents browser remote-control on`);
+}

package/dist/lib/browser/service.d.ts

@@ -50,6 +50,22 @@ export interface HealInfo {
     role: string;
     name: string;
 }
+/**
+ * Resolve the identity stamped on a task at start: WHO (`owner`) and WHICH run
+ * (`launchId`). The forwarded values come from the caller's own CLI process and
+ * are authoritative — the browser daemon is shared and long-lived, so resolving
+ * the actor daemon-side (the RUSH-2020 bug) mis-attributes every task to the
+ * daemon's owner. `resolveLocalActor` is consulted ONLY when no actor was
+ * forwarded (a CLI that predates the field, mid-rollout) — never to override a
+ * forwarded one.
+ */
+export declare function resolveTaskIdentity(forwarded: {
+    actor?: string;
+    launchId?: string;
+}, resolveLocalActor: () => string): {
+    owner: string;
+    launchId?: string;
+};
 export declare class BrowserService {
     private static readonly SOURCE_PREFIX;
     private connections;
@@ -64,6 +80,9 @@ export declare class BrowserService {
         url?: string;
         endpointName?: string;
         skipDomainSkill?: boolean;
+        /** Caller identity, forwarded from the CLI (see IPCRequest.actor/launchId). */
+        actor?: string;
+        launchId?: string;
     }): Promise<{
         task: string;
         name: string;

package/dist/lib/browser/service.js

@@ -222,6 +222,21 @@ async function isConnHealthy(conn, timeoutMs = 1000) {
         return false;
     }
 }
+/**
+ * Resolve the identity stamped on a task at start: WHO (`owner`) and WHICH run
+ * (`launchId`). The forwarded values come from the caller's own CLI process and
+ * are authoritative — the browser daemon is shared and long-lived, so resolving
+ * the actor daemon-side (the RUSH-2020 bug) mis-attributes every task to the
+ * daemon's owner. `resolveLocalActor` is consulted ONLY when no actor was
+ * forwarded (a CLI that predates the field, mid-rollout) — never to override a
+ * forwarded one.
+ */
+export function resolveTaskIdentity(forwarded, resolveLocalActor) {
+    return {
+        owner: forwarded.actor ?? resolveLocalActor(),
+        launchId: forwarded.launchId,
+    };
+}
 export class BrowserService {
     static SOURCE_PREFIX = {
         'rush-app': 'rush-app-',
@@ -332,7 +347,10 @@ export class BrowserService {
             currentTabId: undefined,
             createdAt: Date.now(),
             pid: conn.pid,
-            owner: resolveActor().id, // who launched this browser task (RUSH-2020)
+            // Identity is forwarded from the caller (see resolveTaskIdentity): WHO
+            // (owner) and WHICH run (launchId). Resolving daemon-side would attribute
+            // every task to the shared daemon's actor (the RUSH-2020 bug).
+            ...resolveTaskIdentity({ actor: opts.actor, launchId: opts.launchId }, () => resolveActor().id),
         };
         // For Electron, get the existing window as the tab
         if (conn.electron) {