@phnx-labs/agents-cli 1.20.29 → 1.20.31

package/dist/lib/session/discover.js

@@ -20,6 +20,7 @@ import { walkForFiles } from '../fs-walk.js';
 import { getConfigSymlinkVersion } from '../shims.js';
 import { SESSION_AGENTS } from './types.js';
 import { extractSessionTopic } from './prompt.js';
+import { extractPrUrl, detectWorktree, detectTicket, isPrCreateCommand } from './state.js';
 import { costOfUsage } from '../pricing/index.js';
 import { getDB, getScanStampByPath, getScanStampsForPaths, recordScans, syncLabels, syncTopics, upsertSessionsBatch, querySessions, countSessions, ftsSearch, tryClaimScan, releaseScan, } from './db.js';
 const HOME = os.homedir();
@@ -427,6 +428,10 @@ async function readClaudeMeta(filePath, sessionId, account, label) {
             costUsd: scan.costUsd,
             durationMs: scan.durationMs,
             isTeamOrigin,
+            prUrl: scan.prUrl,
+            prNumber: scan.prNumber,
+            worktreeSlug: scan.worktreeSlug,
+            ticketId: scan.ticketId,
         };
     }
     else {
@@ -445,6 +450,10 @@ async function readClaudeMeta(filePath, sessionId, account, label) {
             durationMs: scan.durationMs,
             topic: scan.topic,
             isTeamOrigin,
+            prUrl: scan.prUrl,
+            prNumber: scan.prNumber,
+            worktreeSlug: scan.worktreeSlug,
+            ticketId: scan.ticketId,
         };
     }
     return { meta, content: scan.contentText || '' };
@@ -610,6 +619,10 @@ async function readCodexMeta(filePath, account, currentVersion) {
         costUsd: scan.costUsd,
         durationMs: scan.durationMs,
         account,
+        prUrl: scan.prUrl,
+        prNumber: scan.prNumber,
+        worktreeSlug: scan.worktreeSlug,
+        ticketId: scan.ticketId,
     };
     return { meta, content: scan.contentText || '' };
 }
@@ -1543,6 +1556,12 @@ export async function scanClaudeSession(filePath) {
     let lastTsMs;
     const seenAssistantIds = new Set();
     const userTexts = [];
+    // Durable PR signal: set only when an actual `gh pr create` Bash *command*
+    // runs (structural — the command field, not any prose mentioning it), then
+    // capture the pull URL from a later tool_result's output.
+    let sawPrCreate = false;
+    let prUrl;
+    let prNumber;
     try {
         for await (const line of rl) {
             if (!line.trim())
@@ -1559,6 +1578,31 @@ export async function scanClaudeSession(filePath) {
             if (!entrypoint && typeof parsed.entrypoint === 'string') {
                 entrypoint = parsed.entrypoint;
             }
+            // PR signal, structurally: a Bash tool_use whose command is `gh pr create`
+            // marks intent; the pull URL is then read from a tool_result's output.
+            if (!prUrl) {
+                if (!sawPrCreate && parsed.type === 'assistant' && Array.isArray(parsed.message?.content)) {
+                    for (const b of parsed.message.content) {
+                        if (b?.type === 'tool_use' && typeof b?.input?.command === 'string' && isPrCreateCommand(b.input.command)) {
+                            sawPrCreate = true;
+                        }
+                    }
+                }
+                if (sawPrCreate && parsed.type === 'user' && Array.isArray(parsed.message?.content)) {
+                    for (const b of parsed.message.content) {
+                        if (b?.type !== 'tool_result')
+                            continue;
+                        const text = typeof b.content === 'string'
+                            ? b.content
+                            : Array.isArray(b.content) ? b.content.map((c) => c?.text || '').join('\n') : '';
+                        const pr = extractPrUrl(text);
+                        if (pr) {
+                            prUrl = pr.url;
+                            prNumber = pr.number;
+                        }
+                    }
+                }
+            }
             // Track duration across every timestamped event, not just the first.
             if (typeof parsed.timestamp === 'string') {
                 const ms = new Date(parsed.timestamp).getTime();
@@ -1643,6 +1687,8 @@ export async function scanClaudeSession(filePath) {
     // Prefer an explicit session title (user `/rename` > Claude auto-title) over
     // the first-prompt topic.
     const resolvedTopic = customTitle || aiTitle || topic;
+    const worktree = detectWorktree(cwd, gitBranch);
+    const ticket = detectTicket(userTexts.join('\n') || undefined, gitBranch);
     return {
         timestamp,
         cwd,
@@ -1655,6 +1701,10 @@ export async function scanClaudeSession(filePath) {
         costUsd: sawCost ? costUsd : undefined,
         durationMs,
         contentText: userTexts.length > 0 ? userTexts.join('\n') : undefined,
+        prUrl,
+        prNumber,
+        worktreeSlug: worktree?.slug,
+        ticketId: ticket?.id,
     };
 }
 /** Stream a Codex JSONL file and extract scan-level metadata (session ID, cwd, topic, tokens). */
@@ -1674,6 +1724,9 @@ async function scanCodexSession(filePath) {
     let firstTsMs;
     let lastTsMs;
     const userTexts = [];
+    let sawPrCreate = false;
+    let prUrl;
+    let prNumber;
     try {
         for await (const line of rl) {
             if (!line.trim())
@@ -1685,6 +1738,28 @@ async function scanCodexSession(filePath) {
             catch {
                 continue;
             }
+            // PR signal, structurally: a Codex `function_call` whose command is
+            // `gh pr create`, then the pull URL from a `function_call_output`.
+            if (!prUrl && parsed.type === 'response_item') {
+                const p = parsed.payload || {};
+                if (!sawPrCreate && p.type === 'function_call') {
+                    let cmd = '';
+                    try {
+                        const args = typeof p.arguments === 'string' ? JSON.parse(p.arguments) : (p.arguments || {});
+                        cmd = String(args.command || args.cmd || '');
+                    }
+                    catch { /* non-JSON args */ }
+                    if (isPrCreateCommand(cmd))
+                        sawPrCreate = true;
+                }
+                if (sawPrCreate && p.type === 'function_call_output') {
+                    const pr = extractPrUrl(String(p.output || ''));
+                    if (pr) {
+                        prUrl = pr.url;
+                        prNumber = pr.number;
+                    }
+                }
+            }
             // Track duration across every timestamped event.
             if (typeof parsed.timestamp === 'string') {
                 const ms = new Date(parsed.timestamp).getTime();
@@ -1755,6 +1830,8 @@ async function scanCodexSession(filePath) {
     const durationMs = firstTsMs !== undefined && lastTsMs !== undefined && lastTsMs > firstTsMs
         ? lastTsMs - firstTsMs
         : undefined;
+    const worktree = detectWorktree(cwd, gitBranch);
+    const ticket = detectTicket(userTexts.join('\n') || undefined, gitBranch);
     return {
         sessionId,
         timestamp,
@@ -1767,6 +1844,10 @@ async function scanCodexSession(filePath) {
         costUsd,
         durationMs,
         contentText: userTexts.length > 0 ? userTexts.join('\n') : undefined,
+        prUrl,
+        prNumber,
+        worktreeSlug: worktree?.slug,
+        ticketId: ticket?.id,
     };
 }
 /** Resolve the working directory for an OpenClaw agent from its workspace config. */

package/dist/lib/session/parse.d.ts

@@ -13,6 +13,8 @@ import type { SessionAgentId, SessionEvent } from './types.js';
  */
 export declare const SESSION_FILE_MAX_BYTES = 200000000;
 export declare function sanitizeForTerminal(s: string): string;
+/** In-place sanitize every user-visible string field on a list of events. */
+export declare function sanitizeEvents(events: SessionEvent[]): void;
 /**
  * Read a session file, refusing files above maxBytes. Bounded read protects
  * against multi-GB session blobs that would OOM the CLI or exceed V8's
@@ -31,8 +33,21 @@ export declare function detectAgent(filePath: string): SessionAgentId | null;
 export declare function summarizeToolUse(tool: string, args?: Record<string, any>): string;
 /** Parse a Claude JSONL session file into normalized events. */
 export declare function parseClaude(filePath: string): SessionEvent[];
+/**
+ * Parse Claude JSONL *content* (already read into a string) into normalized
+ * events. Split from `parseClaude` so the tail reader can parse just the last
+ * chunk of a file without re-reading the whole thing. Malformed leading lines
+ * (a tail that starts mid-line) are skipped by the per-line try/catch below.
+ */
+export declare function parseClaudeContent(content: string): SessionEvent[];
 /** Parse a Codex JSONL session file into normalized events. */
 export declare function parseCodex(filePath: string): SessionEvent[];
+/**
+ * Parse Codex JSONL *content* (already read into a string) into normalized
+ * events. Split from `parseCodex` so the tail reader can parse just the last
+ * chunk without re-reading the whole file.
+ */
+export declare function parseCodexContent(content: string): SessionEvent[];
 /** Parse a Gemini JSON session file into normalized events. */
 export declare function parseGemini(filePath: string): SessionEvent[];
 /**

package/dist/lib/session/parse.js

@@ -41,6 +41,11 @@ function sanitizeArgsDeep(value) {
     }
     return value;
 }
+/** In-place sanitize every user-visible string field on a list of events. */
+export function sanitizeEvents(events) {
+    for (const e of events)
+        sanitizeEvent(e);
+}
 /** In-place sanitize all user-visible string fields on an event. */
 function sanitizeEvent(e) {
     if (e.content)
@@ -214,7 +219,15 @@ function shortenPath(p) {
 // ---------------------------------------------------------------------------
 /** Parse a Claude JSONL session file into normalized events. */
 export function parseClaude(filePath) {
-    const content = safeReadSessionFile(filePath);
+    return parseClaudeContent(safeReadSessionFile(filePath));
+}
+/**
+ * Parse Claude JSONL *content* (already read into a string) into normalized
+ * events. Split from `parseClaude` so the tail reader can parse just the last
+ * chunk of a file without re-reading the whole thing. Malformed leading lines
+ * (a tail that starts mid-line) are skipped by the per-line try/catch below.
+ */
+export function parseClaudeContent(content) {
     const lines = content.split('\n').filter(l => l.trim());
     const events = [];
     // Map tool_use id -> {tool, args} for correlating with tool_result
@@ -403,7 +416,14 @@ export function parseClaude(filePath) {
 // ---------------------------------------------------------------------------
 /** Parse a Codex JSONL session file into normalized events. */
 export function parseCodex(filePath) {
-    const content = safeReadSessionFile(filePath);
+    return parseCodexContent(safeReadSessionFile(filePath));
+}
+/**
+ * Parse Codex JSONL *content* (already read into a string) into normalized
+ * events. Split from `parseCodex` so the tail reader can parse just the last
+ * chunk without re-reading the whole file.
+ */
+export function parseCodexContent(content) {
     const lines = content.split('\n').filter(l => l.trim());
     const events = [];
     // Track function_call id -> name for correlating with function_call_output

package/dist/lib/session/remote.d.ts

@@ -23,7 +23,7 @@ export declare function buildForwardedArgs(argv: string[], hosts?: Set<string>):
  * are quoted for the inner login shell, then the whole `agents …` invocation is
  * quoted again so it survives `bash -lc <...>`.
  */
-export declare function buildRemoteCommand(forwardedArgs: string[]): string;
+export declare function buildRemoteCommand(forwardedArgs: string[], columns?: number): string;
 /** The four outcomes of one `ssh <host> agents sessions …` invocation. */
 export type SshOutcome = 'ok' | 'unreachable' | 'query-failed' | 'spawn-error';
 /**

package/dist/lib/session/remote.js

@@ -28,6 +28,7 @@ import { createHash } from 'crypto';
 import chalk from 'chalk';
 import { getCacheDir } from '../state.js';
 import { formatRelativeTime } from './relative-time.js';
+import { terminalWidth } from './width.js';
 /**
  * SSH target: a bare ssh-config host alias (e.g. `yosemite-s1`) or `user@host`.
  * The strict allowlist blocks shell metacharacters and a leading `-`, so a target
@@ -87,9 +88,13 @@ export function buildForwardedArgs(argv, hosts = new Set()) {
  * are quoted for the inner login shell, then the whole `agents …` invocation is
  * quoted again so it survives `bash -lc <...>`.
  */
-export function buildRemoteCommand(forwardedArgs) {
+export function buildRemoteCommand(forwardedArgs, columns) {
     const inner = ['agents', ...forwardedArgs].map(shellQuote).join(' ');
-    return `bash -lc ${shellQuote(inner)}`;
+    // Forward the caller's terminal width so the remote renders the table to the
+    // local screen (over SSH the remote's own COLUMNS is unset/wrong). `VAR=val
+    // cmd` scopes the env to that process — the remote's terminalWidth() reads it.
+    const withCols = columns && columns > 0 ? `COLUMNS=${columns} ${inner}` : inner;
+    return `bash -lc ${shellQuote(withCols)}`;
 }
 const SSH_OPTS = [
     '-o', 'BatchMode=yes',
@@ -175,7 +180,7 @@ export function runRemoteSessions(hosts, argv = process.argv) {
     for (const host of hosts)
         assertValidSshTarget(host); // fail fast on any bad target
     const forwarded = buildForwardedArgs(argv, new Set(hosts));
-    const remoteCmd = buildRemoteCommand(forwarded);
+    const remoteCmd = buildRemoteCommand(forwarded, terminalWidth());
     const multi = hosts.length > 1;
     let failures = 0;
     for (const host of hosts) {

package/dist/lib/session/render.d.ts

@@ -49,6 +49,8 @@ export interface SessionStats {
     userTurns: number;
     assistantTurns: number;
     toolCount: number;
+    /** Per-tool call counts (histogram), highest first when rendered. */
+    toolCounts: Record<string, number>;
     errorCount: number;
     outputTokens: number;
     cacheReadTokens: number;

package/dist/lib/session/render.js

@@ -11,6 +11,7 @@ import { summarizeToolUse } from './parse.js';
 import { cleanSessionPrompt, extractSessionTopic } from './prompt.js';
 import { renderMarkdown } from '../markdown.js';
 import { redactSecrets } from '../redact.js';
+import { classifyFileChanges, changeCounts, toolHistogram, detectTestResult } from './digest.js';
 // ── Path helpers ──────────────────────────────────────────────────────────────
 /**
  * Return absPath relative to cwd; fall back to ~/… then absolute.
@@ -153,6 +154,7 @@ export function collapseRetries(commands) {
 /** Compute aggregate statistics (turns, tools, tokens, duration) from session events. */
 export function computeSummaryStats(events) {
     const modelSet = new Set();
+    const toolCounts = {};
     let userTurns = 0;
     let assistantTurns = 0;
     let toolCount = 0;
@@ -177,6 +179,8 @@ export function computeSummaryStats(events) {
         }
         else if (e.type === 'tool_use' && !e._local) {
             toolCount++;
+            if (e.tool)
+                toolCounts[e.tool] = (toolCounts[e.tool] ?? 0) + 1;
         }
         else if (e.type === 'error') {
             errorCount++;
@@ -193,6 +197,7 @@ export function computeSummaryStats(events) {
         userTurns,
         assistantTurns,
         toolCount,
+        toolCounts,
         errorCount,
         outputTokens,
         cacheReadTokens,
@@ -426,6 +431,76 @@ function renderActivityLine(item) {
             return chalk.green('Msg  ') + ' ' + chalk.gray('"' + trim(item.label) + '"');
     }
 }
+// ── Catch-up digest sections ──────────────────────────────────────────────────
+const OP_GLYPH = {
+    created: (s) => chalk.green(s),
+    modified: (s) => chalk.yellow(s),
+    deleted: (s) => chalk.red(s),
+};
+const OP_MARK = { created: '+', modified: '~', deleted: '−' };
+/**
+ * Render the Changes section: files grouped by directory, each tagged with its
+ * create/modify/delete lifecycle, plus a `+N ~N −N` summary. Replaces the old
+ * flat "Modified" list. Returns true if anything was rendered.
+ */
+function renderChangesSection(lines, events, cwd) {
+    // In-project changes only; edits outside cwd (e.g. /tmp) keep their own
+    // "External edits" section so they don't clutter the project's changeset.
+    const inCwd = (p) => !cwd || !p.startsWith('/') || p.startsWith(cwd + '/');
+    const changes = classifyFileChanges(events).filter(ch => inCwd(ch.path));
+    if (changes.length === 0)
+        return false;
+    const c = changeCounts(changes);
+    const opByRel = new Map();
+    for (const ch of changes)
+        opByRel.set(relativeToCwd(ch.path, cwd), ch.op);
+    const summary = [
+        c.created ? chalk.green(`+${c.created}`) : '',
+        c.modified ? chalk.yellow(`~${c.modified}`) : '',
+        c.deleted ? chalk.red(`−${c.deleted}`) : '',
+    ].filter(Boolean).join(' ');
+    lines.push(chalk.bold('Changes') + chalk.gray(` (${changes.length})  `) + summary);
+    const groups = groupByParentDir(changes.map(ch => ch.path), cwd);
+    const single = groups.size === 1;
+    for (const [dir, files] of groups) {
+        // Single dir: show the full relative path per file (dir/base). Multiple
+        // dirs: a dir header, then bare filenames under it.
+        if (!single)
+            lines.push('  ' + chalk.dim(dir + '/'));
+        for (const f of files.sort()) {
+            const rel = dir === '.' ? f : `${dir}/${f}`;
+            const op = opByRel.get(rel) ?? 'modified';
+            const shown = single ? rel : f;
+            const name = op === 'deleted' ? chalk.strikethrough(chalk.gray(shown)) : shown;
+            lines.push((single ? '  ' : '    ') + OP_GLYPH[op](OP_MARK[op]) + ' ' + name);
+        }
+    }
+    lines.push('');
+    return true;
+}
+/** Render the tool histogram: `Edit 61 · Bash 48 · Read 35 …`. */
+function renderToolsSection(lines, stats) {
+    const hist = toolHistogram(stats.toolCounts, 8);
+    if (hist.length === 0)
+        return;
+    const parts = hist.map(h => `${chalk.white(h.tool)} ${chalk.gray(String(h.count))}`);
+    lines.push(chalk.bold('Tools') + '  ' + parts.join(chalk.gray(' · ')));
+    lines.push('');
+}
+/** Render the last test/build verdict, e.g. `Tests  tests: 294 pass · 4 fail`. */
+function renderTestsLine(lines, events) {
+    const r = detectTestResult(events);
+    if (!r || !r.ok)
+        return;
+    const bits = [];
+    if (r.passed !== undefined)
+        bits.push(chalk.green(`${r.passed} pass`));
+    if (r.failed !== undefined)
+        bits.push(r.failed > 0 ? chalk.red(`${r.failed} fail`) : chalk.gray('0 fail'));
+    const verdict = r.failed && r.failed > 0 ? chalk.red('✗') : chalk.green('✓');
+    lines.push(chalk.bold('Tests') + `  ${verdict} ${chalk.cyan(r.runner)} ${bits.join(chalk.gray(' · '))}`);
+    lines.push('');
+}
 // ── Main summary renderer ─────────────────────────────────────────────────────
 /**
  * Render session as an activity summary.
@@ -560,7 +635,6 @@ export function renderSummary(events, cwd) {
         }
         return m;
     };
-    const modifiedAbsMap = buildAbsMap(filesModifiedAbs);
     const readAbsMap = buildAbsMap(filesReadAbs);
     // ── Render sections ───────────────────────────────────────────────────────
     const lines = [''];
@@ -640,15 +714,14 @@ export function renderSummary(events, cwd) {
             chalk.gray(`: ${errors.length} failure${errors.length !== 1 ? 's' : ''} — first: ${firstDesc}`));
         lines.push('');
     }
-    // 6. Modified files
-    if (filesModifiedAbs.size > 0) {
-        lines.push(chalk.bold('Modified') + chalk.gray(` (${filesModifiedAbs.size})`));
-        const groups = groupByParentDir(filesModifiedAbs, cwd);
-        renderFileGroup(lines, groups, modifiedAbsMap);
-        lines.push('');
-    }
-    // 6b. External edits (files edited outside the project root — typically /tmp)
-    // Filter out plan files (already shown in Plan section)
+    // 6. Changes — files grouped by directory with create/modify/delete lifecycle
+    // (replaces the old flat "Modified" + "External edits" lists).
+    renderChangesSection(lines, events, cwd);
+    // 6b. Catch-up signals: last test/build verdict, then the tool histogram.
+    renderTestsLine(lines, events);
+    renderToolsSection(lines, computeSummaryStats(events));
+    // 6c. External edits (files edited outside the project root — typically /tmp).
+    // Filter out plan files (already shown in Plan section).
     const externalNonPlan = [...filesModifiedExternal].filter(p => !(p.includes('.claude/plans/') && p.endsWith('.md')));
     if (externalNonPlan.length > 0) {
         const externalList = externalNonPlan.sort();

package/dist/lib/session/state.d.ts

@@ -0,0 +1,82 @@
+/**
+ * Session state inference.
+ *
+ * Turns a chronological slice of normalized `SessionEvent`s (typically the tail
+ * of a transcript) plus lightweight context (file mtime, cwd, branch, whether
+ * the owning process is alive) into a `SessionState`: is the agent working,
+ * waiting on the user, or idle — and did it open a PR, is it in a worktree, is
+ * it tied to a tracker ticket. Pure functions, no I/O, so the whole thing is
+ * unit-testable and shared by both the live `--active` path and the incremental
+ * scanner (which persists the durable signals to the index).
+ *
+ * Structural signals are preferred over prose heuristics: Claude's
+ * `ExitPlanMode` / `AskUserQuestion` tool calls are exact "waiting on you"
+ * markers. Codex has no such tools, so it falls back to last-role + question
+ * shape + mtime — same function, driven off the normalized events.
+ */
+import type { SessionEvent } from './types.js';
+export type SessionActivity = 'working' | 'waiting_input' | 'idle';
+export type AwaitingReason = 'question' | 'plan_review' | 'permission';
+export interface DetectedPr {
+    url: string;
+    number?: number;
+}
+export interface DetectedWorktree {
+    /** Absolute worktree path (the session cwd). */
+    path: string;
+    /** The `<slug>` under `.agents/worktrees/`. */
+    slug: string;
+    branch?: string;
+}
+export interface DetectedTicket {
+    /** Tracker key, e.g. `RUSH-1234`. */
+    id: string;
+    url?: string;
+}
+export interface SessionState {
+    activity: SessionActivity;
+    awaitingReason?: AwaitingReason;
+    lastRole?: 'user' | 'assistant';
+    lastEventKind?: SessionEvent['type'];
+    /** Single-line description of the latest turn (message text or tool action). */
+    preview?: string;
+    lastActivityMs?: number;
+    pr?: DetectedPr;
+    worktree?: DetectedWorktree;
+    ticket?: DetectedTicket;
+}
+export interface StateContext {
+    /** Session file mtime; drives running-vs-stale. */
+    mtimeMs?: number;
+    cwd?: string;
+    gitBranch?: string;
+    /** Whether the owning OS process is alive (from the active scanner). */
+    pidAlive?: boolean;
+    /** Override the running window (defaults to 2 min, matching active.ts). */
+    activeWindowMs?: number;
+}
+/** Detect a worktree from the session cwd, per the `.agents/worktrees/<slug>/` convention. */
+export declare function detectWorktree(cwd?: string, branch?: string): DetectedWorktree | undefined;
+/** Detect a tracker ticket from free text (prompt/topic) then a branch name. */
+export declare function detectTicket(text?: string, branch?: string): DetectedTicket | undefined;
+/** Pull a PR URL + number out of tool-result output text. */
+export declare function extractPrUrl(output?: string): DetectedPr | undefined;
+/** True when a Bash/exec command string is a `gh pr create`. */
+export declare function isPrCreateCommand(command?: string): boolean;
+/**
+ * Infer live activity + a preview from a chronological event slice. `pr` /
+ * `ticket` / `worktree` are attached by `inferSessionState`; this focuses on the
+ * running-vs-waiting-vs-idle decision and the preview line.
+ */
+export declare function inferActivity(events: SessionEvent[], ctx?: StateContext): SessionState;
+/**
+ * Scan an event slice for the durable signals (PR opened, ticket) that aren't
+ * about the cwd. Correlates each `gh pr create` with the nearest following
+ * tool_result URL; keeps the last PR found.
+ */
+export declare function detectDurableSignals(events: SessionEvent[]): {
+    pr?: DetectedPr;
+    ticket?: DetectedTicket;
+};
+/** Full inference: activity + preview + durable signals + worktree/ticket from ctx. */
+export declare function inferSessionState(events: SessionEvent[], ctx?: StateContext): SessionState;