@phnx-labs/agents-cli 1.20.35 → 1.20.36

package/dist/commands/sessions-picker.js

@@ -12,6 +12,14 @@ import { linkPath, relativeToCwd } from '../lib/session/render.js';
 import { renderMarkdown } from '../lib/markdown.js';
 import { itemPicker } from '../lib/picker.js';
 import { classifyFileChanges, changeCounts, toolHistogram, detectTestResult } from '../lib/session/digest.js';
+/** A session whose transcript lives on another machine (folded in over the live
+ * cross-machine fan-out): its `filePath` is on that peer's disk, so the preview
+ * can't parse it locally — it shows metadata + a "resume there" note instead.
+ * Keys off `_remote`, not the machine tag, so locally-readable synced mirrors
+ * still parse their file normally. */
+function remoteMachineOf(session) {
+    return session._remote ? session.machine : undefined;
+}
 /**
  * SessionMeta originates in discover.ts (gitBranch, cwd, label, etc. read from
  * untrusted session files). parseSession sanitizes event payloads at its
@@ -37,9 +45,22 @@ function sanitizeMeta(s) {
 const previewCache = new Map();
 /** Build a cached multi-line preview string for display in the session picker. */
 export function buildPreview(session) {
-    const cached = previewCache.get(session.id);
+    const remote = remoteMachineOf(session);
+    const cacheKey = remote ? `${remote}:${session.id}` : session.id;
+    const cached = previewCache.get(cacheKey);
     if (cached)
         return cached;
+    const safe = sanitizeMeta(session);
+    // Remote session: the transcript is on the peer's disk, so there is nothing to
+    // parse here. Show the metadata header (agent, cwd, msgs, tokens — all carried
+    // over in the fan-out) plus where it lives and how to open it.
+    if (remote) {
+        const note = '  ' + chalk.gray(`on `) + chalk.bold.white(remote)
+            + chalk.gray(` — enter to resume there, or space then enter to read it over SSH`);
+        const output = [formatHeader(safe, []), '', note].join('\n');
+        previewCache.set(cacheKey, output);
+        return output;
+    }
     let events = [];
     let parseError;
     try {
@@ -48,13 +69,12 @@ export function buildPreview(session) {
     catch (err) {
         parseError = sanitizeForTerminal(err?.message ?? String(err));
     }
-    const safe = sanitizeMeta(session);
     const header = formatHeader(safe, events);
     const body = parseError
         ? '  ' + chalk.red(`Failed to parse session: ${parseError}`)
         : formatCompactPreview(events, safe);
     const output = [header, '', body].filter(Boolean).join('\n');
-    previewCache.set(session.id, output);
+    previewCache.set(cacheKey, output);
     return output;
 }
 function displayAgent(agent) {
@@ -342,6 +362,7 @@ function truncate(s, max) {
 export async function sessionPicker(config) {
     const picked = await itemPicker({
         message: config.message,
+        subtitle: config.subtitle,
         items: config.sessions,
         filter: config.filter,
         labelFor: config.labelFor,

package/dist/commands/sessions-resume.js

@@ -14,7 +14,7 @@ import { discoverSessions } from '../lib/session/discover.js';
 import { filterTeamSessions } from '../lib/session/team-filter.js';
 import { multiItemPicker, itemPicker } from '../lib/picker.js';
 import { buildPreview } from './sessions-picker.js';
-import { filterSessionsByQuery, formatPickerLabel, buildResumeCommand, resumeSessionInPlace, parseAgentFilter, } from './sessions.js';
+import { filterSessionsByQuery, formatPickerLabel, pickerColumnsFor, buildResumeCommand, resumeSessionInPlace, parseAgentFilter, } from './sessions.js';
 import { openSurfaces, availableBackends, detectCurrentBackend, currentContext, } from '../lib/terminal/index.js';
 import { isInteractiveTerminal, isPromptCancelled } from './utils.js';
 import { setHelpSections } from '../lib/help.js';
@@ -25,7 +25,7 @@ export function registerSessionsResumeCommand(sessionsCmd) {
     const cmd = sessionsCmd
         .command('resume')
         .argument('[query]', 'Filter sessions before selecting (topic, path, or id fragment)')
-        .description('Multi-select sessions and resume each in a terminal tab/split (this terminal, iTerm, Ghostty, tmux; local or --host).')
+        .description('Multi-select sessions and resume each in a terminal tab/split (this terminal, iTerm, Ghostty, tmux, VSCodium; local or --host).')
         .option('-a, --agent <agent>', 'Filter by agent type and version (e.g., claude, codex@0.116.0)')
         .option('--all', 'Include sessions from every directory (not just current project)')
         .option('--teams', 'Include team-spawned sessions (hidden by default)')
@@ -35,6 +35,7 @@ export function registerSessionsResumeCommand(sessionsCmd) {
         .option('--iterm', 'Force the iTerm backend')
         .option('--ghostty', 'Force the Ghostty backend')
         .option('--tmux', 'Force the tmux backend')
+        .option('--vscodium', 'Force the VSCodium agent-terminal backend (swarm-ext)')
         .option('--tabs', 'One tab per session (default: pack two panes per tab)');
     setHelpSections(cmd, {
         examples: `
@@ -46,13 +47,16 @@ export function registerSessionsResumeCommand(sessionsCmd) {
 
       # Force a backend / one tab each / a remote host
       agents sessions resume --ghostty
+      agents sessions resume --vscodium
       agents sessions resume --tabs
       agents sessions resume --host zion --tmux
     `,
         notes: `
       - space toggles a session, enter confirms; tab toggles the preview pane.
       - Layout: two-per-tab by default (session 1 → new tab, session 2 → split beside it, …). --tabs disables splitting.
-      - Backend: auto-detected from the terminal you're in (iTerm / Ghostty / tmux); override with --iterm/--ghostty/--tmux.
+      - VSCodium defaults to one editor tab per session (matches swarm-ext's native agent-terminal UX); the others default to two-per-tab.
+      - Backend: auto-detected from the terminal you're in (iTerm / Ghostty / tmux); override with --iterm/--ghostty/--tmux/--vscodium.
+      - --vscodium opens each session as an agent terminal tab in VSCodium via the swarm-ext extension (works with --host too).
       - --host <alias> resumes on a remote machine over the same SSH transport as 'sessions --host' (defaults to tmux).
       - Each session opens version-pinned, in its own cwd. Non-resumable agents are skipped with a note.
     `,
@@ -86,14 +90,16 @@ async function sessionsResumeAction(query, options) {
         console.log(chalk.gray('No sessions found. Try --all or a different --since window.'));
         return;
     }
-    // 1. Multi-select the sessions.
+    // 1. Multi-select the sessions. gutter: 6 = the multi-select cursor + checkbox
+    // ('> [x] ') that multiItemPicker prepends, so rows size to fit without wrapping.
+    const cols = { ...pickerColumnsFor(sessions), gutter: 6 };
     let chosen;
     try {
         chosen = await multiItemPicker({
             message: 'Select sessions to resume:',
             items: sessions,
             filter: (q) => (q.trim() ? filterSessionsByQuery(sessions, q) : sessions),
-            labelFor: (s, q) => formatPickerLabel(s, q),
+            labelFor: (s, q) => formatPickerLabel(s, q, cols),
             keyFor: (s) => s.id,
             buildPreview,
             pageSize: 15,
@@ -147,8 +153,10 @@ async function sessionsResumeAction(query, options) {
             await resumeSessionInPlace(it.session);
         return;
     }
-    // 5b. Fan out through the engine (two-per-tab by default).
-    const packing = options.tabs ? 'tabs' : 'two-per-tab';
+    // 5b. Fan out through the engine. Split-packing (two-per-tab) suits the
+    // terminal apps; the VSCodium backend defaults to one editor tab per session,
+    // matching swarm-ext's native agent-terminal UX. --tabs forces tabs anywhere.
+    const packing = options.tabs || backend === 'vscodium-agent' ? 'tabs' : 'two-per-tab';
     const where = options.host ? `${backend} on ${options.host}` : backend;
     console.log(chalk.gray(`Opening ${items.length} session${items.length === 1 ? '' : 's'} in ${where} (${packing})…`));
     const results = await openSurfaces(items.map((it) => ({ cwd: it.cwd, command: it.command })), { backend, host: options.host, packing });
@@ -172,7 +180,11 @@ async function sessionsResumeAction(query, options) {
  * user dismissed the chooser).
  */
 async function resolveBackend(options, ctx, count) {
-    const forced = options.iterm ? 'iterm' : options.ghostty ? 'ghostty' : options.tmux ? 'tmux' : undefined;
+    const forced = options.iterm ? 'iterm'
+        : options.ghostty ? 'ghostty'
+            : options.tmux ? 'tmux'
+                : options.vscodium ? 'vscodium-agent'
+                    : undefined;
     if (forced)
         return forced;
     // Remote defaults to tmux (headless, no GUI session assumptions); override with a backend flag.

package/dist/commands/sessions.d.ts

@@ -80,13 +80,83 @@ export declare function groupSessionsByMachine(sessions: ActiveSession[], localM
  * correlated, so they're all kept.
  */
 export declare function dedupeByMachineSession(sessions: ActiveSession[]): ActiveSession[];
+/**
+ * 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
+ * every machine keeping its incoming order (timestamp) within the block. Also
+ * dedupes: a session present both locally (a synced mirror copy) and via live
+ * fan-out collapses to one, keyed by machine + session id. Rows are keyed by
+ * `machine` (discover tags local rows with the local id; fan-out tags remote
+ * rows with the peer id) falling back to `localMachine` when untagged. Pure —
+ * `localMachine` is injected so the ordering is testable without os.hostname().
+ */
+export declare function mergeLocalFirst(sessions: SessionMeta[], localMachine: string): SessionMeta[];
+/**
+ * Group key for the overview: prefer the indexed project name; else fold the cwd
+ * to its repo — a worktree (`.../<repo>/.agents/worktrees/<slug>`) folds to the
+ * repo, and a monorepo subdir falls back to its leaf dir basename. Pure.
+ */
+export declare function overviewProjectKey(s: Pick<SessionMeta, 'project' | 'cwd'>): string;
+export interface OverviewGroup {
+    key: string;
+    total: number;
+    shown: SessionMeta[];
+    more: number;
+    maxTs: string;
+}
+/**
+ * Turn a recency-descending pool into project groups: each group shows its
+ * `perProjectCap` most-recent sessions (the rest become `· N more`), and groups
+ * are ordered by their most-recent session so the newest-active project leads.
+ * `perProjectCap = Infinity` expands every group. Pure — unit-tested.
+ */
+export declare function buildOverviewGroups(pool: SessionMeta[], perProjectCap: number): {
+    groups: OverviewGroup[];
+    projectCount: number;
+};
 /**
  * Render a session's full transcript to stdout — the non-follow view behind
  * `agents logs <sessionId>`. Reuses the same markdown renderer as
  * `agents sessions <id> --markdown`.
  */
 export declare function renderSessionLog(session: SessionMeta): Promise<void>;
-export declare function formatPickerLabel(s: SessionMeta, query: string): string;
+/** Column-visibility flags for the picker row, computed once over the whole pool. */
+export interface PickerColumns {
+    /** Render the machine column (only when the pool spans more than one machine). */
+    showMachine?: boolean;
+    /** Map a full machine id to its compact display form (shared prefix stripped). */
+    machineLabel?: (m: string) => string;
+    /** Total width of the machine column, sized to the widest compacted hostname
+     * in the pool (capped). Falls back to PICKER_MACHINE_W when absent. */
+    machineWidth?: number;
+    /** Render the ticket/PR column (only when at least one row carries a ref). */
+    showTicket?: boolean;
+    /**
+     * Cells the picker prepends before each row: 2 for the single-select cursor
+     * ('> '), 6 for the multi-select cursor + checkbox ('> [x] '). Reserved from
+     * the topic width so rows never wrap. Defaults to 2.
+     */
+    gutter?: number;
+}
+/**
+ * Compact display form for machine ids: strip the longest shared dash-delimited
+ * prefix so "yosemite-s0"/"yosemite-s1" read as "s0"/"s1" while unrelated ids
+ * ("zion", "mac-mini") stay whole. Stripping a *common* prefix can't collide,
+ * and at least one segment is always kept.
+ */
+export declare function machineLabeler(machines: string[]): (m: string) => string;
+/**
+ * Column flags for a picker, computed once over the whole pool so every row
+ * aligns: the machine column only earns its width when the listing spans more
+ * than one box, the ticket column only when some row carries a PR/ticket ref.
+ */
+export declare function pickerColumnsFor(sessions: SessionMeta[]): PickerColumns;
+export declare function formatPickerLabel(s: SessionMeta, query: string, cols?: PickerColumns): string;
+/**
+ * Pick a hint to show above the picker. Deterministic (keys off the pool size)
+ * so it stays fixed across the picker's re-renders within a single run.
+ */
+export declare function formatPickerTip(sessions: SessionMeta[]): string;
 export declare function pickSessionInteractive(sessions: SessionMeta[], message?: string, initialSearch?: string, hiddenCount?: number): Promise<PickedSession | null>;
 /**
  * Resume a session in the current terminal — a foreground takeover of this