@phnx-labs/agents-cli 1.22.35 → 1.22.38

package/dist/commands/audit.js

@@ -1,68 +1,78 @@
 /**
- * `agents audit` — inspect the tamper-evident audit log of dispatched runs.
+ * `agents audit` — thin alias of `agents events --include runs`.
  *
- * Every run that reaches the exec dispatch chokepoint appends one hash-chained
- * record (see src/lib/audit/log.ts). This command walks that chain:
+ * New run-dispatch outcomes land in the unified event stream as `run.dispatched`
+ * (see lib/audit/log.ts::recordDispatchedRun). This command does not own a
+ * separate store or query path — it only sets the default family filter.
  *
- *   agents audit verify   Confirm the chain is intact; report the first break.
- *   agents audit list     Print recent records (newest last).
- *
- * `verify` exits non-zero when the chain is broken so it can gate CI / governance
- * checks.
+ *   agents audit              ≡ agents events --include runs
+ *   agents audit list         ≡ same
+ *   agents audit verify       walks the legacy hash-chain file if present
+ *                             (pre-unification history only)
  */
 import chalk from 'chalk';
 import { verifyAuditChain, readAuditLog, getAuditLogPath, } from '../lib/audit/log.js';
-function renderRow(r, i) {
-    const idx = chalk.gray(String(i).padStart(4));
-    const time = chalk.gray(r.ts.slice(0, 19).replace('T', ' '));
-    const who = `${r.agent}@${r.version}`.padEnd(20);
-    const outcome = r.outcome === 'ok' ? chalk.green('ok  ') : chalk.red('fail');
-    const mode = chalk.cyan(r.mode.padEnd(6));
-    return `${idx}  ${time}  ${who} ${mode} ${outcome} exit=${r.exit}  ${r.repo}`;
-}
+import { addEventsReadOptions, runEventsCommand } from './events.js';
 export function registerAuditCommands(program) {
-    const audit = program
+    const audit = addEventsReadOptions(program
         .command('audit')
-        .description('Inspect the tamper-evident audit log of dispatched runs');
+        .description('Alias of `agents events --include runs` — dispatched-run outcomes'), false)
+        .addHelpText('after', `
+Examples:
+  agents audit                         Same as: agents events --include runs
+  agents audit --since 7d --json
+  agents audit list                    Muscle-memory alias of bare audit
+  agents audit verify                  Legacy hash-chain file only (if present)
+`)
+        .action((_options, command) => {
+        const opts = command.optsWithGlobals();
+        // Bare audit defaults to --include runs unless the user already set families.
+        if (!opts.include && !opts.exclude)
+            opts.include = 'runs';
+        return runEventsCommand(opts);
+    });
+    audit
+        .command('list')
+        .description('Alias of `agents audit` / `agents events --include runs`')
+        .action((_options, command) => {
+        const parent = command.parent;
+        const opts = {
+            ...(parent?.optsWithGlobals?.() ?? {}),
+            ...(command.optsWithGlobals?.() ?? {}),
+            include: 'runs',
+        };
+        return runEventsCommand(opts);
+    });
     audit
         .command('verify')
-        .description('Walk the hash chain and report OK or the first broken index')
+        .description('Walk the legacy hash-chain file (pre-unification history only)')
         .option('--json', 'Output the result as JSON')
         .action((options) => {
-        const result = verifyAuditChain();
+        const logPath = getAuditLogPath();
+        const records = readAuditLog(logPath);
+        if (records.length === 0) {
+            if (options.json) {
+                console.log(JSON.stringify({ ok: true, legacy: true, records: 0, note: 'no legacy audit chain; new runs use events --include runs' }));
+                process.exit(0);
+            }
+            console.log(chalk.green('✓ no legacy audit chain present'));
+            console.log(chalk.gray('  New run outcomes: agents events --include runs'));
+            console.log(chalk.gray(`  (looked for ${logPath})`));
+            process.exit(0);
+        }
+        const result = verifyAuditChain(logPath);
         if (options.json) {
-            console.log(JSON.stringify(result));
+            console.log(JSON.stringify({ ...result, legacy: true, records: records.length }));
             process.exit(result.ok ? 0 : 1);
         }
         if (result.ok) {
-            const n = readAuditLog().length;
-            console.log(chalk.green(`✓ audit chain intact — ${n} record(s) verified`));
-            console.log(chalk.gray(`  ${getAuditLogPath()}`));
+            console.log(chalk.green(`✓ legacy audit chain intact — ${records.length} record(s) verified`));
+            console.log(chalk.gray(`  ${logPath}`));
+            console.log(chalk.gray('  New runs use the events stream: agents events --include runs'));
             process.exit(0);
         }
-        console.error(chalk.red(`✗ audit chain BROKEN at record #${result.brokenAt}`));
-        console.error(chalk.gray(`  ${getAuditLogPath()}`));
+        console.error(chalk.red(`✗ legacy audit chain BROKEN at record #${result.brokenAt}`));
+        console.error(chalk.gray(`  ${logPath}`));
         process.exit(1);
     });
-    audit
-        .command('list')
-        .description('Print recent audit records (oldest-first)')
-        .option('--limit <n>', 'Max records to show (default 50)', '50')
-        .option('--json', 'Output raw records as JSON')
-        .action((options) => {
-        const all = readAuditLog();
-        if (options.json) {
-            console.log(JSON.stringify(all, null, 2));
-            return;
-        }
-        if (all.length === 0) {
-            console.log(chalk.gray('No audit records yet.'));
-            return;
-        }
-        const limit = Math.max(1, parseInt(options.limit ?? '50', 10) || 50);
-        const start = Math.max(0, all.length - limit);
-        for (let i = start; i < all.length; i++)
-            console.log(renderRow(all[i], i));
-        console.log(chalk.gray(`\n${all.length} record(s). Log: ${getAuditLogPath()}`));
-    });
 }

package/dist/commands/browser.js

@@ -1,7 +1,7 @@
+import chalk from 'chalk';
 import * as fs from 'fs';
 import * as path from 'path';
 import { listProfiles, getProfile, createProfile, deleteProfile, ensureDefaultBrowserProfile, getConfiguredDefaultProfileName, DEFAULT_BROWSER_PROFILE_NAME, getProfileRuntimeDir, extractConfiguredPort, findFreeProfilePort, getEndpointPresets, } from '../lib/browser/profiles.js';
-import { updateMeta } from '../lib/state.js';
 import { resolveActor } from '../lib/actor.js';
 import { loginsForProfile, profilesLoggedInto, serviceForUrl, loginsWithAccountsForProfile, accountsForProfile, credKeysForService, AUTH_SIGNATURES, } from '../lib/browser/login-detection.js';
 import { parseSecretRef } from '../lib/browser/secret-ref.js';
@@ -15,7 +15,7 @@ import { parseTargetFilter } from '../lib/browser/service.js';
 import { BrowserDaemonNotRunningError, formatBrowserDaemonNotRunningError, sendIPCRequest, } from '../lib/browser/ipc.js';
 import { browserTaskPicker } from './browser-picker.js';
 import { assertRemoteControlAllowed } from '../lib/browser/remote-control.js';
-import { getConfigValue, setConfigValue } from '../lib/device-config.js';
+import { getConfigValue, setConfigValue, unsetConfigValue } from '../lib/device-config.js';
 import { isInteractiveTerminal } from './utils.js';
 import { registerCommandGroups, setHelpSections } from '../lib/help.js';
 import { buildHar } from '../lib/browser/har.js';
@@ -188,17 +188,15 @@ function registerProfilesCommands(browser) {
             console.log(`Default profile (this machine): ${configuredDefault}`);
         }
     });
+    const browserProfileDeprecation = chalk.yellow('Deprecation: `agents browser profiles set-default` is replaced by `agents config set browser.profile <name>`.');
     profiles
         .command('set-default [name]')
         .description('Set the profile `agents browser start` uses when no --profile is passed (also re-points an explicit `--profile default`). Device-local — each machine has its own. No name prints the current value.')
         .option('--unset', 'Clear the configured default (revert to auto-detecting an installed browser)')
         .action(async (name, opts) => {
+        console.warn(browserProfileDeprecation);
         if (opts.unset) {
-            updateMeta((m) => {
-                const { defaultBrowserProfile, ...rest } = m;
-                void defaultBrowserProfile;
-                return rest;
-            });
+            unsetConfigValue('browser.profile');
             console.log('Default browser profile cleared. `agents browser start` will auto-detect an installed Chromium-family browser.');
             return;
         }
@@ -209,7 +207,7 @@ function registerProfilesCommands(browser) {
             }
             else {
                 console.log('No default browser profile set. `agents browser start` auto-detects an installed Chromium-family browser.');
-                console.log('Set one with: agents browser profiles set-default <name>');
+                console.log('Set one with: agents config set browser.profile <name>');
             }
             return;
         }
@@ -221,7 +219,7 @@ function registerProfilesCommands(browser) {
                 console.error(`Available profiles: ${all.map((p) => p.name).join(', ')}`);
             process.exit(1);
         }
-        updateMeta((m) => ({ ...m, defaultBrowserProfile: name }));
+        setConfigValue('browser.profile', name);
         const eps = getEndpointPresets(target);
         const epStr = Object.values(eps)[0]?.target ?? '';
         console.log(`Default browser profile (this machine) is now "${name}" (${target.browser}${epStr ? `, ${epStr}` : ''}).`);
@@ -454,7 +452,7 @@ function registerProfilesCommands(browser) {
             (removed > 0 ? ` (and ${removed} cache dir${removed === 1 ? '' : 's'})` : ''));
         if (getConfiguredDefaultProfileName() === name) {
             console.error(`warning: "${name}" was this machine's default browser profile; ` +
-                `\`agents browser start\` will auto-detect until you run: agents browser profiles set-default <name>`);
+                `\`agents browser start\` will auto-detect until you run: agents config set browser.profile <name>`);
         }
     });
     profiles
@@ -674,6 +672,7 @@ function registerTaskCommands(browser) {
             task: opts.task ?? process.env.AGENTS_BROWSER_TASK,
             actor: resolveActor().id,
             launchId: process.env.AGENT_LAUNCH_ID,
+            sessionId: process.env.AGENT_SESSION_ID || process.env.AGENTS_SESSION_ID,
         });
     });
     setHelpSections(stream, {
@@ -695,11 +694,12 @@ function registerTaskCommands(browser) {
     });
     browser
         .command('start')
-        .description('Start a browser task. Pass --profile <name>; omit to use your configured default (`agents browser profiles set-default`), else auto-pick an installed Chromium-family browser.')
+        .description('Start a browser task. Pass --profile <name>; omit to use your configured default (`agents config set browser.profile <name>`), else auto-pick an installed Chromium-family browser.')
         .option('-p, --profile <name>', 'Browser profile to use (omit to use the configured default, else auto-pick an installed Chromium-family browser)')
         .option(TASK_OPTION_FLAG, 'Task name (auto-generated if omitted)')
         .option('-e, --endpoint <name>', 'Endpoint preset (defaults to the profile\'s default)')
         .option('-u, --url <url>', 'Open URL in first tab')
+        .option('--fresh', 'Always open a new tab, skipping the reclaim of a tab an abandoned task is holding on that URL')
         .option('--no-skills', 'Skip auto-discovery of site-specific SKILL.md from ~/.agents/skills/browser/domain-skills/')
         .option('--record', 'Start recording right after the tab opens (shorthand for `agents browser record start` as a follow-up)')
         .option('--fps <n>', 'Recording frames per second (with --record; 1–30, default 5)', (v) => parseInt(v, 10))
@@ -792,12 +792,18 @@ function registerTaskCommands(browser) {
             url: opts.url,
             endpoint: opts.endpoint,
             skipDomainSkill: opts.skills === false,
+            fresh: opts.fresh === true,
             // Forward the caller's identity: the browser daemon is shared, so it
             // cannot resolve who/which-run called `start`. `resolveActor()` runs
             // here in the CLI (the caller's process); `$AGENT_LAUNCH_ID` is the
             // per-run id exec.ts injects for every harness.
             actor: resolveActor().id,
             launchId: process.env.AGENT_LAUNCH_ID,
+            // The agent session that drove this task — what makes the capture
+            // traceable back to a conversation (RUSH-2549). Sent alongside, not
+            // instead of, launchId: a launch id is absent on most agent processes,
+            // a session id is not.
+            sessionId: process.env.AGENT_SESSION_ID || process.env.AGENTS_SESSION_ID,
         });
         if (!response.ok) {
             console.error(response.error);

package/dist/commands/cloud.js

@@ -127,7 +127,7 @@ Examples:
   # Codex Cloud
   agents cloud run "add auth tests" --provider codex --env env_abc123
 
-  # One of your own machines (agents hosts / agents devices), over SSH
+  # One of your own machines (agents devices), over SSH
   agents cloud run "run the nightly benchmark" --host gpu-box --agent claude
   agents cloud run "rebuild the index" --host gpu --any --remote-cwd ~/proj
 

package/dist/commands/commands.js

@@ -395,17 +395,6 @@ Examples:
             console.log(chalk.gray('Central source unchanged. Commands will re-sync on next agent launch.'));
         }
     });
-    // `commands sync` is gone — sync runs automatically when the agent launches.
-    commandsCmd
-        .command('sync', { hidden: true })
-        .allowUnknownOption()
-        .allowExcessArguments()
-        .action(() => {
-        console.error(chalk.red('"agents commands sync" is gone.'));
-        console.error(chalk.gray('Sync runs automatically when you launch the agent.'));
-        console.error(chalk.gray('To remove orphans, use:  agents prune cleanup commands'));
-        process.exit(1);
-    });
     // `commands prune` moved to the top-level `agents prune cleanup` command.
     commandsCmd
         .command('prune', { hidden: true })

package/dist/commands/computer-actions.js

@@ -9,9 +9,12 @@
 import { execFileSync } from 'child_process';
 import * as fs from 'fs';
 import * as path from 'path';
+import { randomUUID } from 'node:crypto';
 import { openComputerClient, describeTransport, resolvePolicyPath, } from '../lib/computer-rpc.js';
 import { COMPUTER_INPUT_GATED_VERBS, formatComputerPermissionGrantHint, } from '../lib/permissions.js';
 import { emit as emitEvent } from '../lib/events.js';
+import { recordComputerSession } from '../lib/session/db.js';
+import { resolveActor } from '../lib/actor.js';
 function isComputerInputVerb(verb) {
     return typeof verb === 'string' && COMPUTER_INPUT_GATED_VERBS.includes(verb);
 }
@@ -358,14 +361,44 @@ function emit(result, json, human) {
 // NOTE: the field is `targetPid`, never `pid` — `pid` is a reserved envelope
 // key (the emitting process's OWN pid, events.ts RESERVED_META_KEYS) that
 // sanitizePayload() silently strips from the payload before it can collide.
+const COMPUTER_INVOCATION_ID = randomUUID();
 export function emitComputerAction(verb, targetPid, opts, extra = {}) {
     emitEvent('computer.action', {
         command: verb,
+        invocationId: COMPUTER_INVOCATION_ID,
         targetPid,
         bundle: opts.bundle,
         host: opts.host,
         ...extra,
     });
+    // Mirror the invocation's IDENTITY into the durable store (RUSH-2549). The
+    // event above stays the audit record, but the event ledger is bounded and
+    // prunes at 7 days / 50 MiB (events.ts), so a run's history used to vanish on
+    // day 8. This row is metadata only -- no screenshots, no typed text -- and
+    // `action_count` accumulates across the many calls one invocation makes.
+    //
+    // Identity is read from this process's own env, exactly as stampProvenance()
+    // does for the event: `agents computer` runs IN the caller's process, so there
+    // is no shared daemon to mis-attribute it to (the browser problem).
+    //
+    // Guarded for the same reason `emit` above guards itself ("logging should
+    // never break the CLI", events.ts): this is a RECORD of the action, not the
+    // action. An unwritable or locked session DB must not stop `agents computer
+    // click` from clicking. The action still happened and its event still landed;
+    // only this row is missed, and the next call re-records the identity.
+    try {
+        recordComputerSession({
+            invocationId: COMPUTER_INVOCATION_ID,
+            sessionId: process.env.AGENT_SESSION_ID || process.env.AGENTS_SESSION_ID,
+            launchId: process.env.AGENT_LAUNCH_ID,
+            actor: resolveActor().id,
+            actionCount: 1,
+            taskPreview: typeof extra.task === 'string' ? extra.task : undefined,
+        });
+    }
+    catch {
+        // Recording is best-effort; the action and its event are already done.
+    }
 }
 // Add the shared --pid/--bundle/--host target options to a verb. `--host` routes
 // the verb at a remote Windows device: the `computer` preAction hook hydrates

package/dist/commands/computer-sessions-picker.d.ts

@@ -0,0 +1,21 @@
+import { type ComputerRunRow } from '../lib/computer/sessions-list.js';
+export interface ComputerSessionsCommandOpts {
+    machine?: string;
+    /** Row cap for the flat table only — the interactive picker is searchable
+     *  and shows every row regardless (see `runComputerSessions`). */
+    limit?: number;
+    json?: boolean;
+    /** Commander's `--no-interactive` convention: `false` opts out. */
+    interactive?: boolean;
+    /** Pre-collected fleet rows. Omitted for the local ledger path. */
+    rows?: ComputerRunRow[];
+}
+/** True when the interactive picker should open instead of the printed table:
+ *  a real TTY, no `--json`, and `--no-interactive` not set. */
+export declare function shouldOpenInteractiveComputerSessions(opts: ComputerSessionsCommandOpts, isTTY: boolean): boolean;
+/**
+ * Shared entry point for `agents computer sessions` and `agents sessions
+ * --computer`. Mirrors `runBrowserSessionsCommand`'s interactive-routing
+ * split so both call sites stay in lockstep.
+ */
+export declare function runComputerSessionsCommand(opts: ComputerSessionsCommandOpts): Promise<void>;

package/dist/commands/computer-sessions-picker.js

@@ -0,0 +1,141 @@
+/**
+ * Interactive, task-first `agents computer sessions` / `agents sessions
+ * --computer` view (RUSH-2432) — the computer counterpart of
+ * `browser-sessions-picker.ts` (RUSH-2407). Backs the TTY path only —
+ * non-TTY, `--json`, and `--no-interactive` all fall straight through to the
+ * flat printer in `lib/computer/sessions-list.ts` (unchanged, so `--json`
+ * stays a stable surface).
+ *
+ * Reuses the same `itemPicker` + `buildPreview` primitives as the ordinary
+ * session picker (`sessions-picker.ts`) and the browser task picker — same
+ * search/filter/quit help, and the preview pane for a linked run IS the
+ * canonical session digest, not a second renderer. Unlike a browser task, a
+ * computer run has no on-disk artifact of its own to open (see
+ * `lib/computer/sessions-list.ts`'s module docblock), so `enter` prints the
+ * run's full action list rather than opening a file, and the picker keeps
+ * browsing afterward instead of exiting.
+ */
+import chalk from 'chalk';
+import { itemPicker } from '../lib/picker.js';
+import { isInteractiveTerminal, isPromptCancelled } from './utils.js';
+import { buildPreview } from './sessions-picker.js';
+import { runComputerSessions, printComputerSessionRows, buildComputerSessionRows, matchesComputerSessionRow, formatRowActions, } from '../lib/computer/sessions-list.js';
+import { formatRelativeTime } from '../lib/session/relative-time.js';
+/** True when the interactive picker should open instead of the printed table:
+ *  a real TTY, no `--json`, and `--no-interactive` not set. */
+export function shouldOpenInteractiveComputerSessions(opts, isTTY) {
+    return opts.interactive !== false && !opts.json && isTTY;
+}
+/**
+ * Shared entry point for `agents computer sessions` and `agents sessions
+ * --computer`. Mirrors `runBrowserSessionsCommand`'s interactive-routing
+ * split so both call sites stay in lockstep.
+ */
+export async function runComputerSessionsCommand(opts) {
+    if (!shouldOpenInteractiveComputerSessions(opts, isInteractiveTerminal())) {
+        if (opts.rows)
+            printComputerSessionRows(opts.rows, { limit: opts.limit, json: opts.json });
+        else
+            runComputerSessions({ machine: opts.machine, limit: opts.limit, json: opts.json });
+        return;
+    }
+    const rows = opts.rows ?? buildComputerSessionRows({ machine: opts.machine });
+    if (rows.length === 0) {
+        console.log(`No computer actions recorded${opts.machine ? ` for machine "${opts.machine}"` : ''}.`);
+        return;
+    }
+    await browseComputerSessions(rows);
+}
+function rowLinkSummary(row) {
+    if (row.linkStatus === 'linked' && row.linkedSession) {
+        const s = row.linkedSession;
+        return chalk.cyan(s.agent) + ' — ' + (s.label || s.topic || s.shortId);
+    }
+    if (row.linkStatus === 'unresolved') {
+        return chalk.yellow(`owner ${row.agent ?? 'unknown'} (session not indexed here)`);
+    }
+    return chalk.gray('unlinked');
+}
+function formatRowLabel(row) {
+    // Pad the raw text first, THEN colorize — padEnd on an already-chalked
+    // string counts the ANSI escape bytes as width and misaligns the column.
+    const rawName = row.task ?? row.bundle ?? (row.pid ? `pid ${row.pid}` : 'recovered run');
+    const name = rawName.slice(0, 40).padEnd(40);
+    const coloredName = row.task ? name : chalk.gray(name);
+    const where = (row.remoteHost ? `${row.machine} -> ${row.remoteHost}` : row.machine).padEnd(24);
+    const age = formatRelativeTime(new Date(row.endMs).toISOString());
+    const counts = formatRowActions(row);
+    return [coloredName, where, age.padEnd(11), counts.padEnd(24), rowLinkSummary(row)].join(' ');
+}
+const PREVIEW_ACTION_LIMIT = 12;
+function buildRowPreview(row) {
+    const parts = [];
+    if (row.linkStatus === 'linked' && row.linkedSession) {
+        parts.push(buildPreview(row.linkedSession));
+    }
+    else if (row.linkStatus === 'unresolved') {
+        parts.push(chalk.yellow(`owner ${row.agent ?? 'unknown'} — session ${row.sessionId ?? row.launchId} has no indexed session on this machine.`));
+    }
+    else {
+        parts.push(chalk.gray('Unlinked — no owning agent session is known for this run (no session/launch identity recorded).'));
+    }
+    if (row.task) {
+        parts.push('');
+        parts.push(chalk.bold('Task:') + ` ${row.task}`);
+    }
+    parts.push('');
+    parts.push(chalk.bold(`Actions (${row.recoveredActionCount ?? row.actions.length})`) + `  ${formatRowActions(row)}`);
+    for (const a of row.actions.slice(0, PREVIEW_ACTION_LIMIT)) {
+        parts.push(`  ${formatActionLabel(a)}`);
+    }
+    const more = row.actions.length - PREVIEW_ACTION_LIMIT;
+    if (more > 0)
+        parts.push(chalk.gray(`  … (${more} more)`));
+    return parts.join('\n');
+}
+function formatActionLabel(a) {
+    const age = formatRelativeTime(new Date(a.tsMs).toISOString());
+    const target = a.bundle ?? (a.targetPid != null ? `pid ${a.targetPid}` : '-');
+    return `${age.padEnd(11)}  ${a.verb.padEnd(14)}  ${target}`;
+}
+/** Print one run's full action list (no truncation) — the `enter` action,
+ *  since a computer run has no on-disk artifact to open. */
+function printRunDetail(row) {
+    console.log('');
+    console.log(chalk.bold(row.task ?? row.bundle ?? `pid ${row.pid}`));
+    console.log(row.remoteHost ? `${row.machine} -> ${row.remoteHost}` : row.machine);
+    console.log('');
+    for (const a of row.actions)
+        console.log(formatActionLabel(a));
+    if (row.actions.length === 0)
+        console.log('(no driving actions recorded)');
+    console.log('');
+}
+/** Run-level picker with an action-list preview. Loops until the user quits
+ *  (esc) so a session's whole run history can be browsed repeatedly in one
+ *  sitting — mirroring `browseAndOpen`'s loop, minus the artifact drill-down
+ *  a computer run has none of. */
+async function browseComputerSessions(rows) {
+    for (;;) {
+        let picked;
+        try {
+            picked = await itemPicker({
+                message: 'Computer sessions:',
+                items: rows,
+                filter: (query) => (query.trim() ? rows.filter((r) => matchesComputerSessionRow(r, query)) : rows),
+                labelFor: (row) => formatRowLabel(row),
+                buildPreview: (row) => buildRowPreview(row),
+                emptyMessage: 'No computer sessions match.',
+                enterHint: 'view actions',
+            });
+        }
+        catch (err) {
+            if (isPromptCancelled(err))
+                return;
+            throw err;
+        }
+        if (!picked)
+            return;
+        printRunDetail(picked.item);
+    }
+}

package/dist/commands/computer.d.ts

@@ -38,6 +38,22 @@ export declare function reconcileScreenshotExt(outPath: string, buf: Buffer): {
 export declare function registerComputerCommand(program: Command): void;
 export declare function registerComputerSubcommands(program: Command): void;
 export declare function buildRestartTaskScript(taskName: string, exeName: string): string;
+/**
+ * Emit a `computer.action` marker for `computer run`'s whole loop process, so
+ * `agents computer sessions` groups every verb the loop drives under one
+ * task-labeled row instead of a bare pid with no task text (see
+ * lib/computer/sessions-list.ts's "Grouping key" docblock note). The task
+ * text is bounded to `TASK_PREVIEW_MAX_CHARS` — never the full unbounded
+ * `--task` string — matching that module's retention/privacy note. Exported
+ * so the truncation behavior is directly unit-testable against the real
+ * event ledger, the same seam `computer-actions.test.ts` already uses for
+ * `emitComputerAction`.
+ */
+export declare function emitComputerRunTaskMarker(opts: {
+    task: string;
+    bundle?: string;
+    host?: string;
+}): void;
 /**
  * Install the macOS helper locally: resolve (or download + verify) the signed,
  * notarized .app, copy it to /Applications, verify the destination signature,

package/dist/commands/computer.js

@@ -11,6 +11,9 @@ import { registerActionCommands, withClient, unwrap, pickTarget, emitComputerAct
 import { runComputerLoop } from '../lib/computer/loop.js';
 import { makeVerbDispatcher } from '../lib/computer/dispatch.js';
 import { makeClaudeResponder, resolveApiKey, DEFAULT_CLAUDE_MODEL, DEFAULT_CLAUDE_BASE_URL } from '../lib/computer/model.js';
+import { TASK_PREVIEW_MAX_CHARS } from '../lib/computer/sessions-list.js';
+import { runComputerSessionsCommand } from './computer-sessions-picker.js';
+import { truncate } from '../lib/events.js';
 // Help groups — mirror `agents browser` so the mental model carries over.
 const COMPUTER_HELP_GROUPS = [
     { title: 'Installation', names: ['setup'] },
@@ -18,6 +21,7 @@ const COMPUTER_HELP_GROUPS = [
     { title: 'Autonomous', names: ['run'] },
     { title: 'Observe', names: ['apps', 'describe', 'screenshot', 'get-text'] },
     { title: 'Interact', names: ['launch', 'raise', 'click', 'right-click', 'type', 'type-text', 'key', 'drag', 'scroll', 'ax-action', 'focus', 'wait'] },
+    { title: 'History and discovery', names: ['sessions'] },
 ];
 // Subcommands that manage the `--host` remote path themselves (provisioning /
 // tunnel lifecycle, or daemon-state reporting that must degrade gracefully
@@ -109,6 +113,7 @@ export function registerComputerSubcommands(program) {
     registerRunCommand(program);
     registerScreenshotCommand(program);
     registerActionCommands(program);
+    registerSessionsCommand(program);
     registerCommandGroups(program, COMPUTER_HELP_GROUPS);
 }
 function registerStatusCommand(program) {
@@ -300,6 +305,7 @@ function registerRunCommand(program) {
             model: opts.model,
             maxTokens: opts.maxTokens,
         });
+        emitComputerRunTaskMarker({ task: opts.task, bundle: opts.bundle, host: opts.host });
         await withClient(async (client) => {
             const dispatch = makeVerbDispatcher(client, { host: opts.host });
             const targetInput = opts.bundle ? { bundle: opts.bundle } : {};
@@ -324,6 +330,37 @@ function registerRunCommand(program) {
         });
     });
 }
+// sessions — task-first history over the computer.action event ledger (RUSH-2432),
+// the computer counterpart of `agents browser sessions` (RUSH-2407). `agents
+// sessions --computer` (sessions.ts) routes to the same runComputerSessionsCommand.
+function registerSessionsCommand(program) {
+    program
+        .command('sessions')
+        .description('Browse computer-driving history, grouped by run — one row per `agents computer` invocation')
+        .option('--machine <name>', 'Only rows invoked from/driving this machine (hostname, machineId, or --host device)')
+        .option('--limit <n>', 'Cap the flat/--no-interactive table at this many rows (default 50; --json is unbounded)', (v) => parseInt(v, 10))
+        .option('--json', 'Emit machine-readable JSON')
+        .option('--no-interactive', 'Print the flat listing instead of opening the interactive run browser')
+        .action(async (opts) => {
+        await runComputerSessionsCommand({ machine: opts.machine, limit: opts.limit, json: opts.json, interactive: opts.interactive });
+    });
+}
+/**
+ * Emit a `computer.action` marker for `computer run`'s whole loop process, so
+ * `agents computer sessions` groups every verb the loop drives under one
+ * task-labeled row instead of a bare pid with no task text (see
+ * lib/computer/sessions-list.ts's "Grouping key" docblock note). The task
+ * text is bounded to `TASK_PREVIEW_MAX_CHARS` — never the full unbounded
+ * `--task` string — matching that module's retention/privacy note. Exported
+ * so the truncation behavior is directly unit-testable against the real
+ * event ledger, the same seam `computer-actions.test.ts` already uses for
+ * `emitComputerAction`.
+ */
+export function emitComputerRunTaskMarker(opts) {
+    emitComputerAction('run', undefined, { bundle: opts.bundle, host: opts.host }, {
+        task: truncate(opts.task, TASK_PREVIEW_MAX_CHARS),
+    });
+}
 // Fold the target bundle into the task text so the model biases toward it.
 function describeTaskWithTarget(task, bundle) {
     return bundle ? `${task}\n(Target app bundle id: ${bundle})` : task;

package/dist/commands/config.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Unified configuration command barrel.
+ *
+ * `agents config` consolidates the fragmented config surface into one namespace:
+ *   - run defaults (model, mode, effort)
+ *   - tier overrides (folded into the run namespace)
+ *   - interactive host
+ *   - usage primary host
+ *   - browser profile
+ *   - local projects root
+ *   - per-device config keys
+ *
+ * The underlying YAML schema is unchanged; this command translates the new key
+ * grammar into reads/writes of the existing stores.
+ */
+import type { Command } from 'commander';
+export declare function registerConfigCommand(program: Command): void;