@phnx-labs/agents-cli 1.20.74 → 1.20.77

package/dist/commands/sessions-picker.js

@@ -6,11 +6,14 @@
  * response) and delegates to the generic `itemPicker` for the interactive UI.
  */
 import fs from 'node:fs';
+import path from 'node:path';
 import chalk from 'chalk';
 import { truncate, humanDuration } from '../lib/format.js';
 import { parseSession, sanitizeForTerminal } from '../lib/session/parse.js';
 import { cleanSessionPrompt, extractSessionTopic } from '../lib/session/prompt.js';
-import { linkPath, relativeToCwd } from '../lib/session/render.js';
+import { linkPath, linkUrl, relativeToCwd } from '../lib/session/render.js';
+import { linearIssueUrl } from '../lib/session/linear.js';
+import { extractTodoProgress } from '../lib/session/state.js';
 import { renderMarkdown } from '../lib/markdown.js';
 import { itemPicker } from '../lib/picker.js';
 import { classifyFileChanges, changeCounts, toolHistogram, detectTestResult } from '../lib/session/digest.js';
@@ -22,6 +25,32 @@ import { classifyFileChanges, changeCounts, toolHistogram, detectTestResult } fr
 function remoteMachineOf(session) {
     return session._remote ? session.machine : undefined;
 }
+/**
+ * Compact checklist tally for list rows and previews (RUSH-2045).
+ * Example: `✓6/8 · A5 wiring runner`. Empty string when there is no list.
+ * Consumes `SessionMeta.todos` / `ActiveSession.todos` as populated by the
+ * state engine — does not re-parse transcripts.
+ */
+export function formatTodoCompact(todos) {
+    if (!todos || !Number.isFinite(todos.total) || todos.total < 1)
+        return '';
+    const done = Number.isFinite(todos.done) ? Math.max(0, todos.done) : 0;
+    const tally = `✓${done}/${todos.total}`;
+    const step = todos.activeForm?.replace(/\s+/g, ' ').trim();
+    return step ? `${tally} · ${step}` : tally;
+}
+/**
+ * Best-effort GitHub repo URL from a checkout path shaped like
+ * `…/github.com/<owner>/<repo>/…`. Used to make the project name clickable
+ * when no Linear project URL is available.
+ */
+export function githubRepoUrlFromCwd(cwd) {
+    if (!cwd)
+        return undefined;
+    const norm = cwd.replace(/\\/g, '/');
+    const m = norm.match(/\/github\.com\/([^/]+\/[^/]+)/);
+    return m ? `https://github.com/${m[1]}` : undefined;
+}
 /**
  * SessionMeta originates in discover.ts (gitBranch, cwd, label, etc. read from
  * untrusted session files). parseSession sanitizes event payloads at its
@@ -30,6 +59,17 @@ function remoteMachineOf(session) {
  */
 function sanitizeMeta(s) {
     const clean = (v) => (v == null ? v : sanitizeForTerminal(v));
+    const todos = s.todos
+        ? {
+            ...s.todos,
+            activeForm: clean(s.todos.activeForm),
+            items: s.todos.items.map((it) => ({
+                ...it,
+                content: sanitizeForTerminal(it.content),
+                activeForm: clean(it.activeForm),
+            })),
+        }
+        : s.todos;
     return {
         ...s,
         id: sanitizeForTerminal(s.id),
@@ -42,6 +82,9 @@ function sanitizeMeta(s) {
         account: clean(s.account),
         topic: clean(s.topic),
         label: clean(s.label),
+        ticketId: clean(s.ticketId),
+        prUrl: clean(s.prUrl),
+        todos,
     };
 }
 const previewCache = new Map();
@@ -59,7 +102,8 @@ export function buildPreview(session) {
     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');
+        const metaBody = formatMetaOnlyBody(safe);
+        const output = [formatHeader(safe, []), '', note, metaBody].filter(Boolean).join('\n');
         previewCache.set(cacheKey, output);
         return output;
     }
@@ -67,7 +111,8 @@ export function buildPreview(session) {
     // entry (e.g. `sessions go`). Show the header + a clean note, not a parse error.
     if (!session.filePath || !fs.existsSync(session.filePath)) {
         const note = '  ' + chalk.gray('Live session — full transcript not indexed here.');
-        const output = [formatHeader(safe, []), '', note].filter(Boolean).join('\n');
+        const metaBody = formatMetaOnlyBody(safe);
+        const output = [formatHeader(safe, []), '', note, metaBody].filter(Boolean).join('\n');
         previewCache.set(cacheKey, output);
         return output;
     }
@@ -96,19 +141,27 @@ function formatHeader(session, events) {
     const { startedAgo, duration } = extractTiming(events);
     const totalMessages = session.messageCount ?? countMessages(events);
     const totalTokens = session.tokenCount;
-    // Line 1: Agent v version · model · account
+    // Line 1: Agent v version · shortId · model · account
     const line1 = [];
     line1.push(chalk.gray(`${displayAgent(session.agent)}${session.version ? ` v${session.version}` : ''}`));
+    if (session.shortId)
+        line1.push(chalk.dim(session.shortId));
     if (model)
         line1.push(chalk.bold.white(model));
     if (session.account)
         line1.push(chalk.gray(session.account));
-    // Line 2: cwd · branch · started X ago · lasted Y
+    // Line 2: cwd · project · branch · started X ago · lasted Y
+    // Project is clickable: Linear issue URL is for tickets (line 4); for the
+    // project name prefer a GitHub repo URL derived from the checkout path.
     const line2 = [];
     if (session.cwd) {
         const label = relativeToCwd(session.cwd);
         line2.push(chalk.bold.white(linkPath(session.cwd, label)));
     }
+    if (session.project) {
+        const repoUrl = githubRepoUrlFromCwd(session.cwd);
+        line2.push(chalk.cyan(repoUrl ? linkUrl(repoUrl, session.project) : session.project));
+    }
     if (session.gitBranch)
         line2.push(chalk.cyan(session.gitBranch));
     if (startedAgo)
@@ -125,13 +178,46 @@ function formatHeader(session, events) {
     }
     if (session.label)
         line3.push(chalk.white(session.label));
-    line3.push(chalk.gray(linkPath(session.filePath, session.id)));
+    if (session.filePath)
+        line3.push(chalk.gray(linkPath(session.filePath, session.id)));
+    else
+        line3.push(chalk.gray(session.id));
+    // Line 4: ticket + PR — clickable when a URL is resolvable (OSC 8 hyperlink),
+    // plain text otherwise. Only rendered when the session carries either.
+    const line4 = [];
+    if (session.ticketId) {
+        const url = linearIssueUrl(session.ticketId);
+        line4.push(chalk.blue(url ? linkUrl(url, session.ticketId) : session.ticketId));
+    }
+    if (session.prUrl) {
+        const label = session.prNumber ? `PR#${session.prNumber}` : 'PR';
+        line4.push(chalk.blue(linkUrl(session.prUrl, label)));
+    }
     return [
         line1.join(DOT),
         line2.join(DOT),
         line3.join(DOT),
+        ...(line4.length ? [line4.join(DOT)] : []),
     ].join('\n');
 }
+/**
+ * Body lines available from SessionMeta alone (no transcript parse) — used for
+ * remote / unindexed sessions so checklist progress still surfaces when the
+ * parser teammate (or a prior scan) has populated `session.todos`.
+ */
+function formatMetaOnlyBody(session) {
+    const lines = [];
+    if (session.topic) {
+        lines.push(chalk.cyan('Prompt: ') + chalk.white(truncate(session.topic.trim(), (process.stdout.columns || 80) - 12)));
+    }
+    const compact = formatTodoCompact(session.todos);
+    if (compact) {
+        lines.push(chalk.cyan('Todos: ') + chalk.white(compact));
+    }
+    if (lines.length === 0)
+        return '';
+    return lines.map(l => '  ' + l).join('\n');
+}
 function extractModel(events) {
     for (let i = events.length - 1; i >= 0; i--) {
         const m = events[i].model;
@@ -189,6 +275,7 @@ function stripTags(text) {
 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) {
     let firstUser = '';
     let lastAssistant = '';
@@ -196,7 +283,8 @@ function formatCompactPreview(events, session) {
     const toolCounts = {};
     let toolCalls = 0;
     let planFile = '';
-    let latestTodos = null;
+    /** Latest checklist from the transcript (Claude TodoWrite / Codex update_plan). */
+    let latestTodos;
     for (const event of events) {
         if (event.type === 'message') {
             if (event.role === 'user' && !firstUser && event.content) {
@@ -217,25 +305,53 @@ function formatCompactPreview(events, session) {
             if (!planFile && p && /\/plans\/[^/]+\.md$/.test(p)) {
                 planFile = p;
             }
-            if (tool === 'TodoWrite' && Array.isArray(event.args?.todos)) {
-                latestTodos = event.args.todos;
+            // Claude TodoWrite (`todos`) and Codex update_plan (`plan`) — same source as
+            // extractTodoProgress in the state engine. Prefer the most recent write.
+            if (tool === 'TodoWrite' || tool === 'update_plan') {
+                const progress = extractTodoProgress(event.args);
+                if (progress)
+                    latestTodos = progress;
             }
             if (tool)
                 toolCounts[tool] = (toolCounts[tool] ?? 0) + 1;
             toolCalls++;
         }
     }
+    // Prefer the transcript-derived list when we just re-parsed the file (freshest
+    // 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 lines = [];
     const termWidth = process.stdout.columns || 80;
+    // Originating user prompt (first non-system user turn).
     if (firstUser) {
         const first = extractSessionTopic(firstUser) || cleanSessionPrompt(firstUser).split('\n').find(l => l.trim()) || '';
         if (first) {
             lines.push(chalk.cyan('Prompt: ') + chalk.white(truncate(first.trim(), termWidth - 12)));
         }
     }
+    else if (session.topic) {
+        lines.push(chalk.cyan('Prompt: ') + chalk.white(truncate(session.topic.trim(), termWidth - 12)));
+    }
+    // Compact checklist: ✓done/total · current step (RUSH-2045).
+    const compact = formatTodoCompact(todos);
+    if (compact) {
+        lines.push(chalk.cyan('Todos: ') + chalk.white(compact));
+    }
+    const todosRendered = todos?.items?.length ? renderTodos(todos.items, termWidth) : [];
+    if (todosRendered.length > 0) {
+        for (const l of todosRendered)
+            lines.push('  ' + l);
+    }
+    // Recent activity = directories touched (not raw tool calls). Prefer a
+    // parser-supplied dirsTouched when present; else derive from event paths.
+    const dirs = directoriesTouched(session, events, changes);
+    if (dirs.length) {
+        lines.push(chalk.cyan('Dirs:    ') + chalk.white(dirs.join(chalk.gray(' · '))));
+    }
     const activity = [];
     const changed = chg.created + chg.modified + chg.deleted;
     if (changed) {
@@ -272,14 +388,8 @@ function formatCompactPreview(events, session) {
         const basename = planFile.split('/').pop() || planFile;
         lines.push(chalk.cyan('Plan: ') + chalk.white(linkPath(planFile, basename)));
     }
-    const todosRendered = latestTodos ? renderTodos(latestTodos, termWidth) : [];
-    if (todosRendered.length > 0) {
-        lines.push(chalk.cyan('Todos:'));
-        for (const l of todosRendered)
-            lines.push('  ' + l);
-    }
     if (lastAssistant) {
-        const maxLines = todosRendered.length > 0 ? LAST_RESPONSE_MAX_LINES_WITH_TODOS : LAST_RESPONSE_MAX_LINES;
+        const maxLines = todosRendered.length > 0 || compact ? LAST_RESPONSE_MAX_LINES_WITH_TODOS : LAST_RESPONSE_MAX_LINES;
         const rendered = renderLastResponse(lastAssistant, maxLines);
         if (rendered.length > 0) {
             lines.push('');
@@ -293,6 +403,64 @@ function formatCompactPreview(events, session) {
     }
     return lines.map(l => '  ' + l).join('\n');
 }
+/**
+ * Unique directories the session touched, compact and human-readable.
+ * Prefer `session.dirsTouched` when the parser teammate has populated it;
+ * otherwise derive from file-change + tool paths already available here.
+ */
+function directoriesTouched(session, events, changes) {
+    const fromMeta = session.dirsTouched;
+    if (Array.isArray(fromMeta) && fromMeta.length > 0) {
+        return fromMeta
+            .map((d) => sanitizeForTerminal(String(d).trim()))
+            .filter(Boolean)
+            .slice(0, DIRS_TOUCHED_MAX);
+    }
+    const counts = new Map();
+    const bump = (raw) => {
+        const dir = relativizeDir(raw, session.cwd);
+        if (!dir)
+            return;
+        counts.set(dir, (counts.get(dir) ?? 0) + 1);
+    };
+    for (const ch of changes)
+        bump(ch.path);
+    for (const event of events) {
+        if (event.type !== 'tool_use' || event._local)
+            continue;
+        const p = event.path || event.args?.file_path || event.args?.path || '';
+        if (p)
+            bump(p);
+    }
+    return [...counts.entries()]
+        .sort((a, b) => b[1] - a[1] || a[0].localeCompare(b[0]))
+        .map(([d]) => d)
+        .slice(0, DIRS_TOUCHED_MAX);
+}
+/** Relativize a file path to its parent dir, short enough for one preview line. */
+function relativizeDir(filePath, cwd) {
+    const norm = filePath.replace(/\\/g, '/');
+    if (!norm || norm.includes('node_modules') || norm.includes('/.git/') || norm.includes('/plans/')) {
+        return undefined;
+    }
+    let dir = path.posix.dirname(norm);
+    if (cwd) {
+        const base = cwd.replace(/\\/g, '/').replace(/\/$/, '');
+        if (dir === base)
+            return '.';
+        if (dir.startsWith(base + '/'))
+            dir = dir.slice(base.length + 1);
+    }
+    // Collapse home prefix.
+    const home = (process.env.HOME || '').replace(/\\/g, '/');
+    if (home && dir.startsWith(home + '/'))
+        dir = '~' + dir.slice(home.length);
+    // Drop ultra-deep absolute noise; keep last 3 segments.
+    const parts = dir.split('/').filter(Boolean);
+    if (parts.length > 3 && dir.startsWith('/'))
+        dir = parts.slice(-3).join('/');
+    return dir || undefined;
+}
 function renderLastResponse(content, maxLines = LAST_RESPONSE_MAX_LINES) {
     const cleaned = stripTags(content).trim();
     if (!cleaned)

package/dist/commands/sessions.d.ts

@@ -9,6 +9,18 @@ import { type PickedSession } from './sessions-picker.js';
  * a captured transcript tail. Collapses runs of whitespace.
  */
 export declare function cleanPreview(text: string): string;
+/**
+ * Identity + checklist + live snippet for an --active / cross-machine row.
+ * Surfaces agent-adjacent identity the flat table already has (label, project)
+ * with a clickable project when a GitHub URL is resolvable, then the checklist
+ * tally and the latest-turn snippet.
+ *
+ * Free-text fields are cleaned individually; OSC 8 hyperlinks are applied
+ * *after* cleaning so `cleanPreview` does not strip the clickable targets
+ * (RUSH-2045 review). Ticket is clickable via {@link signalBadges}, not here,
+ * so the id is not printed twice.
+ */
+export declare function formatActiveRowDescription(s: ActiveSession): string;
 /**
  * Index live sessions by their full session UUID so a historical `SessionMeta`
  * row (`meta.id`) can be matched to the session that is still running now.
@@ -33,6 +45,19 @@ export declare function liveGlyphAndPreview(a: ActiveSession | undefined): {
  * into a scannable column instead of jamming against a truncated topic.
  */
 export declare function ticketLabel(s: Pick<SessionMeta, 'ticketId' | 'prNumber'>): string;
+/**
+ * The row shape `agents sessions --active --json` emits. RUSH-1981: a watcher
+ * joins active sessions on ticketId + project, but the raw ActiveSession nests
+ * the ticket (`ticket.id`) and carries no `project` at all — so a naive join
+ * silently drops every row. Emit both as flat, always-present top-level keys
+ * (null when unknown) alongside the raw fields, so every active row is joinable.
+ * `project` uses the same derivation SessionMeta does — basename(cwd) (see
+ * discover.ts) — so the active view and the history view join identically.
+ */
+export declare function serializeActiveSessionsForJson(sessions: ActiveSession[]): Array<ActiveSession & {
+    ticketId: string | null;
+    project: string | null;
+}>;
 /** Grouped + sorted view of active sessions for the --active renderer. */
 export interface ActiveSessionsLayout {
     workspaces: Array<{
@@ -162,6 +187,12 @@ export declare function renderSessionLog(session: SessionMeta, mode?: ViewMode):
  */
 export declare function renderSessionLogJson(session: SessionMeta): Promise<void>;
 /** Column-visibility flags for the picker row, computed once over the whole pool. */
+/** The SSH-launch origin for a picker row, resolved from the live session's
+ * provenance (transport 'ssh'). `device` is set when the client IP matched a
+ * registered device; absent for an unresolved IP (renders a bare `ssh`). */
+export interface SshOriginTag {
+    device?: string;
+}
 export interface PickerColumns {
     /** Render the machine column (only when the pool spans more than one machine). */
     showMachine?: boolean;
@@ -192,7 +223,7 @@ export declare function machineLabeler(machines: string[]): (m: string) => strin
  * 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;
+export declare function formatPickerLabel(s: SessionMeta, query: string, cols?: PickerColumns, ssh?: SshOriginTag): 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.
@@ -204,8 +235,8 @@ export declare function handlePickedSession(picked: PickedSession): Promise<void
  * Resume a session in the current terminal — a foreground takeover of this
  * process. Used by the single-select picker and by `sessions resume` when the
  * chosen destination is "in place" (unknown emulator / off-macOS, single pick).
- * Falls back to the current version via `/continue` when the version-pinned
- * binary is missing (ENOENT).
+ * Falls back to the same resume invocation against the current version when the
+ * version-pinned launcher is genuinely missing.
  */
 export declare function resumeSessionInPlace(session: SessionMeta): Promise<void>;
 /**
@@ -224,23 +255,34 @@ export declare function resumeSpawnInvocation(cmd: string[], platform?: NodeJS.P
     args: string[];
     shell: boolean;
 };
-/**
- * Build the shell command that resumes a picked session.
- *
- * When the session's originating version is known, uses the version-pinned
- * binary (e.g. `claude@2.1.138`) so the resume always runs in the same
- * isolated HOME where the JSONL was written — regardless of which version is
- * currently the default. Falls back to the bare shim when version is unknown.
- *
- * If the versioned binary is missing (version was removed), the ENOENT
- * handler in handlePickedSession retries via buildFallbackCommand.
- */
 export declare function buildResumeCommand(session: SessionMeta): string[] | null;
 interface AgentFilter {
     agent?: SessionAgentId;
     version?: string;
 }
 export declare function parseAgentFilter(agentName?: string): AgentFilter;
+/**
+ * How a `sessions <query>` argument was resolved against the pool.
+ *
+ * `byId` records that the rows came from an id lookup, so only then does an
+ * ambiguous result mean "your id prefix is too short". `completeId` records that
+ * the query was a whole session id: it is unique by construction, so a miss is
+ * final and must NOT widen into a text/content search.
+ */
+export interface SessionQueryResolution {
+    matches: SessionMeta[];
+    byId: boolean;
+    completeId: boolean;
+}
+/**
+ * The single entry point for turning a `sessions <query>` argument into rows.
+ *
+ * An id-shaped query — a complete id OR a hex short-id/prefix (looksLikeSessionId)
+ * — resolves by id alone, through the index, and never falls back to content
+ * search (a bare id must not surface every transcript that merely mentions it).
+ * A genuine search phrase keeps the ranked metadata+content search.
+ */
+export declare function resolveSessionQuery(pool: SessionMeta[], query: string): SessionQueryResolution;
 /** Filter and rank sessions by a multi-term search query across metadata and content. */
 export declare function filterSessionsByQuery(sessions: SessionMeta[], query: string | undefined): SessionMeta[];
 /** Register the `agents sessions` command with all its options and help text. */