@phnx-labs/agents-cli 1.22.29 → 1.22.30

package/dist/commands/sessions.js

@@ -46,11 +46,11 @@ import { getShimsDir } from '../lib/state.js';
 import { fuzzyMatch, FUZZY_PRESETS } from '../lib/fuzzy.js';
 import { itemPicker } from '../lib/picker.js';
 import { resolveSessionAlias } from '../lib/session/actor-sidecar.js';
-import { resolveVersionAliasLoose } from '../lib/versions.js';
+import { listInstalledVersions, resolveVersionAliasLoose } from '../lib/versions.js';
 import { getAgentsInvocation } from '../lib/daemon.js';
 import { sessionRecoveryRunArgs } from '../lib/session/recovery.js';
 import { isInteractiveTerminal, isPromptCancelled } from './utils.js';
-import { sessionPicker, buildPreview, formatTodoCompact, githubRepoUrlFromCwd, } from './sessions-picker.js';
+import { sessionPicker, buildPreview, loadSessionPreviewDigest, formatTodoCompact, githubRepoUrlFromCwd, } from './sessions-picker.js';
 import { setHelpSections } from '../lib/help.js';
 import { registerSessionsTailCommand } from './sessions-tail.js';
 import { registerSessionsResumeCommand } from './sessions-resume.js';
@@ -95,6 +95,44 @@ function applyAgentShorthands(options) {
     if (hit)
         options.agent = hit;
 }
+/**
+ * Treat a positional `agent@version` as a structured filter only when it names
+ * a real installed version. Everything else remains ordinary free-text search.
+ */
+export function parseInstalledAgentVersionQuery(query, installedVersions = (agent) => (agent in AGENTS ? listInstalledVersions(agent) : [])) {
+    const trimmed = query?.trim();
+    if (!trimmed)
+        return undefined;
+    const at = trimmed.indexOf('@');
+    if (at <= 0 || at !== trimmed.lastIndexOf('@') || at === trimmed.length - 1)
+        return undefined;
+    const agentName = trimmed.slice(0, at).toLowerCase();
+    if (!SESSION_AGENTS.includes(agentName))
+        return undefined;
+    const agent = agentName;
+    const version = trimmed.slice(at + 1);
+    return installedVersions(agent).includes(version) ? `${agent}@${version}` : undefined;
+}
+function applyVersionFilters(query, options) {
+    const explicitVersion = options.version ?? options.sessionVersion;
+    if (explicitVersion) {
+        if (!options.agent) {
+            throw new Error('--version requires --agent (for example: --agent claude --version 2.1.181).');
+        }
+        if (options.agent.includes('@')) {
+            throw new Error('Pass the version either in --agent <agent@version> or with --version, not both.');
+        }
+        options.agent = `${options.agent}@${explicitVersion}`;
+    }
+    if (!options.agent) {
+        const positionalFilter = parseInstalledAgentVersionQuery(query);
+        if (positionalFilter) {
+            options.agent = positionalFilter;
+            return undefined;
+        }
+    }
+    return query;
+}
 const CLAUDE_RESUME_MATCH_WINDOW_MS = 10 * 60_000;
 const LOAD_VERBS = ['Loading', 'Scanning', 'Gathering', 'Indexing', 'Reading'];
 const FIND_VERBS = ['Finding', 'Searching', 'Locating', 'Matching'];
@@ -1629,28 +1667,107 @@ function canonicalSessionsCommand(query, options) {
 /** Resolve a session by id/query globally and print its compact preview (no pager).
  * Backs `--preview` — the fast path for the "peek before resume" hot loop. */
 export async function renderSessionPreview(query, scope) {
-    const discovered = await discoverSessions({ all: true, cwd: process.cwd(), limit: 5000 });
-    const pool = applyScopeFilters(discovered, scope);
-    const { matches, completeId } = resolveSessionQuery(pool, query);
-    const session = matches[0];
-    if (!session) {
-        // A complete id that missed is not "no match for this text" — say which, and
-        // give the same fleet pointer the render paths give.
-        if (completeId)
-            notFoundByIdMessage(query).forEach(l => console.log(l));
-        else
-            console.log(chalk.gray(`No session matches "${query}".`));
+    let outcome = await resolveSessionMetadataValue(query, scope);
+    // A just-created transcript may not have reached the incremental index yet.
+    // Keep the indexed path hot, but repair a local cold miss once before saying
+    // it does not exist. This also preserves Claude history-alias discovery.
+    if (outcome.kind !== 'resolved'
+        && (!scope.hosts?.length || shouldIncludeLocal(scope.hosts, machineId()))) {
+        const discovered = applyScopeFilters(await discoverSessions({ all: true, cwd: process.cwd(), limit: 5000 }), scope);
+        const localMatches = resolveSessionQuery(discovered, query, { indexFallback: false }).matches
+            .map(session => ({ ...session, machine: session.machine || machineId() }));
+        const exact = localMatches.find(session => selectorAllowsEarlyExit(query)
+            && session.id.toLowerCase() === query.trim().toLowerCase());
+        if (exact)
+            outcome = { kind: 'resolved', session: exact };
+        else if (outcome.kind === 'not-found' && localMatches.length > 0) {
+            outcome = metadataResolveOutcome(localMatches, { sessions: [], unreachable: [] }, query);
+        }
+    }
+    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;
+        return;
+    }
+    if (outcome.kind === 'not-found') {
+        notFoundByIdMessage(query).forEach(l => console.error(l));
+        process.exitCode = 1;
+        return;
+    }
+    if (outcome.kind === 'ambiguous') {
+        console.error(chalk.red(`Multiple sessions match "${query}" across the fleet:`));
+        for (const candidate of outcome.candidates) {
+            const match = candidate.hits[0].session;
+            const machines = candidate.hits.map(hit => hit.machine).join(', ');
+            console.error(chalk.cyan(`  ${match.shortId}  ${match.id}`) + chalk.gray(`  ${machines}  ${match.agent}${match.version ? ` ${match.version}` : ''}`));
+        }
+        console.error(chalk.gray('Pass the full session ID to narrow it down.'));
+        process.exitCode = 1;
+        return;
+    }
+    const session = outcome.session;
+    if (session._remote && session.machine && session.machine !== machineId()) {
+        const args = ['sessions', 'preview', session.id, '--local'];
+        if (scope.json)
+            args.push('--json');
+        const rendered = await runOnPeer(args, session.machine);
+        if (rendered === 'no-target') {
+            console.error(chalk.red(`Session ${session.id} is on ${session.machine}, but that device is not reachable.`));
+            process.exitCode = 1;
+        }
         return;
     }
     // Lead with the live status when the session is still running, so the preview
     // says working / waiting / idle up front — not just the historical transcript.
-    // `--local --preview` is freely combinable with `--local` (RUSH-2118): thread
-    // it through so this probe never dials a remote-host teammate either.
+    // The shared snapshot is accepted for at most 15 seconds. The durable preview
+    // below contains no live status, so a long-lived process can never keep a
+    // stale working/waiting headline in its transcript cache.
     let live;
     try {
-        live = indexActiveBySessionId(await getActiveSessions({ localOnly: scope.local === true })).get(session.id);
+        const loaded = await loadLocalActiveSessions();
+        live = indexActiveBySessionId(loaded.sessions).get(session.id);
     }
     catch { /* plain preview on any probe failure */ }
+    if (scope.json) {
+        const { digest, error } = loadSessionPreviewDigest(session);
+        console.log(JSON.stringify({
+            schemaVersion: 1,
+            session: {
+                id: session.id,
+                shortId: session.shortId,
+                agent: session.agent,
+                version: session.version,
+                model: session.model,
+                account: session.account,
+                machine: session.machine ?? machineId(),
+                cwd: session.cwd,
+                project: session.project,
+                gitBranch: session.gitBranch,
+                createdAt: session.timestamp,
+                lastActivity: session.lastActivity,
+                durationMs: session.durationMs,
+                messageCount: session.messageCount,
+                tokenCount: session.tokenCount,
+                costUsd: session.costUsd,
+                label: session.label,
+                ticketId: session.ticketId,
+                prUrl: session.prUrl,
+            },
+            active: live ? {
+                status: live.status,
+                activity: live.activity,
+                awaitingReason: live.awaitingReason,
+                lastActivityMs: live.lastActivityMs,
+                startedAtMs: live.startedAtMs,
+                pid: live.pid,
+                host: live.host,
+            } : null,
+            preview: digest ?? null,
+            error: error ?? null,
+        }));
+        return;
+    }
     const headline = formatLiveStatusHeadline(live, isFavorite(session.id));
     if (headline)
         console.log(headline);
@@ -1879,6 +1996,14 @@ limitSource) {
     // shorthands fold into --agent, and --device is an alias for --host (both
     // resolve against the same device registry).
     applyAgentShorthands(options);
+    try {
+        query = applyVersionFilters(query, options);
+    }
+    catch (error) {
+        console.error(chalk.red(error instanceof Error ? error.message : String(error)));
+        process.exitCode = 1;
+        return;
+    }
     // --device / --devices both alias --host. A bare `all` / `fleet` sentinel means
     // "search every peer" — which is already the default — so it resolves to no
     // explicit host set rather than erroring on a device literally named "all".
@@ -1984,7 +2109,7 @@ limitSource) {
             console.error(chalk.red('--preview requires a session id or query.'));
             process.exit(1);
         }
-        await renderSessionPreview(query, { agent: options.agent, project: options.project, local: options.local });
+        await renderSessionPreview(query, { agent: options.agent, project: options.project, local: options.local, hosts: options.host });
         return;
     }
     if (liveOnly) {
@@ -2095,6 +2220,12 @@ limitSource) {
         await renderArtifactsGlobal(searchQuery, options.artifacts ?? false, options.artifact, artifactLookupScope(options.agent, options.project, options.routine));
         return;
     }
+    // A supplied ID is already the lookup key. Resolve it directly from SQLite
+    // and, when needed, the peer indexes before any broad transcript discovery.
+    if (!toolEvidenceMode && searchQuery && looksLikeSessionId(searchQuery)) {
+        await renderOneSession(searchQuery, mode, { agent: options.agent, project: options.project, routine: options.routine, filter: filterOpts, redact: options.redact, local: options.local, hosts: options.host });
+        return;
+    }
     // When the user explicitly asks to render (via mode flag), resolve the
     // query globally so sessions outside the default cwd/30d window are found.
     if (wantsRender && searchQuery) {
@@ -3694,6 +3825,11 @@ export function filterSessionsByQuery(sessions, query) {
     const trimmed = query?.trim().toLowerCase() || '';
     if (!trimmed)
         return sessions;
+    const installedAgentVersion = parseInstalledAgentVersionQuery(trimmed);
+    if (installedAgentVersion) {
+        const { agent, version } = parseAgentFilter(installedAgentVersion);
+        return sessions.filter((session) => session.agent === agent && session.version === version);
+    }
     const terms = trimmed.split(/\s+/).filter(Boolean);
     const contentIndex = searchContentIndex(sessions, trimmed);
     // If the query exactly matches a session label, short-circuit the structural
@@ -3863,6 +3999,53 @@ async function renderArtifactsGlobal(query, listAll, name, scope) {
     }
 }
 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);
+        }
+        // An index miss can be a transcript created since the last incremental
+        // scan, or a Claude history alias. Fall through to the established
+        // discovery/history resolver below only on that cold miss.
+        if (outcome.kind === 'ambiguous') {
+            console.error(chalk.red(`Multiple sessions match "${query}" across the fleet:`));
+            for (const candidate of outcome.candidates) {
+                const match = candidate.hits[0].session;
+                const machines = candidate.hits.map(hit => hit.machine).join(', ');
+                console.error(chalk.cyan(`  ${match.shortId}  ${match.id}`) + chalk.gray(`  ${machines}  ${match.agent}${match.version ? ` ${match.version}` : ''}`));
+            }
+            console.error(chalk.gray('Pass the full session ID to narrow it down.'));
+            process.exit(1);
+        }
+        if (outcome.kind === 'resolved') {
+            const resolved = outcome.session;
+            if (resolved._remote && resolved.machine && resolved.machine !== machineId()) {
+                const args = ['sessions', resolved.id, '--local'];
+                const flag = modeFlag(mode);
+                if (flag)
+                    args.push(flag);
+                if (scope.filter.include?.length)
+                    args.push('--include', scope.filter.include.join(','));
+                if (scope.filter.exclude?.length)
+                    args.push('--exclude', scope.filter.exclude.join(','));
+                if (scope.filter.first !== undefined)
+                    args.push('--first', String(scope.filter.first));
+                if (scope.filter.last !== undefined)
+                    args.push('--last', String(scope.filter.last));
+                if (scope.redact === false)
+                    args.push('--no-redact');
+                const rendered = await runOnPeer(args, resolved.machine);
+                if (rendered === 'no-target') {
+                    console.error(chalk.red(`Session ${resolved.id} is on ${resolved.machine}, but that device is not reachable.`));
+                    process.exit(1);
+                }
+                return;
+            }
+            await renderSession(resolved, mode, scope.filter, { redact: scope.redact });
+            return;
+        }
+    }
     const spinner = ora().start();
     const tracker = createScanProgressTracker(FIND_VERBS, 'session', spinner);
     try {
@@ -4070,6 +4253,16 @@ function resolveIndexedMetadataRows(indexed, selector) {
     }
     return resolveSessionQuery(indexed, selector, { indexFallback: false }).matches;
 }
+/**
+ * ID-shaped selectors go straight to SQLite's primary-key/short-id lookup.
+ * Keyword and label selectors still need the broader metadata pool.
+ */
+function indexedRowsForSelector(selector, scope) {
+    const indexed = looksLikeSessionId(selector)
+        ? findSessionsById(selector)
+        : querySessions();
+    return applyScopeFilters(indexed, scope);
+}
 /** Fixed peer argv for the metadata resolver. Scope flags compose identically on
  * every host; `--all` removes the SSH login cwd/time window, not agent/project filters. */
 export function metadataResolveForwardedArgs(selector, scope) {
@@ -4121,7 +4314,7 @@ export function metadataResolveOutcome(localMatches, remote, selector) {
 export async function resolveSessionMetadataValue(selector, scope = {}, deps = { gatherRemoteList }) {
     const localMachine = machineId();
     const includeLocal = !scope.hosts?.length || shouldIncludeLocal(scope.hosts, localMachine);
-    const indexed = includeLocal ? applyScopeFilters(querySessions(), scope) : [];
+    const indexed = includeLocal ? indexedRowsForSelector(selector, scope) : [];
     const localMatches = resolveIndexedMetadataRows(indexed, selector)
         .map(session => ({ ...session, machine: session.machine || localMachine }));
     // A full-UUID local hit resolves with ZERO SSH: a UUID is globally unique, so
@@ -4158,7 +4351,7 @@ export async function resolveSessionMetadataValue(selector, scope = {}, deps = {
 async function resolveSessionMetadata(selector, scope, deps = { gatherRemoteList }) {
     const localMachine = machineId();
     const includeLocal = !scope.hosts?.length || shouldIncludeLocal(scope.hosts, localMachine);
-    const indexed = includeLocal ? applyScopeFilters(querySessions(), scope) : [];
+    const indexed = includeLocal ? indexedRowsForSelector(selector, scope) : [];
     const localMatches = resolveIndexedMetadataRows(indexed, selector)
         .map(session => ({ ...session, machine: session.machine || localMachine }));
     // A peer is already inside gatherRemoteList. Return all local candidates so
@@ -4257,6 +4450,8 @@ export function registerSessionsCommands(program) {
         .addOption(new Option('--resolve-safe-v1 <selector>').hideHelp())
         .description('Find, browse, and read agent conversation transcripts. Live roster: `agents sessions --active` (alias: `agents roster`).')
         .option('-a, --agent <agent>', 'Filter by agent type and version (e.g., claude, codex@0.116.0)')
+        .addOption(new Option('--session-version <version>', 'Internal spelling for the public sessions --version filter')
+        .hideHelp())
         .option('--claude', 'Shorthand for --agent claude')
         .option('--codex', 'Shorthand for --agent codex')
         .option('--kimi', 'Shorthand for --agent kimi')
@@ -4297,7 +4492,7 @@ export function registerSessionsCommands(program) {
         .option('--abandoned', 'Show sessions with no transcript progress for the abandonment window (implies --active)')
         .option('--queued', 'Show queued sessions that have not started running (implies --active)')
         .option('--unknown', 'Show sessions whose live state cannot be determined (implies --active)')
-        .option('--favorites', 'Show only favorited (starred) sessions — star them with `*` in the browser or `agents sessions favorite <id>`')
+        .option('--favorites', 'Show only favorited sessions — favorite them with `*` in the browser or `agents sessions favorite <id>`')
         .option('--tree', 'Group the listing by directory; drops the id/version columns for readability')
         .option('--flat', 'Plain flat table (one row per session) instead of the grouped project overview')
         .option('--no-live', 'Do not enrich the listing with live status/preview for running sessions')
@@ -4350,6 +4545,10 @@ export function registerSessionsCommands(program) {
       # Search across every directory, not just this project
       agents sessions "topic" --all
 
+      # Filter one installed harness version (equivalent forms)
+      agents sessions claude@2.1.181
+      agents sessions --agent claude --version 2.1.181
+
       # Team-spawned sessions, grouped by team (spawner + spawn time per team,
       # teammate mode/handle per row; team-flagged spawns with no team record
       # in a trailing (no team) bucket)
@@ -4397,6 +4596,7 @@ export function registerSessionsCommands(program) {
         resume [query]          multi-select history → open tabs (or run --resume <id>)
       - 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>.
       - --host runs the query on the remote's own index over SSH (host alias or user@host); repeat or pass several to fan out. SSH access is the only auth.
       - --in-team matches both ends of the lineage: the session that ran 'agents teams create/add', and (with --teams) that team's teammates. In the interactive list, 't' cycles the same filter over the teams in view.
       - --include and --exclude are mutually exclusive.
@@ -4420,6 +4620,45 @@ export function registerSessionsCommands(program) {
         }
         await sessionsAction(query, options, command.getOptionValueSource('limit'));
     });
+    const previewCmd = sessionsCmd
+        .command('preview')
+        .argument('<id>', 'Full session ID or displayed 8-character short ID')
+        .description('Show one rich session card without rendering the full transcript')
+        .option('-a, --agent <agent>', 'Narrow the ID to one agent type/version')
+        .option('-p, --project <name>', 'Narrow the ID to one project')
+        .option('--local', 'Only this machine; do not resolve the ID across the fleet')
+        .option('-H, --host <target...>', 'Resolve only on the named device(s)')
+        .option('--device <target...>', 'Alias for --host')
+        .option('--json', 'Output the session preview as JSON');
+    setHelpSections(previewCmd, {
+        examples: `
+      # Preview by the 8-character ID shown in agents sessions
+      agents sessions preview 407b8dd5
+
+      # A full UUID resolves on the first device that owns it
+      agents sessions preview c70ecdea-6210-4039-9845-246a3a7a9942
+
+      # Stay on this machine or restrict the authoritative lookup to one peer
+      agents sessions preview 407b8dd5 --local
+      agents sessions preview 407b8dd5 --device zion
+    `,
+        notes: `
+      - Full UUIDs are globally unique and may stop the fleet lookup at the first exact hit.
+      - Short IDs wait for every selected device so ambiguity is never hidden.
+      - Active status is refreshed through the bounded live-state TTL; transcript-derived details use the durable session index.
+    `,
+    });
+    previewCmd.action(async (id) => {
+        const options = previewCmd.optsWithGlobals();
+        const hosts = [...(options.host ?? []), ...(options.device ?? [])];
+        await renderSessionPreview(id, {
+            agent: options.agent,
+            project: options.project,
+            local: options.local,
+            hosts: hosts.length > 0 ? hosts : undefined,
+            json: options.json,
+        });
+    });
     registerSessionsTailCommand(sessionsCmd);
     registerSessionsResumeCommand(sessionsCmd);
     registerSessionsForkCommand(sessionsCmd);

package/dist/commands/view.d.ts

@@ -15,6 +15,17 @@ import { type ProfileSummary } from '../lib/profiles.js';
 import { type ByokUsageResult } from '../lib/byok-usage.js';
 /** Shared account identity formatter, re-exported for the view-specific tests. */
 export declare const accountColumnLabel: typeof accountDisplayLabel;
+export interface AccountOrderedVersion {
+    version: string;
+    email: string | null;
+}
+/**
+ * Human `agents view` row order: selected default first, then email-bearing
+ * accounts alphabetically, then installs whose account has no email. Version
+ * descending is the deterministic tie-breaker and preserves the old order for
+ * every non-email harness.
+ */
+export declare function compareAccountOrderedVersions(a: AccountOrderedVersion, b: AccountOrderedVersion, globalDefault: string | null): number;
 /**
  * Join fixed view columns with a consistent two-space gutter. Empty trailing
  * columns are dropped so a row without an auth chip does not grow a dangling

package/dist/commands/view.js

@@ -33,6 +33,30 @@ import { formatPath, isInteractiveTerminal, isPromptCancelled } from './utils.js
 import { terminalWidth, truncateToWidth, stringWidth, padToWidth } from '../lib/session/width.js';
 /** Shared account identity formatter, re-exported for the view-specific tests. */
 export const accountColumnLabel = accountDisplayLabel;
+/**
+ * Human `agents view` row order: selected default first, then email-bearing
+ * accounts alphabetically, then installs whose account has no email. Version
+ * descending is the deterministic tie-breaker and preserves the old order for
+ * every non-email harness.
+ */
+export function compareAccountOrderedVersions(a, b, globalDefault) {
+    const aIsDefault = a.version === globalDefault;
+    const bIsDefault = b.version === globalDefault;
+    if (aIsDefault !== bIsDefault)
+        return aIsDefault ? -1 : 1;
+    const aEmail = a.email?.toLowerCase() ?? null;
+    const bEmail = b.email?.toLowerCase() ?? null;
+    if (aEmail !== null && bEmail === null)
+        return -1;
+    if (aEmail === null && bEmail !== null)
+        return 1;
+    if (aEmail !== null && bEmail !== null) {
+        const emailOrder = aEmail.localeCompare(bEmail);
+        if (emailOrder !== 0)
+            return emailOrder;
+    }
+    return compareVersions(b.version, a.version);
+}
 /**
  * Overview (`agents view` with no agent filter) caps compact usage windows so
  * multi-meter agents (Antigravity's four model quotas, Droid's three buckets)
@@ -56,15 +80,12 @@ export function joinViewColumns(cols) {
     return cols.slice(0, end).join('  ');
 }
 /**
- * Custom harnesses (the `~/.agents/profiles/*.yml` bundles), sorted by name and
- * optionally narrowed to the ones that run on one host agent. YAMLs that fail
- * validation are silently skipped by `listProfiles`, so this never throws on a
- * malformed file.
+ * Custom harnesses (the `~/.agents/profiles/*.yml` bundles), sorted by name.
+ * YAMLs that fail validation are silently skipped by `listProfiles`, so this
+ * never throws on a malformed file.
  */
-function getHarnesses(filterAgentId) {
-    return listProfiles()
-        .filter((profile) => !filterAgentId || profile.host.agent === filterAgentId)
-        .map(profileSummary);
+function getHarnesses() {
+    return listProfiles().map(profileSummary);
 }
 /** Version-first label: "<version> (forked from <host>[, tracks default])" */
 function harnessVersionLabel(harness, globalDefault) {
@@ -307,7 +328,9 @@ async function showInstalledVersions(filterAgentId, viewOpts) {
         .filter((agentId) => !hasNonIsolatedVersion(agentId))
         .map(async (agentId) => [agentId, await getUnmanagedCliState(agentId)])));
     const showPaths = !!filterAgentId;
-    const harnesses = getHarnesses(filterAgentId);
+    // A filtered native view is about that native harness's installed versions.
+    // Custom forks are standalone agent types and only belong in the overview.
+    const harnesses = filterAgentId ? [] : getHarnesses();
     // Auto-heal stale versioned aliases. Pre-v2 aliases (e.g. pre-CLAUDE_CONFIG_DIR
     // claude shims) silently route login through the default version's symlinked
     // home, so `agents view` would never reflect the right account. Regenerate on
@@ -524,14 +547,16 @@ async function showInstalledVersions(filterAgentId, viewOpts) {
                 ? chalk.yellow(' (no default)')
                 : '';
             console.log(`  ${chalk.bold(agentLabel(agentId))}${strategyLabel}${noDefaultLabel}`);
-            // Sort versions with default first, then by semver descending
-            const sortedVersions = [...versions].sort((a, b) => {
-                if (a === globalDefault)
-                    return -1;
-                if (b === globalDefault)
-                    return 1;
-                return compareVersions(b, a);
-            });
+            // Account information is already loaded above. Keep the selected default
+            // first, then make multi-account installs scannable by email. Harnesses
+            // without email identities retain their prior version-descending order.
+            const sortedVersions = versions
+                .map((version) => ({
+                version,
+                email: infoMap.get(`${agentId}:${version}`)?.email ?? null,
+            }))
+                .sort((a, b) => compareAccountOrderedVersions(a, b, globalDefault))
+                .map(({ version }) => version);
             for (const version of sortedVersions) {
                 const isDefault = version === globalDefault;
                 const isolated = !isDefault && isVersionIsolated(agentId, version);
@@ -1273,7 +1298,9 @@ export async function collectAgentsJson(filterAgentId, resourceSections) {
         else
             byAgent.set(agentId, [entry]);
     }
-    const harnesses = getHarnesses(filterAgentId);
+    // Keep filtered native JSON consistent with the text view: custom forks are
+    // not children of the native harness they execute through.
+    const harnesses = filterAgentId ? [] : getHarnesses();
     const out = [];
     for (const agentId of agentsToShow) {
         const versions = byAgent.get(agentId) ?? [];
@@ -1544,19 +1571,19 @@ export async function viewAction(agentArg, options) {
     // Parse agent@version syntax
     const parts = agentArg.split('@');
     const agentName = parts[0];
-    const agentId = resolveAgentName(agentName);
-    if (!agentId) {
-        // A custom harness is an agent type here, not an unknown name: `agents run
-        // <name>` launches it, so `agents view <name>` describes it.
-        if (profileExists(agentName)) {
-            const harness = profileSummary(readProfile(agentName));
-            if (json) {
-                console.log(JSON.stringify(harness, null, 2));
-                return;
-            }
-            renderHarnessDetail(agentName);
+    // Match run resolution: an exact custom harness name wins over a native id or
+    // alias with the same spelling, so every fork remains independently viewable.
+    if (profileExists(agentName)) {
+        const harness = profileSummary(readProfile(agentName));
+        if (json) {
+            console.log(JSON.stringify(harness, null, 2));
             return;
         }
+        renderHarnessDetail(agentName);
+        return;
+    }
+    const agentId = resolveAgentName(agentName);
+    if (!agentId) {
         if (json) {
             console.log(JSON.stringify({ error: formatAgentError(agentName) }));
             process.exit(1);

package/dist/index.js

@@ -94,7 +94,7 @@ if (IS_DEV_BUILD) {
 // module on each invocation (which loaded the whole ~50-module tree before the
 // first byte of output), the registry maps a command name to a thunk that
 // imports only what that command needs. See src/lib/startup/command-registry.ts.
-import { COMMAND_LOADERS, LAZY_COMMAND_NAMES, loadView, loadInspect, loadFeedback, loadCommands, loadHooks, loadSkills, loadRules, loadMemory, loadPermissions, loadMcp, loadCli, loadSubagents, loadPlugins, loadWorkflows, loadWorktree, loadVersions, loadImport, loadExport, loadPackages, loadRoutines, loadMonitors, loadProjects, loadRun, loadFork, loadDefaults, loadSet, loadModels, loadModes, loadPrune, loadTrash, loadRestore, loadDoctor, loadApply, loadStatus, loadSnapshot, loadProfiles, loadHarness, loadSecrets, loadLogin, loadWallet, loadHelper, loadMenubar, loadBeta, loadSync, loadLock, loadRefreshRules, loadFactory, loadUsage, loadCost, loadInsights, loadPerf, loadTrends, loadOutput, loadBudget, loadAlias, loadMine, loadPty, loadTmux, loadWatchdog, loadBrowser, loadComputer, loadHosts, loadLogs, loadEvents, loadAudit, loadWebhook, loadFunnel, loadHumans, loadSsh, loadPull, loadPush, loadRepo, loadSetup, loadUninstall, loadBench, loadShare, loadSend, loadFeed, loadMailboxes, } from './lib/startup/command-registry.js';
+import { COMMAND_LOADERS, LAZY_COMMAND_NAMES, loadView, loadInspect, loadFeedback, loadCommands, loadHooks, loadSkills, loadRules, loadMemory, loadPermissions, loadMcp, loadCli, loadSubagents, loadPlugins, loadWorkflows, loadWorktree, loadVersions, loadImport, loadExport, loadPackages, loadRoutines, loadDaemon, loadMonitors, loadProjects, loadRun, loadFork, loadDefaults, loadSet, loadModels, loadModes, loadPrune, loadTrash, loadRestore, loadDoctor, loadApply, loadStatus, loadSnapshot, loadProfiles, loadHarness, loadSecrets, loadLogin, loadWallet, loadHelper, loadMenubar, loadBeta, loadSync, loadLock, loadRefreshRules, loadFactory, loadUsage, loadCost, loadInsights, loadPerf, loadTrends, loadOutput, loadBudget, loadAlias, loadMine, loadPty, loadTmux, loadWatchdog, loadBrowser, loadComputer, loadHosts, loadLogs, loadEvents, loadAudit, loadWebhook, loadFunnel, loadHumans, loadAccounts, loadSsh, loadPull, loadPush, loadRepo, loadSetup, loadUninstall, loadBench, loadShare, loadSend, loadFeed, loadMailboxes, } from './lib/startup/command-registry.js';
 import { applyGlobalHelpConventions } from './lib/help.js';
 import { renderWhatsNew } from './lib/whats-new.js';
 import { getCliLaunch } from './lib/cli-entry.js';
@@ -120,6 +120,22 @@ if (process.argv[2] === '__daemon-run') {
     await runDaemon();
     process.exit(process.exitCode ?? 0);
 }
+// One-shot invocation of a migrated daemon housekeeping tick (RUSH-2353). The
+// shipped system routines (`watchdog`, `device-probe`, `fleet-cache-warm`, ...)
+// run this as their `command:` instead of the daemon holding a setInterval —
+// same tick body, now scheduled/tracked/pinnable through the routines system.
+if (process.argv[2] === '__daemon-tick') {
+    const name = process.argv[3] || '';
+    const { runDaemonTick } = await import('./lib/daemon-ticks.js');
+    try {
+        await runDaemonTick(name);
+        process.exit(0);
+    }
+    catch (err) {
+        process.stderr.write(`[agents] daemon tick '${name}' failed: ${err.message}\n`);
+        process.exit(1);
+    }
+}
 // White-label: the shim for a brand (e.g. `jack`) exports AGENTS_BRAND, so the
 // CLI presents its own name/help/errors as the brand. Unbranded (AGENTS_BRAND
 // unset) resolves to 'agents' and everything below is byte-identical to before.
@@ -303,6 +319,7 @@ Run and dispatch:
   defaults                        Configure run defaults by agent/version selector
   teams                           Coordinate multiple agents on shared work
   routines                        Run agents on a cron schedule (scheduler auto-starts)
+  daemon                          Runtime status/control for the always-on daemon (secrets broker, browser IPC, scheduler)
   webhook                         Receive signed GitHub/Linear webhooks for trigger routines
   funnel                          Expose a webhook receiver through Tailscale Funnel
   sessions                        Browse, search, and replay past runs (live-search in TTY; grouped by workspace)
@@ -929,6 +946,7 @@ async function registerAllEagerCommands() {
     await reg(loadExport);
     await reg(loadPackages);
     await reg(loadRoutines);
+    await reg(loadDaemon);
     await reg(loadMonitors);
     await reg(loadProjects);
     await reg(loadRun);
@@ -980,6 +998,7 @@ async function registerAllEagerCommands() {
     await reg(loadWebhook);
     await reg(loadFunnel);
     await reg(loadHumans);
+    await reg(loadAccounts);
     registerHqTombstoneCommand(program);
     await reg(loadFeed);
     await reg(loadMailboxes);
@@ -1060,6 +1079,22 @@ program.on('command:*', (operands) => {
 // and the doc flags (--version/--help/-h) drive both the registration strategy
 // and whether the update check + background sync run at all.
 const passedArgs = process.argv.slice(2);
+// Commander owns `--version` on the root command and otherwise intercepts it
+// even after `sessions`, before the subcommand can parse its version filter.
+// Rewrite only that value-taking nested form; bare `agents --version` and every
+// other command retain the root documentation flag unchanged.
+if (passedArgs[0] === 'sessions') {
+    const nestedVersionIndex = passedArgs.indexOf('--version', 1);
+    if (nestedVersionIndex >= 0) {
+        const nestedVersion = passedArgs[nestedVersionIndex + 1];
+        if (!nestedVersion || nestedVersion.startsWith('-')) {
+            console.error("error: option '--version <version>' argument missing");
+            process.exit(1);
+        }
+        passedArgs[nestedVersionIndex] = '--session-version';
+        process.argv[nestedVersionIndex + 2] = '--session-version';
+    }
+}
 const requestedCommand = passedArgs.find((arg) => !arg.startsWith('-'));
 const verboseStartup = passedArgs.includes('--verbose');
 // Help and version output are pure documentation — they must never gate on
@@ -1212,7 +1247,7 @@ if (process.env.AGENTS_SKIP_MIGRATION !== '1') {
         // Bumping the suffix re-runs migrations for every user; binary releases that
         // don't change the schema must NOT re-run (they would destroy user content
         // when migration steps overlap with user-authored paths). See issue #20.
-        const sentinelValue = 'v15';
+        const sentinelValue = 'v17';
         let needRun = true;
         try {
             if (fs.existsSync(sentinel) && fs.readFileSync(sentinel, 'utf-8').trim() === sentinelValue) {