@phnx-labs/agents-cli 1.22.35 → 1.22.38

package/dist/commands/focus.js

@@ -16,6 +16,9 @@ import fs from 'node:fs';
 import chalk from 'chalk';
 import { confirm } from '@inquirer/prompts';
 import { gatherLiveTargets, pickLiveTarget, pickLiveTargets, jumpTo, probeAttachRail, refuseFallback } from './go.js';
+import { sessionProcessIsLocal, sessionProcessHost, shortIdFromName } from '../lib/session/active.js';
+import { attachTmux, getDefaultSocketPath, hasSession, runTmux } from '../lib/tmux/index.js';
+import { isAgentTmuxAlias } from '../lib/session/types.js';
 import { buildSessionRecoveryCommand, filterSessionsByQuery, formatLiveStatusHeadline, formatPickerLabel, isRunningLiveSession, pickerColumnsFor, resumeSessionInPlace, resolveSessionMetadataValue, resolveSessionAgentName, requestedLiveStatuses, } from './sessions.js';
 import { resolveBackend, CONFIRM_THRESHOLD } from './sessions-resume.js';
 import { runOnPeer } from '../lib/session/remote-list.js';
@@ -69,7 +72,12 @@ function statusWord(status) {
 }
 export function registerFocusCommand(program) {
     const cmd = program
-        .command('focus')
+        // Hidden, but deliberately NOT warned. `sessions resume <id>` dispatches by
+        // spawning `agents sessions focus <id>` (buildSessionLifecycleArgs), so a
+        // deprecation notice here would print on every ordinary resume. focus is now
+        // the internal lifecycle dispatcher; `resume` is the surface. Do not add a
+        // console.warn here without first removing that delegation.
+        .command('focus', { hidden: true })
         .argument('[selector]', 'Session id/prefix, agent@version, or topic/path search')
         .option('--local', 'Only this machine (skip the cross-host sweep)')
         .option('--attach-only', 'Attach only — never open a new tab / resume a copy (the old `go` behavior)')
@@ -134,6 +142,7 @@ export function registerFocusCommand(program) {
       - space toggles a session, enter opens the selected set; a single check + enter opens just one.
       - With no selector/filter, the picker shows the live fleet. An id focuses directly; agent@version and text selectors always show the preview picker.
       - A living tmux pane is JOINED (a second client, no fork). Dead/missing panes recover on the origin device: exact healthy origin uses native resume; otherwise a healthy version of the same harness receives /continue <id>.
+      - An id/identity selector resolves across the whole reachable fleet on its own — you do NOT need --device to focus a session that lives on another box (same as resume/preview). --device only narrows the browsable picker and the agent/version resolution.
       - --host/--device and the sessions-browser filters compose. latest/oldest resolve against each selected device's installed versions.
       Lifecycle siblings (not synonyms):
         focus              attach if alive, otherwise recover (default "take me there")
@@ -159,7 +168,7 @@ export async function focusAction(id, opts) {
     const local = !!opts.local && hosts.length === 0;
     const fallback = selectFallback(opts.attachOnly);
     const agentSelector = focusAgentSelector(id, opts);
-    const textSelector = id && !agentSelector ? id : undefined;
+    let textSelector = id && !agentSelector ? id : undefined;
     const filtered = !!id || hasFocusFilters(opts, statuses);
     // Preserve the fast live multi-picker for an unqualified `focus`. Every
     // selector/filter path below uses the sessions browser's shared candidate
@@ -200,14 +209,41 @@ export async function focusAction(id, opts) {
         if (unreachable.length > 0) {
             console.error(chalk.yellow(`Unavailable devices: ${unreachable.join(', ')}`));
         }
-        let exact = textSelector && looksLikeIdSelector(textSelector)
-            ? sessions.filter((session) => session.id.toLowerCase().startsWith(textSelector.toLowerCase()))
+        const idSelector = textSelector && looksLikeIdSelector(textSelector) ? textSelector.toLowerCase() : undefined;
+        let exact = idSelector
+            ? dedupeSessionsByLogicalId(sessions.filter((session) => session.id.toLowerCase().startsWith(idSelector)), self)
             : [];
+        // A tmux alias naming a LIVE local session attaches directly. This must run
+        // before the metadata resolver: that resolver treats an unmatched alias as a
+        // keyword query, so `ag-kimi-632c1fbc` came back as 13 unrelated text hits
+        // while the pane was alive and attachable the whole time.
+        if (exact.length === 0 && textSelector && !hosts.length && await attachLiveTmuxAlias(textSelector))
+            return;
+        // Not live (or remote-scoped): an alias still carries the session's shortid,
+        // so resolve by THAT rather than handing the whole `ag-<agent>-<shortid>`
+        // string to the resolver — which treats an unmatched alias as a keyword
+        // query and answered `"ag-claude-dead5678" matches 200 sessions` for a pane
+        // whose process had simply exited. SES-41 requires an alias to resolve to one
+        // canonical session id.
+        if (textSelector && isAgentTmuxAlias(textSelector)) {
+            const short = shortIdFromName(textSelector);
+            if (short) {
+                textSelector = short;
+                exact = dedupeSessionsByLogicalId(sessions.filter((session) => session.id.toLowerCase().startsWith(short)), self);
+            }
+        }
         if (exact.length === 0 && textSelector && looksLikeIdentitySelector(textSelector)) {
             const outcome = await resolveSessionMetadataValue(textSelector, { local, hosts });
             if (outcome.kind === 'partial') {
-                console.error(chalk.red(`Could not resolve session while these devices were unavailable: ${outcome.failedPeers.join(', ')}`));
-                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 "${textSelector}" 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 === 'ambiguous') {
@@ -220,13 +256,17 @@ export async function focusAction(id, opts) {
                 process.exitCode = 1;
                 return;
             }
+            // The fleet resolver is authoritative for an id/identity selector — the same
+            // one `resume`/`preview` use, and it already fanned out across the reachable
+            // fleet. Focus the session it found even when that session falls outside the
+            // candidate-pool DISPLAY filters (project scope, time window, device): those
+            // filters scope the browsable list, not an exact id lookup. Requiring the
+            // resolved row to ALSO be in the filtered pool is what made focusing a
+            // peer-owned (or older / other-project) session need `--device`. Prefer the
+            // pool's row when it carries the already-gathered live status, else fall back
+            // to the resolved metadata (focusResolvedSession hops to the owner from it).
             const filteredMatch = sessions.find((session) => session.id === outcome.session.id);
-            if (!filteredMatch) {
-                console.error(chalk.red(`Session ${outcome.session.shortId} does not match the selected focus filters.`));
-                process.exitCode = 1;
-                return;
-            }
-            exact = [filteredMatch];
+            exact = [focusTargetForResolved(filteredMatch, outcome.session)];
         }
         if (exact.length === 1) {
             await focusResolvedSession(exact[0], liveById, self, fallback, opts.attachOnly === true);
@@ -299,7 +339,107 @@ function looksLikeIdSelector(selector) {
 }
 function looksLikeIdentitySelector(selector) {
     return !!selector && (/^[0-9a-f][0-9a-f-]{5,}$/i.test(selector) ||
-        /^ag-[a-z][a-z0-9-]*-[0-9a-f]{8}$/i.test(selector));
+        isAgentTmuxAlias(selector));
+}
+/**
+ * Attach a live tmux session named exactly as the selector, without needing the
+ * session index to know anything about it.
+ *
+ * SES-41 requires a `ag-<agent>-<8hex>` tmux alias to resolve, but the alias's
+ * hex is the LAUNCH id, not the harness session id, and for a harness that
+ * writes no `state/sessions/<pid>.json` record there is no mapping back to a
+ * SessionMeta at all. Measured on yosemite-s0: `--resolve ag-kimi-632c1fbc`
+ * fell through to a keyword search and returned 13 unrelated rows, while the
+ * pane itself was alive (`%124`, `kimi-code`). The pane is the thing the user
+ * asked for, and its NAME is sufficient to attach it — so an unattributable
+ * session is still reachable instead of being a dead end that forces raw
+ * `tmux -S … attach`.
+ *
+ * Returns false when this is not an alias, the server/session is absent, or
+ * every pane is dead — the caller then continues to normal id resolution.
+ * SES-39's "re-read `pane_dead` immediately before attach" is honoured here:
+ * liveness is queried at attach time, not read from the roster.
+ */
+/**
+ * Rank two rows that are the same logical session, best first.
+ *
+ * Prefer the row that can actually be acted on: a real transcript over a
+ * phantom index entry (a purged copy indexes with an empty `filePath`), then
+ * this machine's copy over a peer mirror — resuming is machine-bound, so the
+ * local row is the one whose harness state exists here.
+ */
+function sessionRowRank(s, self) {
+    return (s.filePath ? 4 : 0) + (self && s.machine === self ? 2 : 0) + (s._remote ? 0 : 1);
+}
+/**
+ * Collapse rows that are the SAME logical session.
+ *
+ * A transcript syncs across the fleet, so one session appears once per machine
+ * holding a copy. SES-IF-2a: "Synced copies sharing the same full id MUST count
+ * as one logical session." `fleetCandidatesByQuery` already groups this way, but
+ * this path filtered raw rows instead — so `focus <full-uuid>` answered
+ * "is ambiguous (2 sessions). Use more of the id." with no longer id to give.
+ * Measured on zion: one of the two rows had no transcript at all
+ * ("Session transcript not available (file no longer exists). Path: ").
+ */
+export function dedupeSessionsByLogicalId(rows, self) {
+    const byId = new Map();
+    for (const row of rows) {
+        const key = row.id.toLowerCase();
+        const held = byId.get(key);
+        if (!held || sessionRowRank(row, self) > sessionRowRank(held, self))
+            byId.set(key, row);
+    }
+    return [...byId.values()];
+}
+/** Shape of the tmux alias the CLI mints for an agent session: `ag-<agent>-<shortid>`.
+ * Delegates to the one canonical matcher beside the name parsers in active.ts. */
+export function looksLikeTmuxAlias(selector) {
+    return isAgentTmuxAlias(selector);
+}
+/**
+ * Classify a selector against the live tmux server. Split from the attach so the
+ * decision is testable against a real tmux server without replacing the caller's
+ * shell (attaching is not something a test can undo).
+ */
+export async function resolveTmuxAliasState(selector, socket) {
+    if (!looksLikeTmuxAlias(selector))
+        return 'not-an-alias';
+    const sock = socket ?? getDefaultSocketPath();
+    if (!fs.existsSync(sock))
+        return 'no-server';
+    if (!(await hasSession(selector, sock).catch(() => false)))
+        return 'absent';
+    const panes = await runTmux({
+        socket: sock,
+        args: ['list-panes', '-t', `=${selector}`, '-F', '#{pane_dead}'],
+    }).catch(() => undefined);
+    const states = (panes?.stdout ?? '').split('\n').map(s => s.trim()).filter(Boolean);
+    return states.some(d => d === '0') ? 'live' : 'dead';
+}
+async function attachLiveTmuxAlias(selector) {
+    const socket = getDefaultSocketPath();
+    if (await resolveTmuxAliasState(selector, socket) !== 'live')
+        return false;
+    if (!process.stdout.isTTY) {
+        console.error(chalk.red(`"${selector}" is a live tmux session, but attaching needs a TTY.`));
+        console.error(chalk.gray(`  Run it from a terminal, or: agents tmux attach ${selector}`));
+        process.exitCode = 1;
+        return true;
+    }
+    // Already inside a tmux client on this socket — which is the normal state for
+    // an interactive agent session here — MOVE that client instead of nesting a
+    // second one. jumpTo (go.ts) does the same; attaching from inside tmux
+    // otherwise stacks clients rather than taking you to the session.
+    if (process.env.TMUX) {
+        await runTmux({ socket, args: ['switch-client', '-t', `=${selector}`], throwOnError: false }).catch(() => { });
+        console.log(chalk.gray(`Switched this tmux client to ${selector}.`));
+        return true;
+    }
+    console.log(chalk.gray(`Attaching ${selector} — Ctrl-b d to detach.`));
+    const code = await attachTmux({ socket, args: ['attach-session', '-t', `=${selector}`] });
+    process.exitCode = code;
+    return true;
 }
 function hasFocusFilters(opts, statuses) {
     return statuses.length > 0 || !!(opts.active || opts.local || opts.host?.length || opts.device?.length || focusOptionAgent(opts) ||
@@ -347,6 +487,18 @@ async function pickFocusCandidates(sessions, liveById, initialSearch) {
         throw err;
     }
 }
+/**
+ * The session to focus once an id/identity selector has resolved across the
+ * fleet. Prefer the already-gathered candidate-pool row (it carries the live
+ * status collected for the picker), but fall back to the resolver's own metadata
+ * when the resolved session is not in the filtered pool — a peer-owned, older, or
+ * other-project session that the display filters excluded. Returning the resolved
+ * session there (instead of rejecting it) is what lets `focus <id>` reach a
+ * peer-owned session without `--device`, matching `resume`/`preview`.
+ */
+export function focusTargetForResolved(poolMatch, resolved) {
+    return poolMatch ?? resolved;
+}
 async function focusResolvedSession(meta, liveById, self, fallback, attachOnly) {
     const active = liveById.get(meta.id);
     if (active && isAttachableLiveSession(active)) {
@@ -358,7 +510,7 @@ async function focusResolvedSession(meta, liveById, self, fallback, attachOnly)
         process.exitCode = 1;
         return;
     }
-    const remote = meta.machine && meta.machine !== self ? meta.machine : undefined;
+    const remote = sessionProcessHost(meta, self);
     if (remote) {
         console.log(chalk.gray(`Recovering ${meta.shortId} on ${remote}…`));
         const rc = await runOnPeer(sessionRecoveryRunArgs(meta), remote, { tty: true });
@@ -427,7 +579,7 @@ export function tmuxAttachScript(mux) {
  * and the tests stay decoupled from `discoverSessions`).
  */
 export function planFocusSurface(s, self, resumeCommandFor, rail = { state: 'alive' }) {
-    const remote = s.machine && s.machine !== self ? s.machine : undefined;
+    const remote = sessionProcessHost(s, self);
     const mux = s.provenance?.mux;
     const sid = shortId(s);
     // Join rail = tmux only (local or remote over SSH). A new tab attaching the live
@@ -483,7 +635,7 @@ export async function openFocusTabs(targets, self, deps = {}) {
     const resumeCommandFor = (s) => {
         if (deps.attachOnly)
             return null;
-        const remote = !!s.machine && s.machine !== self;
+        const remote = !sessionProcessIsLocal(s, self);
         return buildSessionRecoveryCommand(metaFor(s), remote);
     };
     const planned = await Promise.all(targets.map(async (s) => {
@@ -518,7 +670,15 @@ export async function openFocusTabs(targets, self, deps = {}) {
         return;
     }
     console.log(chalk.gray(`Opening ${openable.length} session${openable.length === 1 ? '' : 's'} in ${backend} (tabs)…`));
-    const results = await open(openable.map((p) => ({ cwd: cwdFor(p.s, byId), command: p.plan.command })), { backend, packing: 'tabs' });
+    // Pass agent + sessionId so the vscodium-agent backend can stamp the tab
+    // chip without sniffing the local process tree (remote attach has no agent
+    // binary on this box — #2478).
+    const results = await open(openable.map((p) => ({
+        cwd: cwdFor(p.s, byId),
+        command: p.plan.command,
+        agent: p.s.kind || undefined,
+        sessionId: p.s.sessionId || undefined,
+    })), { backend, packing: 'tabs' });
     let opened = 0;
     results.forEach((r, i) => {
         const p = openable[i];

package/dist/commands/funnel.d.ts

@@ -1,5 +1,5 @@
 /**
- * `agents funnel` — thin Tailscale Funnel wrapper for webhook ingress nodes.
+ * `agents daemon funnel` — thin Tailscale Funnel wrapper for webhook ingress nodes.
  */
 import type { Command } from 'commander';
 export declare function registerFunnelCommand(program: Command): void;

package/dist/commands/go.js

@@ -17,7 +17,7 @@ import chalk from 'chalk';
 import path from 'path';
 import { execFile } from 'child_process';
 import { promisify } from 'util';
-import { getActiveSessions, findSessionFileForKind } from '../lib/session/active.js';
+import { getActiveSessions, findSessionFileForKind, sessionProcessIsLocal, sessionProcessHost } from '../lib/session/active.js';
 import { gatherRemoteActive } from '../lib/session/remote-active.js';
 import { discoverSessions } from '../lib/session/discover.js';
 import { deriveShortId } from '../lib/session/short-id.js';
@@ -35,12 +35,13 @@ import { enumerateGhosttyTabs, assignGhosttyTabs } from '../lib/session/ghostty-
 const execFileAsync = promisify(execFile);
 export function registerGoCommand(program) {
     program
-        .command('go')
+        .command('go', { hidden: true })
         .argument('[id]', 'Short/full session id to jump to; omit for an interactive picker')
         .option('--local', 'Only this machine (skip the cross-host sweep)')
-        .description('Deprecated alias for `sessions focus --attach-only`')
+        .description('Deprecated — use `agents sessions resume --attach-only` instead.')
         .action(async (id, opts) => {
-        console.error(chalk.yellow('`sessions go` is deprecated — use `sessions focus --attach-only`'));
+        console.warn(chalk.yellow('`agents sessions go` is deprecated — use `agents sessions resume --attach-only` instead:'));
+        console.warn(chalk.gray(`  agents sessions resume ${id ?? '<id>'} --attach-only`));
         await focusAction(id, { local: opts.local, attachOnly: true });
     });
 }
@@ -163,7 +164,7 @@ export async function buildLivePool(activeById, self) {
     return mergeLocalFirst(pool, self);
 }
 function synthMeta(s, self) {
-    const remote = !!s.machine && s.machine !== self;
+    const remote = !sessionProcessIsLocal(s, self);
     // For a local session, locate the real transcript on disk so the picker's
     // buildPreview parses it directly (rich Prompt/Changes/Tools/Last response) —
     // independent of the sessions DB. Remote transcripts live on the peer, so leave
@@ -191,7 +192,7 @@ function shortId(s) {
  * `jumpTo` below: remote-tmux, then local-tmux, then ghostty, then refuse.
  */
 export function describeWhere(s, self) {
-    const remote = s.machine && s.machine !== self ? s.machine : undefined;
+    const remote = sessionProcessHost(s, self);
     const mux = s.provenance?.mux;
     if (mux?.kind === 'tmux' && mux.pane) {
         // When the renderer has resolved the current viewer, fold it into the label
@@ -216,7 +217,7 @@ export async function probeAttachRail(s, self) {
     const mux = s.provenance?.mux;
     if (mux?.kind !== 'tmux' || !mux.pane)
         return { state: 'missing' };
-    const remote = s.machine && s.machine !== self ? s.machine : undefined;
+    const remote = sessionProcessHost(s, self);
     if (!remote) {
         const pane = await paneExitStatus(mux.pane, mux.socket ?? getDefaultSocketPath());
         if (!pane.found)
@@ -253,7 +254,7 @@ export async function refuseFallback(s, remote) {
     process.exitCode = 1;
 }
 export async function jumpTo(s, self, fallback = refuseFallback) {
-    const remote = s.machine && s.machine !== self ? s.machine : undefined;
+    const remote = sessionProcessHost(s, self);
     const mux = s.provenance?.mux;
     // Path C: remote tmux — ssh in and attach, resolving the pane's session on the remote.
     if (remote) {

package/dist/commands/harness-wizard.d.ts

@@ -80,6 +80,7 @@ export interface HarnessDraft {
     model?: string;
     baseUrl?: string;
     authProvider?: string;
+    account?: string;
     /** `<bundle>` or `<bundle>:<key>` — a value copied out of an agents secrets bundle. */
     fromSecrets?: string;
     version?: string;

package/dist/commands/harness-wizard.js

@@ -31,6 +31,7 @@ import { baseUrlEnvKeyForHost, authEnvKeyForHost, modelEnvKeyForHost, validatePr
 import { listPresets, getPreset } from '../lib/profiles-presets.js';
 import { listBundles } from '../lib/secrets/bundles.js';
 import { AGENTS, ALL_AGENT_IDS, isSelfUpdatingAgent, resolveAgentName } from '../lib/agents.js';
+import { readAccountRegistry } from '../lib/account-registry.js';
 /**
  * Resolver-sourced editability, the scaffold default behind the RUSH-2222 seam.
  * Every field is read from the same maps the run-time resolver uses
@@ -248,10 +249,17 @@ export function createSteps() {
             },
         },
         {
-            id: 'auth',
-            decide: (d) => (d.authProvider && d.fromSecrets === undefined ? 'run' : 'skip'),
+            id: 'account',
+            decide: (d) => (d.authProvider && d.account === undefined ? 'run' : 'skip'),
             async run(io, d) {
-                await askKeySource(io, d, d.authProvider);
+                const accounts = Object.values(readAccountRegistry().accounts).filter(account => account.provider === d.authProvider);
+                if (accounts.length === 0) {
+                    throw new Error(`No '${d.authProvider}' account exists. Add one first with 'agents accounts add <name> --provider ${d.authProvider} --auth api-key'.`);
+                }
+                d.account = await io.select({
+                    message: 'Account',
+                    choices: accounts.map(account => ({ name: account.name, value: account.name })),
+                });
             },
         },
         connectionTestStep(),
@@ -302,29 +310,19 @@ export function editSteps(original) {
             },
         },
         {
-            id: 'auth',
+            id: 'account',
             decide: () => (cap.auth ? 'run' : { disabled: `host '${host}' manages its own login — no auth to edit` }),
             async run(io, d, hooks) {
                 if (!editableFor(hooks).auth)
                     return;
-                const bundles = listBundles();
-                const choices = [
-                    { name: 'Leave auth unchanged', value: KEEP },
-                    { name: 'Repoint to a provider (enter a key)', value: TYPE_NOW },
-                ];
-                if (bundles.length > 0)
-                    choices.push({ name: 'Copy a key from an agents secrets bundle', value: FROM_SECRETS });
-                const choice = await io.select({ message: 'Auth', choices });
+                const accounts = Object.values(readAccountRegistry().accounts);
+                const choice = await io.select({
+                    message: 'Account',
+                    choices: [{ name: 'Leave account unchanged', value: KEEP }, ...accounts.map(account => ({ name: `${account.name} (${account.provider})`, value: account.name }))],
+                });
                 if (choice === KEEP)
                     return;
-                const provider = await io.input({
-                    message: 'Provider',
-                    default: original.provider,
-                    validate: (v) => (v.trim() ? true : 'Provider is required'),
-                });
-                d.authProvider = provider;
-                if (choice === FROM_SECRETS)
-                    await askKeySource(io, d, provider);
+                d.account = choice;
             },
         },
         {

package/dist/commands/harness.d.ts

@@ -25,6 +25,7 @@ export interface ForkOptions {
     model?: string;
     baseUrl?: string;
     authProvider?: string;
+    account?: string;
     version?: string;
     description?: string;
     /** `<bundle>` or `<bundle>:<key>` — see {@link applyFromSecrets} in ./profiles.js. */
@@ -37,6 +38,7 @@ export interface EditOptions {
     model?: string;
     baseUrl?: string;
     authProvider?: string;
+    account?: string;
     /** Empty string ('') unpins the host CLI version. */
     version?: string;
     description?: string;