@phnx-labs/agents-cli 1.22.35 → 1.22.37

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;

package/dist/commands/config.js

@@ -0,0 +1,401 @@
+/**
+ * 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 chalk from 'chalk';
+import { setHelpSections } from '../lib/help.js';
+import { parseConfigKey, formatAgentVersion, devicePropertyToConfigName, configKeyStorageHint, } from '../lib/config-keys.js';
+import { resolveRunDefaults, setRunDefaultModel, setRunDefaultMode, setRunDefaultEffort, unsetRunDefault, } from '../lib/run-defaults.js';
+import { resolveTierOverride, setTierOverride, clearTierOverride } from '../lib/model-tier-overrides.js';
+import { getConfigValue, setConfigValue, unsetConfigValue, listConfig, } from '../lib/device-config.js';
+import { readMeta, updateMeta } from '../lib/state.js';
+import { MODEL_TIERS } from '../lib/model-tiers.js';
+import { machineId } from '../lib/machine-id.js';
+import { getProjectRoot, setProjectRoot } from '../lib/project-root.js';
+/** Parse a boolean value the same way `agents devices configure` does. */
+function parseBool(value, key) {
+    const v = value.trim().toLowerCase();
+    if (v === 'on' || v === 'true')
+        return true;
+    if (v === 'off' || v === 'false')
+        return false;
+    throw new Error(`Config key '${key}' expects a boolean ('on' or 'off'), got '${value}'.`);
+}
+/** Parse the value for a given key, enforcing type rules. */
+function parseValue(key, parsed, raw) {
+    switch (parsed.scope) {
+        case 'run':
+            return raw.trim();
+        case 'interactive':
+            return raw.trim();
+        case 'usage':
+            return raw.trim();
+        case 'browser':
+            return raw.trim();
+        case 'project':
+            return raw.trim();
+        case 'device': {
+            switch (parsed.property) {
+                case 'max-agents':
+                    if (!/^\d+$/.test(raw.trim())) {
+                        throw new Error(`Config key '${key}' expects an integer, got '${raw}'.`);
+                    }
+                    return Number.parseInt(raw.trim(), 10);
+                case 'scheduler':
+                case 'daemon':
+                case 'watchdog':
+                case 'browser.remote-control':
+                    return parseBool(raw, key);
+                case 'notes':
+                    return raw.trim();
+                case 'browser.profile':
+                    return raw.trim();
+            }
+        }
+    }
+}
+/** Write a value for a parsed config key. */
+function setConfig(parsed, value) {
+    switch (parsed.scope) {
+        case 'run': {
+            const selector = `${parsed.agent}:${parsed.version}`;
+            if (parsed.property === 'tier') {
+                setTierOverride(selector, parsed.tier, value);
+                return;
+            }
+            if (parsed.property === 'model') {
+                setRunDefaultModel(selector, value);
+            }
+            else if (parsed.property === 'mode') {
+                setRunDefaultMode(selector, value);
+            }
+            else {
+                setRunDefaultEffort(selector, value);
+            }
+            return;
+        }
+        case 'interactive': {
+            setConfigValue('interactive.host', value);
+            return;
+        }
+        case 'usage': {
+            setConfigValue('usage.primary-host', value);
+            return;
+        }
+        case 'browser': {
+            // Device-local default lives in the central fleet.devices.<name>.config
+            // block (same store `agents devices config` / getConfigValue use). Bare
+            // browser.profile targets this machine; devices.<name>.browser.profile
+            // targets a peer.
+            setConfigValue('browser.profile', value, parsed.device ? { device: parsed.device } : undefined);
+            return;
+        }
+        case 'project':
+            setProjectRoot(value);
+            return;
+        case 'device': {
+            const configName = devicePropertyToConfigName(parsed.property);
+            if (parsed.property === 'notes') {
+                const existing = getConfigValue('notes', { device: parsed.device }).value ?? [];
+                setConfigValue('notes', [...existing, value], { device: parsed.device });
+            }
+            else {
+                setConfigValue(configName, value, { device: parsed.device });
+            }
+            return;
+        }
+    }
+}
+/** Unset a parsed config key. */
+function unsetConfig(parsed) {
+    switch (parsed.scope) {
+        case 'run': {
+            const selector = `${parsed.agent}:${parsed.version}`;
+            if (parsed.property === 'tier') {
+                return clearTierOverride(selector, parsed.tier);
+            }
+            return unsetRunDefault(selector);
+        }
+        case 'interactive': {
+            const had = getConfigValue('interactive.host').value !== undefined;
+            unsetConfigValue('interactive.host');
+            return had;
+        }
+        case 'usage': {
+            const had = getConfigValue('usage.primary-host').value !== undefined;
+            unsetConfigValue('usage.primary-host');
+            return had;
+        }
+        case 'browser': {
+            const target = parsed.device ? { device: parsed.device } : undefined;
+            const had = getConfigValue('browser.profile', target).value !== undefined;
+            unsetConfigValue('browser.profile', target);
+            return had;
+        }
+        case 'project': {
+            const had = getProjectRoot() !== undefined;
+            updateMeta((meta) => {
+                const { projectRoot: _projectRoot, ...rest } = meta;
+                return rest;
+            });
+            return had;
+        }
+        case 'device': {
+            const configName = devicePropertyToConfigName(parsed.property);
+            const had = getConfigValue(configName, { device: parsed.device }).value !== undefined;
+            unsetConfigValue(configName, { device: parsed.device });
+            return had;
+        }
+    }
+}
+/** Read the stored value for a parsed config key. */
+function getConfig(parsed) {
+    switch (parsed.scope) {
+        case 'run': {
+            const defaults = resolveRunDefaults(parsed.agent, parsed.version);
+            if (parsed.property === 'tier') {
+                return resolveTierOverride(parsed.agent, parsed.version)[parsed.tier];
+            }
+            return defaults[parsed.property];
+        }
+        case 'interactive':
+            return getConfigValue('interactive.host').value;
+        case 'usage':
+            return getConfigValue('usage.primary-host').value;
+        case 'browser': {
+            return getConfigValue('browser.profile', parsed.device ? { device: parsed.device } : undefined).value;
+        }
+        case 'project':
+            return getProjectRoot();
+        case 'device': {
+            const configName = devicePropertyToConfigName(parsed.property);
+            return getConfigValue(configName, { device: parsed.device }).value;
+        }
+    }
+}
+/** Format a config value for display. */
+function formatValue(value) {
+    if (value === undefined)
+        return chalk.gray('(unset)');
+    if (typeof value === 'boolean')
+        return value ? chalk.green('true') : chalk.red('false');
+    return chalk.cyan(JSON.stringify(value));
+}
+/** Collect all set config entries for a given device scope (self or peer). */
+function* listRunConfigEntries() {
+    const meta = readMeta();
+    for (const [selector, defaults] of Object.entries(meta.run?.defaults ?? {})) {
+        const [agent, version] = selector.split(':');
+        if (!agent || !version)
+            continue;
+        const base = `run.${formatAgentVersion(agent, version)}`;
+        const d = defaults;
+        for (const prop of ['model', 'mode', 'effort']) {
+            if (d[prop] !== undefined) {
+                const key = `${base}.${prop}`;
+                yield { key, value: d[prop], hint: configKeyStorageHint(parseConfigKey(key)) };
+            }
+        }
+    }
+    for (const [selector, tiers] of Object.entries(meta.model?.tiers ?? {})) {
+        const [agent, version] = selector.split(':');
+        if (!agent || !version)
+            continue;
+        const base = `run.${formatAgentVersion(agent, version)}.tier`;
+        for (const tier of MODEL_TIERS) {
+            const value = tiers[tier];
+            if (value !== undefined) {
+                const key = `${base}.${tier}`;
+                yield { key, value, hint: configKeyStorageHint(parseConfigKey(key)) };
+            }
+        }
+    }
+}
+/** Collect central non-run config entries. */
+function* listCentralConfigEntries() {
+    const meta = readMeta();
+    if (meta.config?.interactiveHost !== undefined) {
+        yield { key: 'interactive.host', value: meta.config.interactiveHost, hint: 'config.interactiveHost' };
+    }
+    if (meta.config?.usagePrimaryHost !== undefined) {
+        yield { key: 'usage.primary-host', value: meta.config.usagePrimaryHost, hint: 'config.usagePrimaryHost' };
+    }
+    if (meta.projectRoot !== undefined) {
+        yield { key: 'project.root', value: meta.projectRoot, hint: 'devices.<self>.projectRoot' };
+    }
+    // This machine's default browser profile lives in fleet.devices.<self>.config
+    // (device-config), not the legacy top-level Meta.defaultBrowserProfile field.
+    const browserProfile = getConfigValue('browser.profile').value;
+    if (browserProfile !== undefined) {
+        const key = 'browser.profile';
+        yield { key, value: browserProfile, hint: configKeyStorageHint(parseConfigKey(key)) };
+    }
+}
+/** Collect device-scope config entries. */
+function* listDeviceConfigEntries(device) {
+    for (const entry of listConfig({ device })) {
+        if (entry.value === undefined)
+            continue;
+        const prefix = `devices.${device}.`;
+        let key;
+        switch (entry.spec.name) {
+            case 'agents.max-concurrent':
+                key = `${prefix}max-agents`;
+                break;
+            case 'scheduler.enabled':
+                key = `${prefix}scheduler`;
+                break;
+            case 'daemon.enabled':
+                key = `${prefix}daemon`;
+                break;
+            case 'watchdog.enabled':
+                key = `${prefix}watchdog`;
+                break;
+            case 'browser.remote-control':
+                key = `${prefix}browser.remote-control`;
+                break;
+            case 'notes':
+                key = `${prefix}notes`;
+                break;
+            case 'browser.profile':
+                // The self device's default browser profile is already surfaced as the
+                // top-level `browser.profile` key; skip it here to avoid duplication.
+                if (device === machineId())
+                    continue;
+                key = `${prefix}browser.profile`;
+                break;
+            default:
+                continue;
+        }
+        yield { key, value: entry.value, hint: configKeyStorageHint(parseConfigKey(key)) };
+    }
+}
+export function registerConfigCommand(program) {
+    const config = program
+        .command('config')
+        .description('Get, set, list, and unset run defaults, tier overrides, the projects root, and device options.');
+    setHelpSections(config, {
+        examples: `
+      agents config set run.claude@*.model best
+      agents config set run.claude@*.tier.best claude-opus-4-8
+      agents config set run.claude@2.1.45.model claude-opus-4-8
+      agents config set run.claude@*.mode auto
+      agents config set interactive.host zion
+      agents config set usage.primary-host zion
+      agents config set browser.profile work
+      agents config set project.root ~/src/github.com/<you>
+      agents config set devices.mac-mini.max-agents 4
+      agents config get run.claude@*.model
+      agents config get usage.primary-host
+      agents config unset run.claude@*.tier.best
+      agents config unset usage.primary-host
+      agents config list
+    `,
+        notes: `
+      Every agent/harness reference uses agent@version. Use * for all versions.
+      Tier overrides are part of the run namespace: run.<agent@version>.tier.<tier>.
+      Project root is auto-inferred from the current Git repository when unset.
+    `,
+    });
+    config
+        .command('list')
+        .description('List configured config keys and their values')
+        .option('--device <name>', 'List config for a specific device instead of this machine')
+        .option('--json', 'Output machine-readable JSON')
+        .action((opts) => {
+        try {
+            const entries = [];
+            if (!opts.device) {
+                entries.push(...listRunConfigEntries());
+                entries.push(...listCentralConfigEntries());
+                entries.push(...listDeviceConfigEntries(machineId()));
+            }
+            else {
+                entries.push(...listDeviceConfigEntries(opts.device));
+            }
+            entries.sort((a, b) => a.key.localeCompare(b.key));
+            if (opts.json) {
+                process.stdout.write(JSON.stringify(entries, null, 2) + '\n');
+                return;
+            }
+            if (entries.length === 0) {
+                console.log(chalk.gray('No config values set.'));
+                console.log(chalk.gray("Set one with: agents config set run.claude@*.model best"));
+                return;
+            }
+            console.log(chalk.bold('Config\n'));
+            for (const { key, value, hint } of entries) {
+                console.log(`  ${chalk.cyan(key.padEnd(42))} ${formatValue(value)}`);
+                console.log(`  ${''.padEnd(42)} ${chalk.gray(hint)}`);
+            }
+        }
+        catch (err) {
+            console.error(chalk.red(err.message));
+            process.exit(1);
+        }
+    });
+    config
+        .command('get <key>')
+        .description('Get the current value of a config key')
+        .option('--json', 'Output machine-readable JSON')
+        .action((key, opts) => {
+        try {
+            const parsed = parseConfigKey(key);
+            const value = getConfig(parsed);
+            if (opts.json) {
+                process.stdout.write(JSON.stringify({ key, value: value ?? null }, null, 2) + '\n');
+                return;
+            }
+            console.log(`${chalk.cyan(key)} = ${formatValue(value)}`);
+        }
+        catch (err) {
+            console.error(chalk.red(err.message));
+            process.exit(1);
+        }
+    });
+    config
+        .command('set <key> <value>')
+        .description('Set a config key')
+        .action((key, value) => {
+        try {
+            const parsed = parseConfigKey(key);
+            const typed = parseValue(key, parsed, value);
+            setConfig(parsed, typed);
+            console.log(chalk.green('Set:') + ` ${chalk.cyan(key)} = ${formatValue(typed)}`);
+        }
+        catch (err) {
+            console.error(chalk.red(err.message));
+            process.exit(1);
+        }
+    });
+    config
+        .command('unset <key>')
+        .description('Unset a config key (restore default behavior)')
+        .action((key) => {
+        try {
+            const parsed = parseConfigKey(key);
+            const removed = unsetConfig(parsed);
+            if (removed) {
+                console.log(chalk.green(`Unset ${key}`));
+            }
+            else {
+                console.log(chalk.gray(`No value set for ${key}`));
+            }
+        }
+        catch (err) {
+            console.error(chalk.red(err.message));
+            process.exit(1);
+        }
+    });
+}