@phnx-labs/agents-cli 1.20.28 → 1.20.30

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();
@@ -34,6 +35,7 @@ const RUSH_SESSIONS_DIR = path.join(HOME, '.rush', 'sessions');
 const HERMES_SESSIONS_DIR = path.join(HOME, '.hermes', 'sessions');
 /** How long OpenClaw channel/cron snapshots stay valid before we re-shell-out. */
 const OPENCLAW_TTL_MS = 60_000;
+const ACTIVE_APPEND_RESCAN_DEBOUNCE_MS = 5_000;
 let cachedOpenClawWorkspaces = null;
 const cachedAgentVersions = new Map();
 /**
@@ -63,6 +65,7 @@ export async function discoverSessions(options) {
                     case 'rush': return scanRushIncremental(onProgress);
                     case 'hermes': return scanHermesIncremental(onProgress);
                     case 'kimi': return scanKimiIncremental(onProgress);
+                    case 'droid': return scanDroidIncremental(onProgress);
                 }
             }));
         }
@@ -164,10 +167,16 @@ export function searchContentIndex(sessions, query) {
 /**
  * For a list of files, stat each, compare to the DB ledger, and return only
  * the ones that need rescanning. One bulk DB query for the whole list.
+ *
+ * Actively running agents append to their JSONL every few seconds. Without a
+ * small debounce, repeated `agents sessions` invocations stream-parse the same
+ * growing transcript over and over. The cached row is good enough for a few
+ * seconds; once writes settle or the debounce expires, the file is parsed once.
  */
 function filterChangedFiles(filePaths) {
     const ledger = getScanStampsForPaths(filePaths);
     const out = [];
+    const now = Date.now();
     for (const filePath of filePaths) {
         const stat = safeStatSync(filePath);
         if (!stat)
@@ -180,10 +189,22 @@ function filterChangedFiles(filePaths) {
         if (prev && prev.fileMtimeMs === scan.fileMtimeMs && prev.fileSize === scan.fileSize) {
             continue;
         }
+        if (prev && shouldDeferRecentAppend(prev, scan, now)) {
+            continue;
+        }
         out.push({ filePath, scan });
     }
     return out;
 }
+export function shouldDeferRecentAppend(prev, current, nowMs, debounceMs = ACTIVE_APPEND_RESCAN_DEBOUNCE_MS) {
+    if (prev.scannedAt === undefined)
+        return false;
+    if (current.fileSize <= prev.fileSize)
+        return false;
+    if (current.fileMtimeMs < prev.fileMtimeMs)
+        return false;
+    return nowMs - prev.scannedAt < debounceMs;
+}
 // ---------------------------------------------------------------------------
 // Multi-version directory scanning
 // ---------------------------------------------------------------------------
@@ -407,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 {
@@ -425,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 || '' };
@@ -590,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 || '' };
 }
@@ -1291,6 +1324,214 @@ function extractHermesMessageText(content) {
         .join('\n')
         .trim();
 }
+/**
+ * Incrementally re-scan changed Droid (Factory) session files and upsert into
+ * the DB. Droid writes one `<uuid>.jsonl` transcript plus a sibling
+ * `<uuid>.settings.json` (model + token usage) under
+ * `~/.factory/sessions/<encoded-cwd>/`.
+ */
+async function scanDroidIncremental(onProgress) {
+    const currentVersion = await getCurrentAgentVersion('droid');
+    const filePaths = [];
+    for (const sessionsDir of getAgentSessionDirs('droid', 'sessions')) {
+        // High limit: we only stat files here, parsing is gated by ledger match.
+        for (const fp of walkForFiles(sessionsDir, '.jsonl', 100_000)) {
+            filePaths.push(fp);
+        }
+    }
+    const changed = filterChangedFiles(filePaths);
+    if (changed.length === 0)
+        return;
+    onProgress?.({ agent: 'droid', parsed: 0, total: changed.length });
+    const entries = [];
+    const touched = [];
+    const seen = new Set();
+    let parsed = 0;
+    for (const { filePath, scan } of changed) {
+        try {
+            const result = await readDroidMeta(filePath, currentVersion);
+            if (result && !seen.has(result.meta.id)) {
+                seen.add(result.meta.id);
+                entries.push({ meta: result.meta, content: result.content, scan });
+            }
+            else {
+                touched.push({ filePath, scan });
+            }
+        }
+        catch {
+            touched.push({ filePath, scan });
+        }
+        parsed++;
+        onProgress?.({ agent: 'droid', parsed, total: changed.length });
+    }
+    upsertSessionsBatch(entries);
+    recordScans(touched);
+}
+/** Stream-parse a single Droid JSONL file (+ sibling settings) into session metadata. */
+async function readDroidMeta(filePath, currentVersion) {
+    const scan = await scanDroidSession(filePath);
+    // The filename is the canonical session id; fall back to the session_start id.
+    const sessionId = path.basename(filePath).replace(/\.jsonl$/, '') || scan.sessionId || '';
+    if (!sessionId)
+        return null;
+    // Token usage and cost live only in the sibling `<uuid>.settings.json`.
+    const settings = readDroidSettings(filePath.replace(/\.jsonl$/, '.settings.json'));
+    const model = settings.model || scan.model;
+    const tokenCount = settings.tokenCount;
+    const costUsd = model && settings.usage
+        ? costOfUsage({
+            model,
+            inputTokens: settings.usage.inputTokens,
+            outputTokens: settings.usage.outputTokens,
+            cacheReadTokens: settings.usage.cacheReadTokens,
+            cacheCreationTokens: settings.usage.cacheCreationTokens,
+        })
+        : 0;
+    const stat = safeStatSync(filePath);
+    const cwd = normalizeCwd(scan.cwd || '');
+    const meta = {
+        id: sessionId,
+        shortId: sessionId.slice(0, 8),
+        agent: 'droid',
+        timestamp: scan.timestamp || (stat ? stat.mtime.toISOString() : new Date().toISOString()),
+        project: cwd ? path.basename(cwd) : undefined,
+        cwd,
+        filePath,
+        version: resolveSessionVersion('droid', filePath, undefined, currentVersion),
+        topic: scan.topic,
+        messageCount: scan.messageCount,
+        tokenCount,
+        costUsd: costUsd > 0 ? costUsd : undefined,
+        durationMs: scan.durationMs,
+    };
+    return { meta, content: scan.contentText || '' };
+}
+/** Read model + token usage from a Droid `<uuid>.settings.json` sidecar. */
+function readDroidSettings(settingsPath) {
+    try {
+        const data = JSON.parse(fs.readFileSync(settingsPath, 'utf-8'));
+        const model = typeof data.model === 'string' ? data.model : undefined;
+        const u = data.tokenUsage;
+        if (!u || typeof u !== 'object')
+            return { model };
+        const usage = {
+            inputTokens: u.inputTokens,
+            outputTokens: u.outputTokens,
+            cacheReadTokens: u.cacheReadTokens,
+            cacheCreationTokens: u.cacheCreationTokens,
+        };
+        const tokenCount = sumKnownNumbers([
+            u.inputTokens,
+            u.outputTokens,
+            u.cacheCreationTokens,
+            u.cacheReadTokens,
+        ]) ?? undefined;
+        return { model, tokenCount, usage };
+    }
+    catch {
+        return {};
+    }
+}
+/** Stream a Droid JSONL file and extract scan-level metadata (id, cwd, topic, model, duration). */
+async function scanDroidSession(filePath) {
+    const stream = fs.createReadStream(filePath, { encoding: 'utf-8' });
+    const rl = readline.createInterface({ input: stream, crlfDelay: Infinity });
+    let sessionId;
+    let timestamp;
+    let cwd;
+    let title;
+    let sessionTitle;
+    let firstUserTopic;
+    let model;
+    let messageCount = 0;
+    let firstTsMs;
+    let lastTsMs;
+    const userTexts = [];
+    try {
+        for await (const line of rl) {
+            if (!line.trim())
+                continue;
+            let parsed;
+            try {
+                parsed = JSON.parse(line);
+            }
+            catch {
+                continue;
+            }
+            if (parsed.type === 'session_start') {
+                sessionId = typeof parsed.id === 'string' ? parsed.id : sessionId;
+                cwd = typeof parsed.cwd === 'string' ? parsed.cwd : cwd;
+                // Droid auto-generates `sessionTitle`; `title` is the raw first prompt.
+                if (typeof parsed.sessionTitle === 'string' && parsed.sessionTitle.trim()) {
+                    sessionTitle = parsed.sessionTitle.trim();
+                }
+                if (typeof parsed.title === 'string' && parsed.title.trim()) {
+                    title = parsed.title.trim();
+                }
+                continue;
+            }
+            if (parsed.type !== 'message')
+                continue;
+            // Track duration across every timestamped message.
+            if (typeof parsed.timestamp === 'string') {
+                const ms = new Date(parsed.timestamp).getTime();
+                if (!Number.isNaN(ms)) {
+                    if (firstTsMs === undefined || ms < firstTsMs)
+                        firstTsMs = ms;
+                    if (lastTsMs === undefined || ms > lastTsMs)
+                        lastTsMs = ms;
+                }
+            }
+            if (!timestamp && typeof parsed.timestamp === 'string')
+                timestamp = parsed.timestamp;
+            const msg = parsed.message || {};
+            if (typeof msg.modelId === 'string')
+                model = msg.modelId;
+            const text = extractDroidMessageText(msg.content);
+            if (!text)
+                continue;
+            messageCount++;
+            if (msg.role === 'user') {
+                userTexts.push(text);
+                if (!firstUserTopic)
+                    firstUserTopic = extractSessionTopic(text);
+            }
+        }
+    }
+    finally {
+        rl.close();
+        stream.destroy();
+    }
+    const durationMs = firstTsMs !== undefined && lastTsMs !== undefined && lastTsMs > firstTsMs
+        ? lastTsMs - firstTsMs
+        : undefined;
+    return {
+        sessionId,
+        timestamp,
+        cwd,
+        // Prefer Droid's auto-title, then the raw first-prompt title, then the
+        // derived first-user-message topic.
+        topic: sessionTitle || title || firstUserTopic,
+        model,
+        messageCount,
+        durationMs,
+        contentText: userTexts.length > 0 ? userTexts.join('\n') : undefined,
+    };
+}
+/** Extract plain text from a Droid message content field (Anthropic-shaped blocks). */
+function extractDroidMessageText(content) {
+    if (typeof content === 'string')
+        return content.trim();
+    if (!Array.isArray(content))
+        return '';
+    return content
+        .map((part) => (typeof part?.text === 'string' && part.type === 'text' ? part.text : ''))
+        // Droid front-loads injected context (date, skills list) as <system-reminder>
+        // text blocks on the first user turn — drop them so topic/content stay clean.
+        .filter((text) => text.trim() && !text.trim().startsWith('<system-reminder>'))
+        .join('\n')
+        .trim();
+}
 /** Stream a Claude JSONL file and extract scan-level metadata (timestamp, cwd, topic, tokens). */
 export async function scanClaudeSession(filePath) {
     const stream = fs.createReadStream(filePath, { encoding: 'utf-8' });
@@ -1315,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())
@@ -1331,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();
@@ -1415,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,
@@ -1427,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). */
@@ -1446,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())
@@ -1457,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();
@@ -1527,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,
@@ -1539,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[];
 /**
@@ -51,3 +66,10 @@ export declare function parseRush(filePath: string): SessionEvent[];
 export declare function parseHermes(filePath: string): SessionEvent[];
 /** Parse a Kimi session state.json file by reading its agents/main/wire.jsonl. */
 export declare function parseKimi(filePath: string): SessionEvent[];
+/**
+ * Parse a Droid (Factory) JSONL session file into normalized events. Droid
+ * wraps each turn in a `{type:'message', message:{role, content, modelId}}`
+ * envelope; the content blocks are Anthropic-shaped (text/thinking/tool_use/
+ * tool_result), so block handling mirrors the Claude parser.
+ */
+export declare function parseDroid(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)
@@ -109,6 +114,9 @@ export function parseSession(filePath, agent) {
         case 'kimi':
             events = parseKimi(filePath);
             break;
+        case 'droid':
+            events = parseDroid(filePath);
+            break;
     }
     // Chokepoint: every string field that originated in an untrusted session
     // file gets stripped of terminal escapes here, so renderers downstream can
@@ -133,6 +141,8 @@ export function detectAgent(filePath) {
         return 'hermes';
     if (filePath.includes('/.kimi-code/') || filePath.includes('\\.kimi-code\\'))
         return 'kimi';
+    if (filePath.includes('/.factory/') || filePath.includes('\\.factory\\'))
+        return 'droid';
     // Cloud convention: cloud-sessions/<id>/session.<format>.jsonl
     const cloudMatch = filePath.match(/session\.(claude|codex|rush)\.jsonl(?:$|[?#])/);
     if (cloudMatch)
@@ -209,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
@@ -398,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
@@ -1124,3 +1149,108 @@ export function parseKimi(filePath) {
     }
     return events;
 }
+// ---------------------------------------------------------------------------
+// Droid (Factory) parser
+// ---------------------------------------------------------------------------
+/**
+ * Parse a Droid (Factory) JSONL session file into normalized events. Droid
+ * wraps each turn in a `{type:'message', message:{role, content, modelId}}`
+ * envelope; the content blocks are Anthropic-shaped (text/thinking/tool_use/
+ * tool_result), so block handling mirrors the Claude parser.
+ */
+export function parseDroid(filePath) {
+    const content = safeReadSessionFile(filePath);
+    const lines = content.split('\n').filter(l => l.trim());
+    const events = [];
+    // Map tool_use id -> {tool, args} for correlating with tool_result.
+    const toolUseMap = new Map();
+    for (const line of lines) {
+        let raw;
+        try {
+            raw = JSON.parse(line);
+        }
+        catch {
+            continue;
+        }
+        if (raw.type !== 'message')
+            continue;
+        const message = raw.message || {};
+        const role = message.role === 'user' ? 'user' : 'assistant';
+        const timestamp = raw.timestamp || new Date().toISOString();
+        const blocks = message.content;
+        // Plain-string content (rare) renders as a single message.
+        if (typeof blocks === 'string') {
+            const text = blocks.trim();
+            if (text)
+                events.push({ type: 'message', agent: 'droid', timestamp, role, content: text });
+            continue;
+        }
+        if (!Array.isArray(blocks))
+            continue;
+        for (const block of blocks) {
+            if (block.type === 'text') {
+                const text = (block.text || '').trim();
+                // Skip injected context blocks (date, skills list) on the first user turn.
+                if (text && !(role === 'user' && text.startsWith('<system-reminder>'))) {
+                    events.push({ type: 'message', agent: 'droid', timestamp, role, content: text });
+                }
+            }
+            else if (block.type === 'thinking') {
+                const thinkingText = (block.thinking || '').trim();
+                if (thinkingText)
+                    events.push({ type: 'thinking', agent: 'droid', timestamp, content: thinkingText });
+            }
+            else if (block.type === 'tool_use') {
+                const toolName = block.name || 'unknown';
+                const toolInput = block.input || {};
+                if (block.id)
+                    toolUseMap.set(block.id, { tool: toolName, args: toolInput });
+                events.push({
+                    type: 'tool_use',
+                    agent: 'droid',
+                    timestamp,
+                    tool: toolName,
+                    args: toolInput,
+                    path: toolInput.file_path || toolInput.path || undefined,
+                    command: toolName === 'Bash' ? toolInput.command : undefined,
+                });
+            }
+            else if (block.type === 'tool_result') {
+                const toolId = block.tool_use_id;
+                const toolInfo = toolId ? toolUseMap.get(toolId) : undefined;
+                const isError = block.is_error === true;
+                let output = '';
+                if (typeof block.content === 'string') {
+                    output = block.content;
+                }
+                else if (Array.isArray(block.content)) {
+                    output = block.content
+                        .filter((c) => c.type === 'text')
+                        .map((c) => c.text || '')
+                        .join('\n');
+                }
+                if (isError) {
+                    events.push({ type: 'error', agent: 'droid', timestamp, tool: toolInfo?.tool, content: output || 'Tool execution failed' });
+                }
+                else {
+                    events.push({
+                        type: 'tool_result',
+                        agent: 'droid',
+                        timestamp,
+                        tool: toolInfo?.tool,
+                        success: true,
+                        output: output.length > 500 ? output.slice(0, 497) + '...' : output,
+                    });
+                }
+                if (toolId)
+                    toolUseMap.delete(toolId);
+            }
+            else if (block.type === 'image') {
+                const source = block.source || {};
+                const sizeBytes = source.type === 'base64' ? Math.ceil((source.data?.length || 0) * 0.75) : 0;
+                events.push({ type: 'attachment', agent: 'droid', timestamp, mediaType: source.media_type || 'image/png', sizeBytes });
+            }
+        }
+    }
+    return events;
+}

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) {