@phnx-labs/agents-cli 1.22.35 → 1.22.37

package/dist/commands/sessions.js

@@ -14,14 +14,14 @@ import { spawn } from 'child_process';
 import { Option } from 'commander';
 import chalk from 'chalk';
 import { truncate, padRight, humanDuration } from '../lib/format.js';
-import { sanitizeForTerminal } from '../lib/redact.js';
+import { sanitizeForTerminal, redactSecrets } from '../lib/redact.js';
 import { resolveProjectKey } from '../lib/project-key.js';
 import { listProjectDefs, resolveProjectNameForCwd } from '../lib/projects.js';
 import ora from 'ora';
 import { SESSION_AGENTS } from '../lib/session/types.js';
 import { discoverArtifacts, readArtifact, resolveArtifact } from '../lib/session/artifacts.js';
 import { looksLikePath, toComparablePath, homeDir, needsWindowsShell, composeWin32CommandLine } from '../lib/platform/index.js';
-import { getActiveSessions } from '../lib/session/active.js';
+import { getActiveSessions, sessionProcessIsLocal } from '../lib/session/active.js';
 import { enumerateGhosttyTabs, assignGhosttyTabs } from '../lib/session/ghostty-tabs.js';
 import { mapPanesToTargets, listClients } from '../lib/tmux/session.js';
 import { resolveViewingIn, viewingInLabel } from '../lib/session/viewing-in.js';
@@ -29,10 +29,11 @@ import { machineId, normalizeHost } from '../lib/session/sync/config.js';
 import { gatherRemoteActive, NO_FANOUT_ENV } from '../lib/session/remote-active.js';
 import { loadFleetActiveSessions, loadLocalActiveSessions, } from '../lib/session/session-cache.js';
 import { gatherRemoteList, gatherRemoteToolProgramCounts, gatherRemoteToolSearch, runOnPeer } from '../lib/session/remote-list.js';
+import { gatherRemoteAgentsJson } from '../lib/remote-agents-json.js';
 import { stringWidth, truncateToWidth, padToWidth, terminalWidth } from '../lib/session/width.js';
 import { inferSessionState } from '../lib/session/state.js';
 import { discoverSessions, queryIndexedSessions, countSessionsInScope, resolveSessionById, isCompleteSessionId, looksLikeSessionId, searchContentIndex, getSessionRoots, scopeToManaged } from '../lib/session/discover.js';
-import { findSessionsById, querySessions, getSessionById } from '../lib/session/db.js';
+import { findSessionsById, querySessions, getSessionById, readSessionContent, readArchivedSessionPreview } from '../lib/session/db.js';
 import { filterTeamSessions, shouldShowTeamSessions, safeTeamText, groupSessionsByTeam, NO_TEAM_GROUP_KEY, } from '../lib/session/team-filter.js';
 import { parseSession } from '../lib/session/parse.js';
 import { runRemoteSessions, buildForwardedArgs, ensureWholeIndex } from '../lib/session/remote.js';
@@ -73,7 +74,10 @@ import { registerSessionsBackfillCommand } from './sessions-backfill.js';
 import { registerSessionsStatsCommand } from './sessions-stats.js';
 import { registerSessionsInsightsCommand } from './insights.js';
 import { registerSessionsOptimizeCommand } from './sessions-optimize.js';
+import { registerSessionsWatchCommand } from './sessions-watch.js';
 import { runBrowserSessionsCommand } from './browser-sessions-picker.js';
+import { runComputerSessionsCommand } from './computer-sessions-picker.js';
+import { buildComputerSessionRows } from '../lib/computer/sessions-list.js';
 import { countToolProgramOccurrences, parseToolProgramCountClause, readToolIndexCoverage, searchToolCalls, TOOL_QUERY_MAX_CLAUSE_BYTES, TOOL_QUERY_MAX_CLAUSES, TOOL_QUERY_MAX_RESULT_SESSIONS, serializeToolSearchEnvelope, toolSearchRemoteReceiveBudget, } from '../lib/session/tool-index.js';
 const SESSION_AGENT_FILTER_HELP = `Filter by agent, e.g. claude, codex, claude@2.0.65`;
 function collectQueryClause(value, previous) {
@@ -669,6 +673,29 @@ export function serializeActiveSessionsForJson(sessions) {
         viewingIn: viewingInLabel(s) ?? null,
     }));
 }
+/** Canonical JSON row consumed by resume pickers and other session UIs. */
+export function serializeSessionPickerRows(sessions, liveSessions, self = machineId()) {
+    const liveById = new Map(liveSessions.filter((row) => row.sessionId).map((row) => [row.sessionId, row]));
+    return sessions.map((session) => {
+        const live = liveById.get(session.id);
+        const sourceDevice = live?.machine ?? session.machine ?? self;
+        const viewingIn = live ? viewingInLabel(live) ?? null : null;
+        const resumable = buildResumeCommand(session) !== null;
+        return {
+            ...session,
+            state: live?.status ?? 'inactive',
+            resumable,
+            unwatched: !viewingIn,
+            viewingIn,
+            sourceDevice,
+            lastActivityMs: live?.lastActivityMs ?? Date.parse(session.lastActivity ?? session.timestamp),
+            pid: live?.pid ?? null,
+            recovery: resumable
+                ? { command: 'agents', args: ['sessions', 'resume', session.id, '--device', sourceDevice], ...(session.cwd ? { cwd: session.cwd } : {}) }
+                : null,
+        };
+    });
+}
 /**
  * Compact, colour-coded badges for the durable/awaiting signals. Text-only (no
  * emoji, per repo convention): `plan` / `ask` / `perm` for why it's waiting,
@@ -984,7 +1011,7 @@ export function groupSessionsByMachine(sessions, localMachine) {
  * correlated, so they're all kept.
  */
 export function dedupeByMachineSession(sessions) {
-    const seen = new Set();
+    const seen = new Map();
     const out = [];
     for (const s of sessions) {
         if (!s.sessionId) {
@@ -992,13 +1019,38 @@ export function dedupeByMachineSession(sessions) {
             continue;
         }
         const key = `${s.machine ?? ''}:${s.sessionId}`;
-        if (seen.has(key))
+        const at = seen.get(key);
+        if (at === undefined) {
+            seen.set(key, out.length);
+            out.push(s);
             continue;
-        seen.add(key);
-        out.push(s);
+        }
+        // Both rows now describe the same session on the same machine, so the tie is
+        // between the EXECUTING box's own row and the dispatcher's shim row for a
+        // host-dispatched run (they only started colliding once foldExecutionMachine
+        // attributed both to the executing host — RUSH-2479). The shim carries no
+        // transcript and a `[host/<peer>]` placeholder label, so keeping it first
+        // would strip a real preview off the merged fleet view. Prefer the row that
+        // is not an offload shim; otherwise the first one still wins.
+        if (out[at].offloadedFrom && !s.offloadedFrom)
+            out[at] = s;
     }
     return out;
 }
+/**
+ * Narrow a gathered live set to the machines an explicit `--host`/`--device`
+ * scope named. The gather picks which boxes to ASK; this asserts what the answer
+ * may contain, and the two are not the same question: a host-dispatched run is
+ * reported by the box that dispatched it while executing somewhere else, so
+ * `--device <dispatcher>` used to list sessions that were not running there at
+ * all (RUSH-2479). No scope → unchanged. Pure; exported for unit testing.
+ */
+export function filterActiveSessionsByHostScope(sessions, hosts, self) {
+    if (!hosts || hosts.length === 0)
+        return sessions;
+    const wanted = new Set(hosts.map(hostToken));
+    return sessions.filter((s) => wanted.has(s.machine ?? self));
+}
 /**
  * Order a merged listing so the local machine's sessions come first, then each
  * remote machine as a contiguous block (more sessions first, then name), with
@@ -1090,6 +1142,41 @@ async function runRemoteSessionsJson(hosts) {
     const { sessions } = await gatherRemoteList(forwarded, hosts);
     process.stdout.write(serializeSessionsJson(sessions));
 }
+/** Parse one peer's computer-run array without accepting banners or partial
+ * JSON. The fan-out boundary supplies the machine name when an older peer row
+ * omitted it. */
+export function parseRemoteComputerSessionRows(stdout, machine) {
+    try {
+        const value = JSON.parse(stdout);
+        if (!Array.isArray(value))
+            return { items: [], valid: false };
+        const items = value
+            .filter((row) => Boolean(row && typeof row === 'object' && !Array.isArray(row)))
+            .map((row) => ({ ...row, machine: row.machine || machine }));
+        return { items, valid: true };
+    }
+    catch {
+        return { items: [], valid: false };
+    }
+}
+/** Collect computer history from named peers, or every automatic peer when
+ * hosts is omitted. Every peer is forced to JSON and receives the recursion
+ * guard through the shared fleet transport. */
+export async function gatherRemoteComputerSessionRows(hosts) {
+    const hostSet = new Set(hosts ?? []);
+    const forwarded = buildForwardedArgs(process.argv, hostSet);
+    if (!forwarded.includes('--json'))
+        forwarded.push('--json');
+    if (!forwarded.includes('--no-interactive'))
+        forwarded.push('--no-interactive');
+    const result = await gatherRemoteAgentsJson({
+        args: forwarded,
+        noFanoutEnv: NO_FANOUT_ENV,
+        hosts,
+        parse: parseRemoteComputerSessionRows,
+    });
+    return result.items;
+}
 /**
  * `running N · idle N · waiting N · queued N · closed N · abandoned N · unknown N`
  * for a bucket of sessions (zero buckets omitted). Same bucketing as the summary so
@@ -1351,7 +1438,15 @@ async function gatherActiveSessionsLive(opts = {}) {
             merged = dedupeByMachineSession([...local, ...remote.sessions]);
         }
     }
-    return { sessions: merged, remoteDeviceCount };
+    // Asking a box is not the same as a session running there: a host-dispatched
+    // run is reported by its dispatcher while executing on the peer. Scope on the
+    // machine the session runs on so `--device X` never lists someone else's work
+    // (RUSH-2479). Applied here, in the single gather, so the interactive browser
+    // gets the same answer as `--active --json`.
+    return {
+        sessions: filterActiveSessionsByHostScope(merged, opts.hosts, self),
+        remoteDeviceCount,
+    };
 }
 /**
  * Render the unified active-session view, grouped by machine. Scoping and the
@@ -1387,7 +1482,7 @@ async function renderActiveSessions(asJson, waitingOnly = false, opts = {}) {
         // is how a consumer distinguishes a session someone is looking at from one
         // running orphaned after its terminal died. tmux-only (no osascript) so the
         // scriptable path stays cheap — see enrichTmuxLocators.
-        await enrichTmuxLocators(sessions.filter(s => !s.machine || s.machine === self));
+        await enrichTmuxLocators(sessions.filter(s => sessionProcessIsLocal(s, self)));
         process.stdout.write(JSON.stringify(serializeActiveSessionsForJson(sessions), null, 2) + '\n');
         if (waitingOnly && sessions.some(isAwaitingUser))
             process.exitCode = 1;
@@ -1402,7 +1497,7 @@ async function renderActiveSessions(asJson, waitingOnly = false, opts = {}) {
     // Enrich LOCAL sessions with jump locators (display-only, after the --json /
     // --waiting gates so scriptable output stays osascript-free). Remote sessions
     // keep their raw pane id — their tmux/Ghostty live on the other machine.
-    await enrichLocalLocators(sessions.filter(s => !s.machine || s.machine === self));
+    await enrichLocalLocators(sessions.filter(s => sessionProcessIsLocal(s, self)));
     const grouped = groupSessionsByMachine(sessions, self);
     let firstMachine = true;
     for (const mg of grouped.machines) {
@@ -1944,9 +2039,15 @@ export async function renderSessionPreview(query, scope) {
         }
     }
     if (outcome.kind === 'partial') {
-        console.error(chalk.red(`Partial session resolution: ${outcome.failedPeers.join(', ')} did not answer.`));
-        console.error(chalk.gray('No preview was rendered because the short ID may be ambiguous on an unreachable peer.'));
-        process.exitCode = 2;
+        // RUSH-2492: an unreachable peer is a warning, not a hard failure. The
+        // resolver already resolves an id found on the reachable fleet (SES-9a),
+        // so reaching here means the session was not found on any device we COULD
+        // reach — it may live on an unreachable peer, which we could not check.
+        const offline = outcome.failedPeers;
+        console.error(chalk.yellow(`Warning: ${offline.length} device(s) unreachable, not checked: ${offline.join(', ')}`));
+        console.error(chalk.red(`No session matching "${query}" on any reachable device (${offline.length} unreachable, not checked).`));
+        console.error(chalk.gray('  If it lives on an offline box, wake it (agents devices) or run there: agents ssh <device>'));
+        process.exitCode = 1;
         return;
     }
     if (outcome.kind === 'not-found') {
@@ -2722,7 +2823,14 @@ limitSource) {
             const filtered = searchQuery
                 ? resolveSessionQuery(sessions, searchQuery).matches
                 : sessions;
-            process.stdout.write(serializeSessionsJson(filtered));
+            // JSON is the canonical picker contract: enrich the durable rows once
+            // from the shared live cache so every consumer gets lifecycle/recovery
+            // metadata without performing its own join or transcript scan.
+            const live = await gatherActiveSessions({
+                local: options.local === true || process.env[NO_FANOUT_ENV] === '1',
+                hosts: options.host,
+            });
+            process.stdout.write(serializeSessionsJson(serializeSessionPickerRows(filtered, live.sessions)));
             return;
         }
         // Cross-machine fan-out: unless --local (or we ARE a peer answering a
@@ -3351,10 +3459,79 @@ export async function renderSessionLog(session, mode = 'summary') {
 export async function renderSessionLogJson(session) {
     await renderSession(session, 'json', {});
 }
+/**
+ * Render a file-gone (archived) session from the local DB (RUSH-2436). The
+ * transcript file is deleted, but the user turns survive in session_text and the
+ * last-computed digest in session_preview_cache — serve those so `agents sessions
+ * <id>` still shows the prompts instead of an empty metadata dump. User-turn text
+ * is the durable content every harness stores; assistant text survives only as
+ * the cached digest's `lastAssistant` snippet, shown when present.
+ */
+function renderArchivedSession(session, mode, options = {}) {
+    // Redact by default, mirroring the live render path (render.ts renderConversationMarkdown):
+    // session_text stores raw user text, so masking is render-time. `--no-redact`
+    // opts out, same as the live path.
+    const redact = (text) => options.redact !== false ? redactSecrets(text) : text;
+    const content = redact((readSessionContent(session.id) ?? '').trim());
+    const digestRaw = readArchivedSessionPreview(session.id);
+    const digest = digestRaw
+        ? { ...digestRaw, lastAssistant: redact(digestRaw.lastAssistant ?? '') }
+        : undefined;
+    if (mode === 'json') {
+        // Minimal machine shape for a file-gone session: the durable user content
+        // plus the cached preview digest, tagged archived. Deliberately NOT the full
+        // { session, events } contract — there are no events to parse. Redact the
+        // first-message-excerpt meta fields (topic/label/plan) too, matching the live
+        // single-session --json (render.ts redactJson), so `--json` masks them unless
+        // --no-redact is passed.
+        console.log(JSON.stringify({
+            session: {
+                ...session,
+                topic: session.topic != null ? redact(session.topic) : session.topic,
+                label: session.label != null ? redact(session.label) : session.label,
+                plan: session.plan != null ? redact(session.plan) : session.plan,
+                archived: true,
+            },
+            archived: true,
+            userContent: content,
+            preview: digest ?? null,
+        }, null, 2));
+        return;
+    }
+    const agentColor = colorAgent(session.agent);
+    const absTime = formatAbsoluteTime(session.timestamp);
+    const title = session.label || session.topic;
+    console.log('');
+    if (title)
+        console.log(chalk.bold.white(title));
+    console.log(agentColor(session.agent) +
+        (session.version ? chalk.yellow(` ${session.version}`) : '') +
+        (session.project ? chalk.cyan(`  ${session.project}`) : '') +
+        chalk.gray(`  ${absTime} (${formatRelativeTime(session.timestamp)})`) +
+        (session.account ? chalk.gray(` · ${session.account}`) : ''));
+    console.log(chalk.yellow('archived — transcript file removed; user turns served from the local DB'));
+    console.log(chalk.gray('─'.repeat(60)));
+    console.log(chalk.cyan('User:'));
+    console.log(content);
+    if (digest?.lastAssistant?.trim()) {
+        console.log('');
+        console.log(chalk.magenta('Last assistant:'));
+        console.log(digest.lastAssistant.trim());
+    }
+}
 async function renderSession(session, mode, filters, options = {}) {
     // OpenCode stores sessions in SQLite; filePath is "db_path#session_id"
     const realPath = session.filePath.split('#')[0];
     if (!fs.existsSync(realPath)) {
+        // The transcript file is gone, but the session's user turns are stored
+        // durably in the local DB (session_text), so serve those instead of a bare
+        // metadata dump (RUSH-2436). This is what makes an archived session still
+        // render its prompts after `agents remove` / rm / a box reimage.
+        const archivedContent = readSessionContent(session.id);
+        if (archivedContent && archivedContent.trim() !== '') {
+            renderArchivedSession(session, mode, options);
+            return;
+        }
         console.log(chalk.yellow('Session transcript not available (file no longer exists).'));
         console.log(chalk.gray(`Path: ${session.filePath}`));
         if (session.version)
@@ -4265,8 +4442,15 @@ async function renderOneSession(query, mode, scope) {
     if (looksLikeSessionId(query)) {
         const outcome = await resolveSessionMetadataValue(query, scope);
         if (outcome.kind === 'partial') {
-            console.error(chalk.red(`Partial session resolution: ${outcome.failedPeers.join(', ')} did not answer.`));
-            process.exit(2);
+            // RUSH-2492: an unreachable peer is a warning, not a hard failure. The
+            // resolver already resolves an id found on the reachable fleet (SES-9a),
+            // so reaching here means the session was not found on any device we
+            // COULD reach — it may live on an unreachable peer we could not check.
+            const offline = outcome.failedPeers;
+            console.error(chalk.yellow(`Warning: ${offline.length} device(s) unreachable, not checked: ${offline.join(', ')}`));
+            console.error(chalk.red(`No session matching "${query}" on any reachable device (${offline.length} unreachable, not checked).`));
+            console.error(chalk.gray('  If it lives on an offline box, wake it (agents devices) or run there: agents ssh <device>'));
+            process.exit(1);
         }
         // An index miss can be a transcript created since the last incremental
         // scan, or a Claude history alias. Fall through to the established
@@ -4459,6 +4643,11 @@ const FULL_SESSION_ID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-
  * the wrong session (whichever peer replied first). Labels therefore stay
  * all-settle so a cross-machine label conflict surfaces as an ambiguity, and a
  * short-id PREFIX stays all-settle for the same reason (RUSH-2203).
+ *
+ * This is about cancelling a sweep that is still IN FLIGHT, where a peer that
+ * has not answered yet is still expected to. It is deliberately stricter than
+ * `isUniqueEnoughSelector`, which decides what to do once the sweep is OVER and
+ * a peer has definitively not answered — see SES-9a.
  */
 export function isDefinitiveMatch(session, selector) {
     return FULL_SESSION_ID_RE.test(selector) && session.id.toLowerCase() === selector.trim().toLowerCase();
@@ -4545,23 +4734,54 @@ export function toolSearchForwardedArgs(argv, hosts) {
         args.push('--local');
     return args;
 }
-/** Resolution fails closed for prefixes/keywords when a peer did not answer.
- * A full UUID is globally unique, so one exact hit is sufficient even when an
- * unrelated registered device is offline. */
+/** Width of the short id the CLI prints everywhere (`SessionMeta.shortId`):
+ * 8 hex chars / 32 bits. A selector shorter than this is treated as a keyword,
+ * not an identifier. */
+const SHORT_SESSION_ID_WIDTH = 8;
+/**
+ * Whether a selector names ONE session precisely enough to resolve from the
+ * reachable fleet alone when some peer did not answer (SES-9a).
+ *
+ * Deliberately stricter than `looksLikeSessionId`, which accepts any 6+ char
+ * `[0-9a-f-]` run and so matches ordinary words (`facade`, `decade`, `beaded`).
+ * Those are keywords a user typed as a search, not identifiers, and they must
+ * keep waiting for every peer.
+ */
+export function isUniqueEnoughSelector(selector) {
+    const trimmed = selector.trim();
+    if (isCompleteSessionId(trimmed))
+        return true;
+    return /^[0-9a-f-]+$/i.test(trimmed)
+        && trimmed.replace(/-/g, '').length >= SHORT_SESSION_ID_WIDTH;
+}
+/** Resolution fails closed for keywords and labels when a peer did not answer.
+ * An id-shaped selector at least `SHORT_SESSION_ID_WIDTH` hex chars wide (or a
+ * complete id) resolves from a single reachable hit even when an unrelated
+ * registered device is offline — see SES-9a for the accepted collision risk. */
 export function metadataResolveOutcome(localMatches, remote, selector) {
     // Every peer answered through --resolve-safe-v1, so its native-id row is
     // already the result of resolving the original selector. Re-filtering by the
     // selector would discard alias suffixes such as c1f3d813 because the native
     // UUID intentionally has a different prefix.
     const candidates = fleetCandidatesByQuery([...localMatches, ...remote.sessions], selector, true);
-    // A full UUID is globally unique, so one exact hit resolves even when an
-    // unrelated registered device is offline. A label is NOT globally unique — a
-    // distinct session may carry the same label on an unreachable peer — so it
-    // stays fail-closed: a unique label auto-resumes only once every peer has
-    // answered (candidates.length === 1 below), and an unreachable peer forces
-    // `partial` rather than guessing. (RUSH-2203: early-exit is UUID-only for the
-    // same reason — see isDefinitiveMatch.)
-    if (FULL_SESSION_ID_RE.test(selector) && candidates.length === 1 && candidates[0].id.toLowerCase() === selector.toLowerCase()) {
+    // One hit on the REACHABLE fleet resolves a precise-enough id selector even
+    // when a peer is offline (SES-9a). This is a deliberate, bounded trade, not a
+    // claim that prefixes cannot collide — they can, which is why the `ambiguous`
+    // branch below still exists for peers that DID answer:
+    //   - refusing costs 100% of lookups on any fleet with a permanently offline
+    //     device (9 of them here), to avoid a prefix collision that ALSO has to
+    //     land on the one box that did not answer. Rate depends on the id type:
+    //     a UUIDv4 short id is unique in practice, while a time-ordered
+    //     UUIDv7/ULID prefix is largely a timestamp and collides much more
+    //     readily (see deriveShortId in session/db.ts);
+    //   - `isUniqueEnoughSelector` keeps this off keyword-shaped queries, so a
+    //     6-char word like `facade` or `decade` is not treated as an identifier.
+    // A label stays fail-closed at any length: labels are free-form and collide by
+    // design, so one hit there really is a guess.
+    // (RUSH-2203's early-exit stays UUID-only — see isDefinitiveMatch — because
+    // that cancels the sweep mid-flight, where a peer that has not answered YET is
+    // still expected to answer. Here the sweep is already over.)
+    if (isUniqueEnoughSelector(selector) && candidates.length === 1) {
         return { kind: 'resolved', session: candidates[0].hits[0].session };
     }
     if (remote.unreachable.length > 0)
@@ -4610,8 +4830,11 @@ export async function resolveSessionMetadataValue(selector, scope = {}, deps = {
 }
 /** Resolve one selector to indexed metadata across the fleet without reading or
  * rendering transcript events. A peer answering the parent sweep returns every
- * local candidate; the parent performs the one logical-session uniqueness gate. */
-async function resolveSessionMetadata(selector, scope, deps = { gatherRemoteList }) {
+ * local candidate; the parent performs the one logical-session uniqueness gate.
+ * Backs `agents sessions --resolve <selector> --json`. Exported (deps already
+ * injectable) so tests can drive this real call site against a fake fan-out
+ * instead of only the pure resolver it wraps. */
+export async function resolveSessionMetadata(selector, scope, deps = { gatherRemoteList }) {
     const localMachine = machineId();
     const includeLocal = !scope.hosts?.length || shouldIncludeLocal(scope.hosts, localMachine);
     const indexed = includeLocal ? indexedRowsForSelector(selector, scope) : [];
@@ -4625,9 +4848,15 @@ async function resolveSessionMetadata(selector, scope, deps = { gatherRemoteList
     }
     const outcome = await resolveSessionMetadataValue(selector, scope, deps);
     if (outcome.kind === 'partial') {
-        console.error(chalk.red(`Partial session resolution: ${outcome.failedPeers.join(', ')} did not answer.`));
-        console.error(chalk.gray('No unique/no-match decision was made. Upgrade or reconnect every peer, then retry.'));
-        process.exit(2);
+        // RUSH-2492: an unreachable peer is a warning, not a hard failure. The
+        // resolver already resolves an id found on the reachable fleet (SES-9a),
+        // so reaching here means the session was not found on any device we
+        // COULD reach — it may live on an unreachable peer we could not check.
+        const offline = outcome.failedPeers;
+        console.error(chalk.yellow(`Warning: ${offline.length} device(s) unreachable, not checked: ${offline.join(', ')}`));
+        console.error(chalk.red(`No session matching "${selector}" on any reachable device (${offline.length} unreachable, not checked).`));
+        console.error(chalk.gray('  If it lives on an offline box, wake it (agents devices) or run there: agents ssh <device>'));
+        process.exit(1);
     }
     if (outcome.kind === 'not-found') {
         console.error(chalk.red(`No session found matching: ${selector}`));
@@ -4766,6 +4995,7 @@ export function registerSessionsCommands(program) {
         .option('--fleet', 'With --include tools: query every registered online compute device and merge compact matches')
         .option('--count', 'With one program:<name> tool query: count static occurrences, containing calls, and sessions')
         .option('--browser', 'List browser-profile captures (screenshots, PDFs, recordings, downloads) instead of agent transcripts — alias of `agents browser sessions`')
+        .option('--computer', 'List computer-driving history, grouped by run, instead of agent transcripts — alias of `agents computer sessions`')
         .option('--no-interactive', 'Print the listing instead of opening the interactive browser (default on a TTY for the bare listing and --active)')
         .option('--print-cmd', 'Print the canonical `ag sessions …` command for the given flags and exit (the twin of the browser’s `y` hotkey)')
         .option('--preview', 'With a session id/query: print a compact preview and exit (no pager)');
@@ -4789,17 +5019,17 @@ export function registerSessionsCommands(program) {
       agents sessions --orphan
       agents sessions --crashed
 
-      # --- Session lifecycle (one verb per intent) ---
-      # Focus a session (attach its living terminal, or recover an ended one)
-      agents sessions focus a1b2c3d4
-      # Attach only — never fork a copy (old: sessions go)
-      agents sessions focus a1b2c3d4 --attach-only
-      # Interactive → headless (keep working unattended)
-      agents sessions detach a1b2c3d4
-      # Headless → interactive in this terminal
-      agents sessions attach a1b2c3d4
+      # --- Session lifecycle ---
+      # Get back into a session — attaches a live pane, or recovers an ended one
+      agents sessions resume a1b2c3d4
+      # Same, by the tmux name shown in: agents tmux ls
+      agents sessions resume ag-claude-a1b2c3d4
+      # Attach only — never fork a copy
+      agents sessions resume a1b2c3d4 --attach-only
       # Multi-select history and open each in a tab
       agents sessions resume
+      # The other direction: interactive → headless (keep working unattended)
+      agents sessions detach a1b2c3d4
 
       # The interactive list folds in other online machines automatically,
       # labelled by host with this machine first. Stay local with --local:
@@ -4851,12 +5081,12 @@ export function registerSessionsCommands(program) {
       agents sessions --all "deploy script" --host box-a --host box-b
     `,
         notes: `
-      Session lifecycle (pick one verb — they are not synonyms):
-        focus [selector]        attach a living pane, or recover on the origin device
-        focus [id] --attach-only  attach only; never fork (replaces sessions go)
-        detach <id>             interactive → headless continuation
-        attach <id>             headless → interactive in this terminal
-        resume [query]          multi-select history → open tabs (or run --resume <id>)
+      Session lifecycle — ONE verb gets you back in, it detects the state:
+        resume <id|alias>       live pane -> attach; headless -> foreground; ended -> recover
+        resume <id> --attach-only  attach only; never fork a copy
+        resume                  multi-select history -> open tabs
+        detach <id>             the other direction: interactive -> headless
+        (retired, still working for one release: sessions attach, sessions go, reconnect)
       - The interactive listing and every live-status flag fold in your other online machines automatically (live over SSH, no sync) — each row is labelled by host, this machine first. Use --local to skip the fan-out; single-id lookups stay local.
       - --all is not a device flag: it widens historical directory and time filters. Fleet collection is already the default. A status flag (--working/--idle/--waiting/--orphan/--crashed/--closed/--abandoned/--queued/--unknown) implies --active; combine status flags for a union.
       - --version <version> requires --agent and is equivalent to --agent <agent@version>.
@@ -4883,6 +5113,26 @@ export function registerSessionsCommands(program) {
             await runBrowserSessionsCommand({ profile: query, json: options.json, interactive: options.interactive });
             return;
         }
+        if (options.computer) {
+            // Alias for `agents computer sessions`: a machine positional narrows to
+            // one machine. `--no-interactive` carries through the same way.
+            const limit = options.limit === undefined ? undefined : Number.parseInt(options.limit, 10);
+            const deviceArgs = [...(options.device ?? []), ...(options.devices ?? [])];
+            const allFleet = deviceArgs.some((host) => ['all', 'fleet'].includes(host.toLowerCase()));
+            const hosts = [...(options.host ?? []), ...deviceArgs]
+                .filter((host) => !['all', 'fleet'].includes(host.toLowerCase()));
+            if (hosts.length > 0 || allFleet) {
+                const remoteRows = await gatherRemoteComputerSessionRows(allFleet ? undefined : hosts);
+                const rows = allFleet
+                    ? [...buildComputerSessionRows({ machine: query }), ...remoteRows]
+                    : remoteRows;
+                rows.sort((a, b) => b.endMs - a.endMs);
+                await runComputerSessionsCommand({ rows, machine: query, limit, json: options.json, interactive: options.interactive });
+                return;
+            }
+            await runComputerSessionsCommand({ machine: query, limit, json: options.json, interactive: options.interactive });
+            return;
+        }
         await sessionsAction(query, options, command.getOptionValueSource('limit'));
     });
     const previewCmd = sessionsCmd
@@ -4943,6 +5193,7 @@ export function registerSessionsCommands(program) {
     registerSessionsStatsCommand(sessionsCmd);
     registerSessionsInsightsCommand(sessionsCmd);
     registerSessionsOptimizeCommand(sessionsCmd);
+    registerSessionsWatchCommand(sessionsCmd);
     // Observe-umbrella alias (Phase 3): roster → sessions --active.
     registerSessionsObserveAliases(program);
 }

package/dist/commands/set.d.ts

@@ -3,7 +3,7 @@
  *
  * `agents set claude@2.1.220 --model opus-5` pins the default model (and/or
  * mode) that `agents run` uses for that agent version. It reads and writes the
- * same store as `agents defaults run set` (agents.yaml -> run.defaults), so the
+ * same store as `agents config set run.<agent@version>.*` (agents.yaml -> run.defaults), so the
  * two stay consistent — `set` is just the short front door.
  *
  *   agents set                          # list every configured default

package/dist/commands/set.js

@@ -3,7 +3,7 @@
  *
  * `agents set claude@2.1.220 --model opus-5` pins the default model (and/or
  * mode) that `agents run` uses for that agent version. It reads and writes the
- * same store as `agents defaults run set` (agents.yaml -> run.defaults), so the
+ * same store as `agents config set run.<agent@version>.*` (agents.yaml -> run.defaults), so the
  * two stay consistent — `set` is just the short front door.
  *
  *   agents set                          # list every configured default
@@ -72,7 +72,7 @@ export function registerSetCommand(program) {
         notes: `
       Selectors use <agent>@<version> or <agent>:<version>; * matches all versions.
       Exact selectors override wildcard selectors field by field.
-      Writes the same store as 'agents defaults run set'. Explicit flags on
+      Writes the same store as 'agents config set run.<agent@version>.*'. Explicit flags on
       'agents run' always win over configured defaults.
     `,
     });

package/dist/commands/setup-browser.js

@@ -8,7 +8,7 @@
  * the pinned browser or re-point the device default.
  */
 import chalk from 'chalk';
-import { updateMeta } from '../lib/state.js';
+import { setConfigValue } from '../lib/device-config.js';
 import { findFirstInstalledBrowser, listInstalledBrowsers } from '../lib/browser/chrome.js';
 import { DEFAULT_BROWSER_PROFILE_NAME, createProfile, findFreeProfilePort, getConfiguredDefaultProfileName, getProfile, } from '../lib/browser/profiles.js';
 import { DEFAULT_VIEWPORT } from '../lib/browser/devices.js';
@@ -113,7 +113,7 @@ async function maybeSetDeviceDefault(name, confirm) {
         default: true,
     });
     if (set) {
-        updateMeta((m) => ({ ...m, defaultBrowserProfile: name }));
+        setConfigValue('browser.profile', name);
         console.log(chalk.dim(`Bare \`agents browser start\` will now use "${name}" on this machine.`));
     }
 }

package/dist/commands/setup-mine.js

@@ -25,7 +25,6 @@ const DISABLEABLE_FEATURES = [
     { name: 'secrets', hint: 'keychain-backed env bundles' },
     { name: 'routines', hint: 'run agents on a cron schedule' },
     { name: 'monitors', hint: 'event-triggered watchers' },
-    { name: 'wallet', hint: 'payment cards' },
 ];
 /**
  * Interactive white-label setup. Returns true when a brand exists afterward,

package/dist/commands/setup-preferences.js

@@ -67,7 +67,7 @@ export async function maybePickInteractiveHost() {
         default: defaultInteractiveHostChoice(macs, self) ?? SKIP,
         choices: [
             ...macs.map((n) => ({ name: n === self ? `${n}  ${chalk.dim('(this machine)')}` : n, value: n })),
-            { name: `Skip ${chalk.dim('— decide later: agents devices set-interactive <name>')}`, value: SKIP },
+            { name: `Skip ${chalk.dim('— decide later: agents devices config <name> interactive.host <name>')}`, value: SKIP },
         ],
     });
     if (picked === SKIP)