@phnx-labs/agents-cli 1.22.29 → 1.22.30

package/dist/commands/sessions-picker.js

@@ -17,8 +17,10 @@ import { linearIssueUrl } from '../lib/session/linear.js';
 import { extractTodoProgress, WORKTREE_RE } from '../lib/session/state.js';
 import { renderMarkdown } from '../lib/markdown.js';
 import { itemPicker } from '../lib/picker.js';
+import { createMemoryCache } from '../lib/memory-cache.js';
 import { classifyFileChanges, changeCounts, toolHistogram, detectTestResult } from '../lib/session/digest.js';
 import { extractArtifacts, extractHooks, extractLinks, extractRepos, extractSkills } from '../lib/session/highlights.js';
+import { getSessionPlugins, readSessionPreviewCache, writeSessionPreviewCache } from '../lib/session/db.js';
 /** A session whose transcript FILE is 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
@@ -100,11 +102,71 @@ function sanitizeMeta(s) {
         todos,
     };
 }
-const previewCache = new Map();
+const previewCache = createMemoryCache({
+    max: 256,
+    ttlMs: 5 * 60_000,
+});
+function previewCacheKey(session, remote) {
+    let fileStamp = '';
+    if (!remote && session.filePath) {
+        try {
+            const stat = fs.statSync(session.filePath);
+            fileStamp = `${stat.mtimeMs}:${stat.size}`;
+        }
+        catch {
+            fileStamp = 'missing';
+        }
+    }
+    // The transcript stamp invalidates derived activity. Metadata that can change
+    // independently (label/ticket/PR/live scanner enrichment) also rides the key.
+    return JSON.stringify([
+        remote ?? '', session.id, fileStamp, session.lastActivity, session.label,
+        session.topic, session.ticketId, session.prUrl, session.messageCount,
+        session.tokenCount, session.model, session.todos, session.plan,
+        session.recentDirectoriesTouched, session.skillsUsed,
+    ]);
+}
+export function clearPreviewMemoryCacheForTest() {
+    previewCache.clear();
+}
+export function loadSessionPreviewDigest(session) {
+    if (!session.filePath || !fs.existsSync(session.filePath))
+        return { events: [] };
+    const safe = sanitizeMeta(session);
+    let events = [];
+    let sourceStamp;
+    try {
+        sourceStamp = fs.statSync(session.filePath);
+    }
+    catch (err) {
+        return { events, error: sanitizeForTerminal(err?.message ?? String(err)) };
+    }
+    let digest = readSessionPreviewCache(session.id, {
+        fileMtimeMs: sourceStamp.mtimeMs,
+        fileSize: sourceStamp.size,
+    });
+    if (!digest) {
+        try {
+            events = parseSession(session.filePath, session.agent);
+            digest = buildSessionPreviewDigest(events, safe);
+            writeSessionPreviewCache({
+                id: session.id,
+                fileMtimeMs: sourceStamp.mtimeMs,
+                fileSize: sourceStamp.size,
+                preview: digest,
+            });
+        }
+        catch (err) {
+            return { events, error: sanitizeForTerminal(err?.message ?? String(err)) };
+        }
+    }
+    digest.plugins = getSessionPlugins(session.id);
+    return { digest, events };
+}
 /** Build a cached multi-line preview string for display in the session picker. */
 export function buildPreview(session) {
     const remote = transcriptOnPeerOf(session);
-    const cacheKey = remote ? `${remote}:${session.id}` : session.id;
+    const cacheKey = previewCacheKey(session, remote);
     const cached = previewCache.get(cacheKey);
     if (cached)
         return cached;
@@ -129,18 +191,11 @@ export function buildPreview(session) {
         previewCache.set(cacheKey, output);
         return output;
     }
-    let events = [];
-    let parseError;
-    try {
-        events = parseSession(session.filePath, session.agent);
-    }
-    catch (err) {
-        parseError = sanitizeForTerminal(err?.message ?? String(err));
-    }
+    const { digest, events, error: parseError } = loadSessionPreviewDigest(session);
     const header = formatHeader(safe, events);
     const body = parseError
         ? '  ' + chalk.red(`Failed to parse session: ${parseError}`)
-        : formatCompactPreview(events, safe);
+        : formatCompactPreview(digest, safe);
     const output = [header, '', body].filter(Boolean).join('\n');
     previewCache.set(cacheKey, output);
     return output;
@@ -368,7 +423,8 @@ const LAST_RESPONSE_MAX_LINES = 15;
 const LAST_RESPONSE_MAX_LINES_WITH_TODOS = 8;
 const TODOS_MAX_ITEMS = 5;
 const DIRS_TOUCHED_MAX = 5;
-function formatCompactPreview(events, session) {
+/** Fold a harness-normalized event stream into the stable preview data model. */
+export function buildSessionPreviewDigest(events, session) {
     let firstUser = '';
     let lastAssistant = '';
     const filesRead = new Set();
@@ -436,9 +492,35 @@ function formatCompactPreview(events, session) {
     // checklist write); fall back to SessionMeta.todos for rows where the scan/
     // fan-out attached progress but the event stream has no TodoWrite yet.
     const todos = latestTodos ?? session.todos;
-    // Digest signals folded into the preview: change lifecycle, tool mix, tests.
     const changes = classifyFileChanges(events);
     const chg = changeCounts(changes);
+    const errorEvents = events.filter(e => e.type === 'error');
+    return {
+        schemaVersion: 1,
+        firstUser,
+        lastAssistant,
+        filesRead: filesRead.size,
+        toolCalls,
+        planFile,
+        todos,
+        subAgentCount,
+        toolTags: [...toolTags],
+        changes: chg,
+        dirs: directoriesTouched(session, events, changes),
+        repos: extractRepos(events, session.cwd),
+        artifacts: extractArtifacts(changes),
+        skills: extractSkills(events),
+        plugins: getSessionPlugins(session.id),
+        hooks: extractHooks(events),
+        links: extractLinks(events),
+        errorCount: errorEvents.length,
+        firstError: errorEvents[0]?.tool,
+        toolHistogram: toolHistogram(toolCounts, 4),
+        test: detectTestResult(events),
+    };
+}
+function formatCompactPreview(digest, session) {
+    const { firstUser, lastAssistant, filesRead, toolCalls, planFile, todos, subAgentCount, toolTags, changes: chg, dirs, repos, artifacts, skills, plugins, hooks, links, errorCount, firstError, toolHistogram: hist, test, } = digest;
     const lines = [];
     const termWidth = process.stdout.columns || 80;
     // Originating user prompt (first non-system user turn).
@@ -464,12 +546,10 @@ function formatCompactPreview(events, session) {
     // Recent activity = directories touched (not raw tool calls). Prefer a
     // parser-supplied dirsTouched when present; else derive from event paths.
     // Width-capped: a long Dirs line used to wrap and swamp the whole pane.
-    const dirs = directoriesTouched(session, events, changes);
     if (dirs.length) {
         lines.push(chalk.cyan('Dirs:    ') + joinWidthCapped(dirs, termWidth - 12));
     }
     // Repos worked in (basename of each `.git` root under the touched paths).
-    const repos = extractRepos(events, session.cwd);
     if (repos.length) {
         lines.push(chalk.cyan('Repos:   ') + chalk.white(repos.slice(0, 4).join(chalk.gray(' · '))));
     }
@@ -487,8 +567,8 @@ function formatCompactPreview(events, session) {
         ].filter(Boolean).join(' ');
         activity.push(`${parts} ${chalk.gray('changed')}`);
     }
-    if (filesRead.size)
-        activity.push(chalk.gray(`${filesRead.size} read`));
+    if (filesRead)
+        activity.push(chalk.gray(`${filesRead} read`));
     if (toolCalls)
         activity.push(chalk.gray(`${toolCalls} tool${toolCalls === 1 ? '' : 's'}`));
     if (activity.length) {
@@ -496,38 +576,35 @@ function formatCompactPreview(events, session) {
     }
     // Documents the session produced (`.agents/artifacts|plans|reports`, other
     // *.md/*.html creations) — the files a human browses later, named + clickable.
-    const artifacts = extractArtifacts(changes);
     if (artifacts.length) {
         const shown = artifacts.slice(0, 5).map(a => linkPath(a.path, a.basename));
         const more = artifacts.length > 5 ? chalk.gray(` · +${artifacts.length - 5} more`) : '';
         lines.push(chalk.cyan('Artifacts: ') + shown.join(chalk.gray(' · ')) + more);
     }
     // Skills invoked (plugin skills included — they ride the same Skill tool).
-    const skills = extractSkills(events);
     if (skills.length) {
         const shown = skills.slice(0, 5).map(s => chalk.white(s.name) + (s.count > 1 ? chalk.gray(` ×${s.count}`) : ''));
         const more = skills.length > 5 ? chalk.gray(` · +${skills.length - 5} more`) : '';
         lines.push(chalk.cyan('Skills:  ') + shown.join(chalk.gray(' · ')) + more);
     }
+    if (plugins.length) {
+        lines.push(chalk.cyan('Plugins: ') + chalk.white(plugins.slice(0, 5).join(chalk.gray(' · '))));
+    }
     // Hooks fired (Claude transcripts record firings; other harnesses don't).
-    const hooks = extractHooks(events);
     if (hooks.length) {
         const shown = hooks.slice(0, 4).map(h => chalk.white(h.name) + (h.count > 1 ? chalk.gray(` ×${h.count}`) : '') + (h.failed ? chalk.red(` (${h.failed} failed)`) : ''));
         const more = hooks.length > 4 ? chalk.gray(` · +${hooks.length - 4} more`) : '';
         lines.push(chalk.cyan('Hooks:   ') + shown.join(chalk.gray(' · ')) + more);
     }
     // Links mentioned in the conversation — clickable (OSC 8), tracker-classified.
-    const links = extractLinks(events);
     if (links.length) {
         const shown = links.slice(0, 5).map(l => chalk.blue(linkUrl(l.url, l.label)));
         const more = links.length > 5 ? chalk.gray(` · +${links.length - 5} more`) : '';
         lines.push(chalk.cyan('Links:   ') + shown.join(chalk.gray(' · ')) + more);
     }
     // Error tally, mirroring the full summary's Errors section in one line.
-    const errorEvents = events.filter(e => e.type === 'error');
-    if (errorEvents.length) {
-        const first = errorEvents[0].tool || 'unknown';
-        lines.push(chalk.cyan('Errors:  ') + chalk.red(`${errorEvents.length} failure${errorEvents.length === 1 ? '' : 's'}`) + chalk.gray(` — first: ${first}`));
+    if (errorCount) {
+        lines.push(chalk.cyan('Errors:  ') + chalk.red(`${errorCount} failure${errorCount === 1 ? '' : 's'}`) + chalk.gray(` — first: ${firstError || 'unknown'}`));
     }
     const metadata = [
         ...toolTags,
@@ -537,12 +614,10 @@ function formatCompactPreview(events, session) {
         lines.push(chalk.cyan('Meta:     ') + chalk.gray(metadata.join(' · ')));
     }
     // Tool mix (top 4) — what kind of work this was.
-    const hist = toolHistogram(toolCounts, 4);
     if (hist.length) {
         lines.push(chalk.cyan('Tools:    ') + chalk.gray(hist.map(h => `${h.tool} ${h.count}`).join(' · ')));
     }
     // Last test/build verdict.
-    const test = detectTestResult(events);
     if (test?.ok) {
         const bits = [
             test.passed !== undefined ? chalk.green(`${test.passed} pass`) : '',

package/dist/commands/sessions.d.ts

@@ -7,6 +7,9 @@ import { type PickedSession } from './sessions-picker.js';
 import { type ToolSearchEnvelope, type ToolProgramCountEnvelope } from '../lib/session/tool-index.js';
 interface SessionFilterOptions {
     agent?: string;
+    version?: string;
+    /** Internal Commander spelling after index.ts disambiguates root --version. */
+    sessionVersion?: string;
     project?: string;
     all?: boolean;
     teams?: boolean;
@@ -56,7 +59,7 @@ interface SessionsOptions extends SessionFilterOptions {
     abandoned?: boolean;
     queued?: boolean;
     unknown?: boolean;
-    /** Show only favorited (starred) sessions — the `f` key's flag twin. */
+    /** Show only favorited sessions — the `f` key's flag twin. */
     favorites?: boolean;
     /** Enrich the listing with live glyphs/preview for running rows. Default on;
      * `--no-live` sets this false. Commander's `--no-` convention. */
@@ -94,6 +97,12 @@ interface SessionsOptions extends SessionFilterOptions {
     /** Only sessions that used a skill/command owned by this plugin (#12). */
     plugin?: string;
 }
+type InstalledVersionsForAgent = (agent: SessionAgentId) => string[];
+/**
+ * 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 declare function parseInstalledAgentVersionQuery(query: string | undefined, installedVersions?: InstalledVersionsForAgent): string | undefined;
 /**
  * Strip terminal/harness noise from a preview so the column stays a single line
  * of plain prose: OSC title escapes, CSI/SGR ANSI, and the harness wrapper tags
@@ -431,6 +440,8 @@ export declare function renderSessionPreview(query: string, scope: {
     agent?: string;
     project?: string;
     local?: boolean;
+    hosts?: string[];
+    json?: boolean;
 }): Promise<void>;
 /**
  * The one-line live status banner shown above a session preview: the glyph, the