@phnx-labs/agents-cli 1.20.87 → 1.20.89

package/dist/lib/secrets/rc-hygiene.d.ts

@@ -47,9 +47,3 @@ export declare function scanRcExports(basename: string, content: string): RcSecr
  * unreadable files are skipped silently — an advisory, not a hard requirement.
  */
 export declare function scanUserRcFiles(homeDir?: string): RcSecretFinding[];
-/**
- * Build the advisory lines for `agents doctor` from a set of findings. Returns
- * `[]` when there is nothing to report. The first line is the headline; the
- * rest are indented detail. Names only — never values.
- */
-export declare function rcSecretWarningLines(findings: RcSecretFinding[]): string[];

package/dist/lib/secrets/rc-hygiene.js

@@ -128,27 +128,3 @@ export function scanUserRcFiles(homeDir = os.homedir()) {
     }
     return out;
 }
-/**
- * Build the advisory lines for `agents doctor` from a set of findings. Returns
- * `[]` when there is nothing to report. The first line is the headline; the
- * rest are indented detail. Names only — never values.
- */
-export function rcSecretWarningLines(findings) {
-    if (findings.length === 0)
-        return [];
-    const lines = [];
-    const master = findings.filter((f) => f.isMasterPassphrase);
-    const others = findings.filter((f) => !f.isMasterPassphrase);
-    const total = findings.length;
-    lines.push(`${total} credential-shaped export${total === 1 ? '' : 's'} found in shell rc files — ` +
-        `readable from /proc/<pid>/environ by any same-user process.`);
-    for (const f of master) {
-        lines.push(`${f.file}:${f.line} ${f.name} — the file-store master key. Move it off-env to ` +
-            `~/.agents/.secrets-key/passphrase (chmod 600) and delete the export.`);
-    }
-    for (const f of others) {
-        lines.push(`${f.file}:${f.line} ${f.name} — move to \`agents secrets\` and inject via \`agents secrets exec\`.`);
-    }
-    lines.push('Rule: no credentials in env vars or shell config. Use the keychain-backed store.');
-    return lines;
-}

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

@@ -298,7 +298,7 @@ export declare function sessionFileTimes(sessionFile: string | undefined): {
 export declare function lifecycleStatus(pidAlive: boolean, mtimeMs: number | undefined, nowMs?: number): ActiveStatus | undefined;
 /**
  * The ONE place a fallback status is decided when no rich transcript state is
- * available — an opaque kind we cannot parse (cursor, openclaw), or a transcript
+ * available — an opaque kind we cannot parse (openclaw), or a transcript
  * whose parse/tail was empty or unreadable. Honest by construction: computed from
  * PID + mtime, never a fabricated `idle`.
  *
@@ -316,13 +316,13 @@ export declare function resolveFallbackStatus(sessionFile: string | undefined, p
  * Locate the live transcript for an agent process. Claude files are keyed by cwd
  * (+ optional session uuid), so they resolve straight off disk. Every OTHER
  * tracked harness — Codex (date-partitioned), plus grok / droid / rush / gemini /
- * kimi / hermes / opencode / antigravity (per-session dirs, SQLite, single-JSON)
+ * kimi / hermes / opencode / antigravity / cursor (per-session dirs, SQLite, single-JSON)
  * — is resolved through the session index by cwd: the newest indexed transcript
  * for that cwd, bounded by ACTIVE_SESSION_STALE_MS so a live pid never borrows a
  * weeks-old transcript. This is what lets a live NON-claude/codex agent get a real
  * status instead of falling through to `unknown` (the file feeds
- * {@link computeLiveSignals}). An opaque kind we don't track (cursor) still yields
- * undefined here and degrades honestly to a live `running`.
+ * {@link computeLiveSignals}). An opaque kind we don't track still yields undefined
+ * here and degrades honestly to a live `running`.
  */
 export declare function findSessionFileForKind(kind: string, cwd?: string, sessionId?: string): string | undefined;
 /** Live per-session signals derived from one transcript-tail read. */
@@ -339,10 +339,10 @@ interface LiveSignals {
  * Claude/Codex take the fast bounded byte-tail ({@link readSessionTailWithRaw}) —
  * the hot path, and the only two that also yield throughput (their raw lines
  * carry usage the event model drops). EVERY OTHER tracked harness (grok, droid,
- * rush, gemini, kimi, hermes, opencode, antigravity) is parsed with its own
+ * rush, gemini, kimi, hermes, opencode, antigravity, cursor) is parsed with its own
  * parser and run through the SAME {@link inferSessionState}, so a live
  * non-claude/codex agent gets a real working/waiting/idle instead of the blanket
- * `unknown` it used to fall through to. An opaque/untracked kind (cursor) or an
+ * `unknown` it used to fall through to. An opaque/untracked kind or an
  * unreadable/empty transcript yields an empty signal set, and the caller's
  * {@link resolveFallbackStatus} reports the honest live floor (`running`).
  */

package/dist/lib/session/active.js

@@ -358,7 +358,7 @@ export function lifecycleStatus(pidAlive, mtimeMs, nowMs = Date.now()) {
 }
 /**
  * The ONE place a fallback status is decided when no rich transcript state is
- * available — an opaque kind we cannot parse (cursor, openclaw), or a transcript
+ * available — an opaque kind we cannot parse (openclaw), or a transcript
  * whose parse/tail was empty or unreadable. Honest by construction: computed from
  * PID + mtime, never a fabricated `idle`.
  *
@@ -379,13 +379,13 @@ export function resolveFallbackStatus(sessionFile, pidAlive, nowMs = Date.now())
  * Locate the live transcript for an agent process. Claude files are keyed by cwd
  * (+ optional session uuid), so they resolve straight off disk. Every OTHER
  * tracked harness — Codex (date-partitioned), plus grok / droid / rush / gemini /
- * kimi / hermes / opencode / antigravity (per-session dirs, SQLite, single-JSON)
+ * kimi / hermes / opencode / antigravity / cursor (per-session dirs, SQLite, single-JSON)
  * — is resolved through the session index by cwd: the newest indexed transcript
  * for that cwd, bounded by ACTIVE_SESSION_STALE_MS so a live pid never borrows a
  * weeks-old transcript. This is what lets a live NON-claude/codex agent get a real
  * status instead of falling through to `unknown` (the file feeds
- * {@link computeLiveSignals}). An opaque kind we don't track (cursor) still yields
- * undefined here and degrades honestly to a live `running`.
+ * {@link computeLiveSignals}). An opaque kind we don't track still yields undefined
+ * here and degrades honestly to a live `running`.
  */
 export function findSessionFileForKind(kind, cwd, sessionId) {
     if (!cwd)
@@ -432,10 +432,10 @@ function parseTailEventsForKind(agent, sessionFile) {
  * Claude/Codex take the fast bounded byte-tail ({@link readSessionTailWithRaw}) —
  * the hot path, and the only two that also yield throughput (their raw lines
  * carry usage the event model drops). EVERY OTHER tracked harness (grok, droid,
- * rush, gemini, kimi, hermes, opencode, antigravity) is parsed with its own
+ * rush, gemini, kimi, hermes, opencode, antigravity, cursor) is parsed with its own
  * parser and run through the SAME {@link inferSessionState}, so a live
  * non-claude/codex agent gets a real working/waiting/idle instead of the blanket
- * `unknown` it used to fall through to. An opaque/untracked kind (cursor) or an
+ * `unknown` it used to fall through to. An opaque/untracked kind or an
  * unreadable/empty transcript yields an empty signal set, and the caller's
  * {@link resolveFallbackStatus} reports the honest live floor (`running`).
  */

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

@@ -622,6 +622,11 @@ export declare function __codexScanBranchCountsForTest(): {
 };
 /** Test seam: reset the Codex parse-branch counters to observe a scan from a clean slate. */
 export declare function __resetCodexScanBranchCountsForTest(): void;
+/** Parse one Cursor transcript and enrich it with the matching chat meta.json. */
+export declare function readCursorMeta(filePath: string, currentVersion?: string): {
+    meta: SessionMeta;
+    content: string;
+} | null;
 /** Parse a single Kimi session state.json file to extract session metadata. */
 export declare function readKimiMeta(filePath: string, priorRow?: {
     parserState: string | null;

package/dist/lib/session/discover.js

@@ -23,7 +23,7 @@ import { getConfigSymlinkVersion } from '../shims.js';
 import { SESSION_AGENTS } from './types.js';
 import { deriveShortId } from './short-id.js';
 import { extractSessionTopic } from './prompt.js';
-import { parseAntigravity } from './parse.js';
+import { parseAntigravity, parseCursor } from './parse.js';
 import { extractPrUrl, detectWorktree, detectTicket, isPrCreateCommand, detectSpawnedTeam, isTicketCreateTool, extractCreatedTicket, extractRecentDirectoriesTouched, extractTodoProgressFromEvents } from './state.js';
 import { costOfUsage } from '../pricing/index.js';
 import { machineForSessionFile } from './origin-machine.js';
@@ -221,6 +221,7 @@ function dispatchAgentScan(agent, onProgress) {
         case 'kimi': return scanKimiIncremental(onProgress);
         case 'droid': return scanDroidIncremental(onProgress);
         case 'grok': return scanGrokIncremental(onProgress);
+        case 'cursor': return scanCursorIncremental(onProgress);
         default: return Promise.resolve();
     }
 }
@@ -660,6 +661,7 @@ const SESSION_ROOT_SPECS = [
     { agent: 'droid', subdir: 'sessions' },
     { agent: 'kimi', subdir: 'sessions' },
     { agent: 'grok', subdir: 'sessions' },
+    { agent: 'cursor', subdir: 'projects' },
 ];
 function sessionRootSubdir(agent) {
     return SESSION_ROOT_SPECS.find((spec) => spec.agent === agent)?.subdir ?? null;
@@ -752,6 +754,13 @@ async function readRoutineArchiveMeta(agent, filePath) {
         const result = await readCodexMeta(filePath);
         return result ? { ...result, meta: decorateRoutineSession(result.meta, info) } : null;
     }
+    if (agent === 'cursor') {
+        // PR #1723 archives Cursor routine transcripts; preserve version resolution
+        // when this reader consumes those archives.
+        const currentVersion = await getCurrentAgentVersion('cursor');
+        const result = readCursorMeta(filePath, currentVersion);
+        return result ? { ...result, meta: decorateRoutineSession(result.meta, info) } : null;
+    }
     return null;
 }
 async function scanRoutineArchivesIncremental(agent, onProgress) {
@@ -3601,6 +3610,133 @@ function sumKnownNumbers(values) {
 // Time range parsing
 // ---------------------------------------------------------------------------
 // ---------------------------------------------------------------------------
+// Cursor
+// ---------------------------------------------------------------------------
+// Cursor writes the conversation to
+// projects/<encoded-cwd>/agent-transcripts/<uuid>/<uuid>.jsonl and metadata to
+// chats/<workspace-hash>/<uuid>/meta.json. Discovery deliberately starts from
+// transcripts, then joins metadata by UUID: chat directories with no transcript
+// are empty or abandoned sessions and must not become broken zero-event rows.
+// Routine archives may contain only the transcript; those remain browsable with
+// file timestamps and without guessed cwd/title metadata.
+/** Incrementally re-scan changed Cursor transcript files and upsert into the DB. */
+async function scanCursorIncremental(onProgress) {
+    const currentVersion = await getCurrentAgentVersion('cursor');
+    const prestat = [];
+    for (const projectsDir of getAgentSessionDirs('cursor', 'projects')) {
+        collectCursorTranscripts(projectsDir, prestat);
+    }
+    const changed = filterChangedEntries(prestat);
+    if (changed.length === 0)
+        return;
+    onProgress?.({ agent: 'cursor', 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 = readCursorMeta(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: 'cursor', parsed, total: changed.length });
+    }
+    upsertSessionsBatch(entries);
+    recordScans(touched);
+}
+function collectCursorTranscripts(projectsDir, out) {
+    let projectNames;
+    try {
+        projectNames = fs.readdirSync(projectsDir);
+    }
+    catch {
+        return;
+    }
+    for (const projectName of projectNames) {
+        const transcriptsDir = path.join(projectsDir, projectName, 'agent-transcripts');
+        for (const f of walkForFilesWithStat(transcriptsDir, '.jsonl', 100_000)) {
+            const sessionId = path.basename(path.dirname(f.path));
+            if (path.basename(f.path) !== `${sessionId}.jsonl`)
+                continue;
+            out.push({ filePath: f.path, fileMtimeMs: f.mtimeMs, fileSize: f.size });
+        }
+    }
+}
+function readCursorChatMeta(filePath, sessionId) {
+    const projectDir = path.dirname(path.dirname(path.dirname(filePath)));
+    const projectsDir = path.dirname(projectDir);
+    const chatsDir = path.join(path.dirname(projectsDir), 'chats');
+    let workspaceHashes;
+    try {
+        workspaceHashes = fs.readdirSync(chatsDir);
+    }
+    catch {
+        return undefined;
+    }
+    for (const workspaceHash of workspaceHashes) {
+        const metaPath = path.join(chatsDir, workspaceHash, sessionId, 'meta.json');
+        try {
+            return JSON.parse(fs.readFileSync(metaPath, 'utf-8'));
+        }
+        catch {
+            // This workspace hash does not own the session, or its metadata is unreadable.
+        }
+    }
+    return undefined;
+}
+/** Parse one Cursor transcript and enrich it with the matching chat meta.json. */
+export function readCursorMeta(filePath, currentVersion) {
+    const sessionId = path.basename(filePath).replace(/\.jsonl$/, '');
+    if (!sessionId || path.basename(path.dirname(filePath)) !== sessionId)
+        return null;
+    const events = parseCursor(filePath);
+    if (events.length === 0)
+        return null;
+    const chatMeta = readCursorChatMeta(filePath, sessionId);
+    const stat = safeStatSync(filePath);
+    const createdAtMs = typeof chatMeta?.createdAtMs === 'number' ? chatMeta.createdAtMs : undefined;
+    const updatedAtMs = typeof chatMeta?.updatedAtMs === 'number' ? chatMeta.updatedAtMs : undefined;
+    const timestamp = createdAtMs !== undefined
+        ? new Date(createdAtMs).toISOString()
+        : stat ? stat.mtime.toISOString() : new Date().toISOString();
+    const lastActivity = updatedAtMs !== undefined
+        ? new Date(updatedAtMs).toISOString()
+        : stat ? stat.mtime.toISOString() : timestamp;
+    const cwd = normalizeCwd(typeof chatMeta?.cwd === 'string' ? chatMeta.cwd : '');
+    const userTexts = events
+        .filter((event) => event.type === 'message' && event.role === 'user' && event.content)
+        .map((event) => event.content);
+    const firstUserText = userTexts[0];
+    const title = typeof chatMeta?.title === 'string' && chatMeta.title.trim()
+        ? chatMeta.title.trim()
+        : undefined;
+    const meta = {
+        id: sessionId,
+        shortId: deriveShortId(sessionId),
+        agent: 'cursor',
+        timestamp,
+        lastActivity,
+        project: cwd ? path.basename(cwd) : undefined,
+        cwd,
+        filePath,
+        version: resolveSessionVersion('cursor', filePath, undefined, currentVersion),
+        topic: firstUserText ? extractSessionTopic(firstUserText) : undefined,
+        label: title,
+        messageCount: events.filter((event) => event.type === 'message').length,
+    };
+    return { meta, content: userTexts.join('\n') };
+}
+// ---------------------------------------------------------------------------
 // Kimi
 // ---------------------------------------------------------------------------
 // Kimi stores sessions under ~/.kimi-code/sessions/<workdir_hash>/session_<uuid>/.

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

@@ -109,6 +109,8 @@ 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 Cursor's Anthropic-shaped message JSONL transcript. */
+export declare function parseCursor(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}}`

package/dist/lib/session/parse.js

@@ -154,6 +154,9 @@ export function parseSession(filePath, agent) {
         case 'droid':
             events = parseDroid(filePath);
             break;
+        case 'cursor':
+            events = parseCursor(filePath);
+            break;
     }
     // Chokepoint: every string field that originated in an untrusted session
     // file gets stripped of terminal escapes here, so renderers downstream can
@@ -194,6 +197,8 @@ export function detectAgent(filePath) {
         return 'kimi';
     if (filePath.includes('/.factory/') || filePath.includes('\\.factory\\'))
         return 'droid';
+    if (filePath.includes('/.cursor/') || filePath.includes('\\.cursor\\'))
+        return 'cursor';
     // Cloud convention: cloud-sessions/<id>/session.<format>.jsonl
     const cloudMatch = filePath.match(/session\.(claude|codex|rush)\.jsonl(?:$|[?#])/);
     if (cloudMatch)
@@ -1617,20 +1622,45 @@ export function parseKimi(filePath) {
     return events;
 }
 // ---------------------------------------------------------------------------
-// Droid (Factory) parser
+// Cursor and Droid (Factory) parsers
 // ---------------------------------------------------------------------------
+/** Parse Cursor's Anthropic-shaped message JSONL transcript. */
+export function parseCursor(filePath) {
+    return parseAnthropicMessageJsonl(filePath, 'cursor');
+}
 /**
- * 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.
+ * Cursor stamps the first user turn as
+ * `<timestamp>Sunday, Aug 2, 2026, 3:51 AM (UTC-7)</timestamp>` followed by the
+ * real question in `<user_query>`. `Date.parse` silently DISCARDS the `(UTC-7)`
+ * parenthetical and reads the rest as local time, so the offset has to be applied
+ * by hand — otherwise the recovered instant is wrong on every machine whose zone
+ * differs from the one that wrote the transcript.
  */
-export function parseDroid(filePath) {
+function parseCursorUserText(text) {
+    const query = text.match(/<user_query>\s*([\s\S]*?)\s*<\/user_query>/);
+    const stamp = text.match(/<timestamp>\s*([\s\S]*?)\s*<\/timestamp>/)?.[1]?.trim();
+    return { text: (query?.[1] ?? text).trim(), timestamp: parseCursorTimestamp(stamp) };
+}
+function parseCursorTimestamp(stamp) {
+    if (!stamp)
+        return undefined;
+    const offset = stamp.match(/\(UTC([+-])(\d{1,2})(?::(\d{2}))?\)/);
+    // Without a declared offset there is no instant to recover -- guessing the
+    // local zone would be worse than falling back to the file mtime.
+    if (!offset)
+        return undefined;
+    const wall = Date.parse(`${stamp.replace(/\s*\(UTC[^)]*\)\s*/, " ").trim()} UTC`);
+    if (Number.isNaN(wall))
+        return undefined;
+    const offsetMs = (Number(offset[2]) * 60 + Number(offset[3] ?? 0)) * 60_000;
+    return new Date(offset[1] === "-" ? wall + offsetMs : wall - offsetMs).toISOString();
+}
+function parseAnthropicMessageJsonl(filePath, agent) {
     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();
+    const fallbackTimestamp = fs.statSync(filePath).mtime.toISOString();
     for (const line of lines) {
         let raw;
         try {
@@ -1639,33 +1669,42 @@ export function parseDroid(filePath) {
         catch {
             continue;
         }
-        if (raw.type !== 'message')
+        if (raw.type === 'turn_ended' || (agent === 'droid' && raw.type !== 'message'))
             continue;
-        const message = raw.message || {};
-        const role = message.role === 'user' ? 'user' : 'assistant';
-        const timestamp = raw.timestamp || new Date().toISOString();
+        const message = raw.message;
+        const wireRole = agent === 'cursor' ? raw.role : message?.role;
+        if (!message || (agent === 'cursor' && !['user', 'assistant'].includes(wireRole)))
+            continue;
+        const role = wireRole === 'user' ? 'user' : 'assistant';
+        let timestamp = raw.timestamp || fallbackTimestamp;
         const blocks = message.content;
-        // Plain-string content (rare) renders as a single message.
         if (typeof blocks === 'string') {
-            const text = blocks.trim();
+            const parsed = agent === 'cursor' && role === 'user'
+                ? parseCursorUserText(blocks)
+                : { text: blocks.trim(), timestamp: undefined };
+            const text = parsed.text;
+            timestamp = parsed.timestamp || timestamp;
             if (text)
-                events.push({ type: 'message', agent: 'droid', timestamp, role, content: text });
+                events.push({ type: 'message', agent, 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.
+                const parsed = agent === 'cursor' && role === 'user'
+                    ? parseCursorUserText(block.text || '')
+                    : { text: (block.text || '').trim(), timestamp: undefined };
+                const text = parsed.text;
+                timestamp = parsed.timestamp || timestamp;
                 if (text && !(role === 'user' && text.startsWith('<system-reminder>'))) {
-                    events.push({ type: 'message', agent: 'droid', timestamp, role, content: text });
+                    events.push({ type: 'message', agent, 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 });
+                    events.push({ type: 'thinking', agent, timestamp, content: thinkingText });
             }
             else if (block.type === 'tool_use') {
                 const toolName = block.name || 'unknown';
@@ -1674,38 +1713,29 @@ export function parseDroid(filePath) {
                     toolUseMap.set(block.id, { tool: toolName, args: toolInput });
                 events.push({
                     type: 'tool_use',
-                    agent: 'droid',
+                    agent,
                     timestamp,
                     tool: toolName,
                     args: toolInput,
                     path: toolInput.file_path || toolInput.path || undefined,
-                    command: (toolName === 'Bash' || toolName === 'Execute') ? toolInput.command : undefined,
+                    command: (toolName === 'Bash' || toolName === 'Execute' || toolName === 'Shell') ? 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');
-                }
+                const output = typeof block.content === 'string'
+                    ? block.content
+                    : Array.isArray(block.content)
+                        ? 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' });
+                    events.push({ type: 'error', agent, timestamp, tool: toolInfo?.tool, content: output || 'Tool execution failed' });
                 }
                 else {
                     events.push({
-                        type: 'tool_result',
-                        agent: 'droid',
-                        timestamp,
-                        tool: toolInfo?.tool,
-                        success: true,
+                        type: 'tool_result', agent, timestamp, tool: toolInfo?.tool, success: true,
                         output: output.length > 500 ? output.slice(0, 497) + '...' : output,
                     });
                 }
@@ -1715,9 +1745,18 @@ export function parseDroid(filePath) {
             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(normalizedAttachmentEvent('droid', timestamp, block, source, 'image/png', sizeBytes));
+                events.push(normalizedAttachmentEvent(agent, timestamp, block, source, 'image/png', sizeBytes));
             }
         }
     }
     return events;
 }
+/**
+ * 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) {
+    return parseAnthropicMessageJsonl(filePath, 'droid');
+}

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

@@ -9,7 +9,10 @@ export declare const NO_FANOUT_ENV = "AGENTS_SESSIONS_LOCAL";
  * Parse a peer's `--active --json` stdout into active sessions, tagging each
  * with `machine`. Defensive against version skew / partial output: non-JSON or
  * a non-array yields `[]`, and non-object entries are dropped rather than
- * throwing. Exported for unit testing without a live tailnet.
+ * throwing. `viewingIn` arrives as a display string from a current peer and as
+ * an `{app, tab}` object from one that predates the flattening, so it is
+ * normalized here — the single boundary where a foreign row becomes internal.
+ * Exported for unit testing without a live tailnet.
  */
 export declare function parseRemoteActive(stdout: string, machine: string): ActiveSession[];
 export interface RemoteActiveResult {

package/dist/lib/session/remote-active.js

@@ -15,6 +15,7 @@
  * `spawn`, not the sync `sshExec`) so N peers cost one round-trip, not N.
  */
 import { gatherRemoteAgentsJson } from '../remote-agents-json.js';
+import { parseViewingIn } from './viewing-in.js';
 /**
  * Recursion guard, passed as an env var (not a CLI flag) so an OLDER remote
  * `agents` that predates this feature ignores it harmlessly instead of erroring
@@ -25,7 +26,10 @@ export const NO_FANOUT_ENV = 'AGENTS_SESSIONS_LOCAL';
  * Parse a peer's `--active --json` stdout into active sessions, tagging each
  * with `machine`. Defensive against version skew / partial output: non-JSON or
  * a non-array yields `[]`, and non-object entries are dropped rather than
- * throwing. Exported for unit testing without a live tailnet.
+ * throwing. `viewingIn` arrives as a display string from a current peer and as
+ * an `{app, tab}` object from one that predates the flattening, so it is
+ * normalized here — the single boundary where a foreign row becomes internal.
+ * Exported for unit testing without a live tailnet.
  */
 export function parseRemoteActive(stdout, machine) {
     let parsed;
@@ -40,7 +44,9 @@ export function parseRemoteActive(stdout, machine) {
     const out = [];
     for (const x of parsed) {
         if (x && typeof x === 'object' && !Array.isArray(x)) {
-            out.push({ ...x, machine });
+            const row = { ...x, machine };
+            row.viewingIn = parseViewingIn(x.viewingIn);
+            out.push(row);
         }
     }
     return out;

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

@@ -7,7 +7,7 @@
  * speaks these types.
  */
 /** Agents that store session data on disk and can be discovered by `agents sessions`. */
-export type SessionAgentId = 'claude' | 'codex' | 'gemini' | 'antigravity' | 'opencode' | 'openclaw' | 'rush' | 'hermes' | 'grok' | 'kimi' | 'droid';
+export type SessionAgentId = 'claude' | 'codex' | 'gemini' | 'antigravity' | 'opencode' | 'openclaw' | 'rush' | 'hermes' | 'grok' | 'kimi' | 'droid' | 'cursor';
 /** All agents with session discovery support, in display order. */
 export declare const SESSION_AGENTS: SessionAgentId[];
 /**

package/dist/lib/session/types.js

@@ -7,7 +7,7 @@
  * speaks these types.
  */
 /** All agents with session discovery support, in display order. */
-export const SESSION_AGENTS = ['claude', 'codex', 'gemini', 'antigravity', 'opencode', 'openclaw', 'rush', 'hermes', 'grok', 'kimi', 'droid'];
+export const SESSION_AGENTS = ['claude', 'codex', 'gemini', 'antigravity', 'opencode', 'openclaw', 'rush', 'hermes', 'grok', 'kimi', 'droid', 'cursor'];
 /**
  * True when `agent` stores session data `agents sessions` can discover (a member
  * of {@link SESSION_AGENTS}). The single predicate every session-index writer

package/dist/lib/session/viewing-in.d.ts

@@ -27,6 +27,37 @@ export interface ViewingIn {
     /** 1-based tab number within that app, when it can be resolved. */
     tab?: number;
 }
+/**
+ * The one display form of "where is this session being watched" — `'codium tab 3'`
+ * when a client is attached, the bare app name when the tab can't be resolved, and
+ * `'detached'` when the pane is live but nobody is looking at it (the terminal that
+ * displayed it was closed or crashed).
+ *
+ * `undefined` means **we do not know**, and it covers two different situations that
+ * must not be confused with `'detached'`: a session that isn't tmux-hosted (no pane
+ * to attach to, so it isn't on this axis at all), and a tmux session whose pane the
+ * locator could not resolve (`mapPanesToTargets` returned nothing for this socket,
+ * or the row was never enriched). {@link resolveViewingIn} answers `undefined` for
+ * BOTH "no client attached" and "could not locate the pane", so the pane's resolved
+ * `tmuxTarget` is what separates them: without it there is no evidence of absence,
+ * only absence of evidence. Claiming `'detached'` there would invent an orphaned
+ * session — and a consumer acts on that claim (Factory's picker pre-ticks every
+ * detached row for rescue), so the wrong answer resumes a session nobody asked for.
+ *
+ * Shared by the `--active` row renderer and the `--json` serializer so a machine
+ * consumer reads exactly the string a human sees, instead of re-deriving "detached"
+ * from an absent field.
+ */
+export declare function viewingInLabel(s: Pick<ActiveSession, 'provenance' | 'viewingIn' | 'tmuxTarget'>): string | undefined;
+/**
+ * Wire form -> internal form for a row arriving from another machine's
+ * `--active --json`. The fan-out reaches peers whose CLI may predate
+ * {@link viewingInLabel} and still emit the `{app, tab}` object, so this boundary
+ * normalizes both shapes into one — the ONLY place either shape is accepted.
+ * `'detached'` maps to undefined, which is what "no attached client" means
+ * internally; {@link viewingInLabel} regenerates the word from the pane.
+ */
+export declare function parseViewingIn(raw: unknown): ViewingIn | undefined;
 /** Injection seams so `resolveViewingIn` is unit-testable without a live tmux/ps/osascript. */
 export interface ViewingInDeps {
     /** Ghostty surfaces (window/tab/cwd/title). Enumerated once by the caller and shared. */