@phnx-labs/agents-cli 1.20.87 → 1.20.88

package/dist/lib/sandbox.js

@@ -100,11 +100,49 @@ export function prepareJobHome(config) {
     else if (config.agent === 'gemini') {
         generateGeminiConfig(overlayHome, config);
     }
+    else if (config.agent === 'cursor') {
+        generateCursorConfig(overlayHome);
+    }
     if (config.allow?.dirs) {
         symlinkAllowedDirs(overlayHome, config.allow.dirs);
     }
     return overlayHome;
 }
+/** Link this host's Cursor login and CLI config into the disposable overlay. */
+export function generateCursorConfig(overlayHome) {
+    const realConfigHome = process.env.XDG_CONFIG_HOME || path.join(resolveRealHome(), '.config');
+    const realAuth = path.join(realConfigHome, 'cursor', 'auth.json');
+    if (!fs.existsSync(realAuth))
+        return;
+    const overlayCursorDir = path.join(overlayHome, '.config', 'cursor');
+    fs.mkdirSync(overlayCursorDir, { recursive: true });
+    const overlayAuth = path.join(overlayCursorDir, 'auth.json');
+    if (process.platform === 'win32') {
+        // File symlinks need Developer Mode on Windows. A same-volume hard link
+        // shares the credential inode without copying its contents to another host.
+        try {
+            fs.linkSync(realAuth, overlayAuth);
+        }
+        catch { /* cross-volume or link creation refused: Cursor will fail auth loudly */ }
+    }
+    else {
+        fs.symlinkSync(realAuth, overlayAuth);
+    }
+    // Setting XDG_CONFIG_HOME makes Cursor look for cli-config.json beside auth.json.
+    // This file carries account identity (authId, displayName, email, userId) as
+    // well as preferences, so it must remain linked rather than copied.
+    const realCliConfig = path.join(resolveRealHome(), '.cursor', 'cli-config.json');
+    if (fs.existsSync(realCliConfig)) {
+        const overlayCliConfig = path.join(overlayCursorDir, 'cli-config.json');
+        try {
+            if (process.platform === 'win32')
+                fs.linkSync(realCliConfig, overlayCliConfig);
+            else
+                fs.symlinkSync(realCliConfig, overlayCliConfig);
+        }
+        catch { /* cross-volume or link creation refused: Cursor will fail auth loudly */ }
+    }
+}
 /** Remove a job's overlay HOME directory entirely. */
 export function cleanJobHome(name) {
     const overlayHome = getJobHomePath(name);

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/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/staleness/detectors/commands.js

@@ -1,13 +1,14 @@
 /**
- * Commands detector — mirrors versions.ts:343-357. Inspects the version home,
+ * Commands detector — mirrors the command dispatch in versions.ts. Inspects the version home,
  * returns command names. Honors the commands-as-skills marker for skills-only
- * agents (kimi, Codex >= 0.117.0, …); falls back to scanning
- * `{agentDir}/<commandsSubdir>/` for the native path.
+ * agents (Kimi, Codex >= 0.117.0, …), treats the native file as authoritative
+ * for dual-write targets (the skill copy is deliberately absent on a name
+ * collision), and scans `{agentDir}/<commandsSubdir>/` for native-only targets.
  */
 import * as fs from 'fs';
 import * as path from 'path';
 import { AGENTS, MANAGED_AGENT_IDS, agentConfigDirName } from '../../agents.js';
-import { shouldInstallCommandAsSkill, listCommandSkillsInVersion } from '../../command-skills.js';
+import { listCommandSkillsInVersion, shouldInstallCommandAsSkill, } from '../../command-skills.js';
 import { lazyAgentMap } from '../writers/lazy-map.js';
 function buildCommandsDetector(agent) {
     return {
@@ -23,9 +24,17 @@ function buildCommandsDetector(agent) {
             if (!fs.existsSync(commandsDir))
                 return [];
             const ext = agentConfig.format === 'toml' ? '.toml' : '.md';
-            return fs.readdirSync(commandsDir)
+            const nativeCommands = fs.readdirSync(commandsDir)
                 .filter(f => f.endsWith(ext))
                 .map(f => f.replace(new RegExp(`\\${ext}$`), ''));
+            // For a dual-write target the native file is the authoritative record that
+            // the command synced. The skill copy is derived, and
+            // installCommandSkillToVersion deliberately writes none when a real skill
+            // source already owns the name -- requiring both copies reported those
+            // commands missing forever and drove an `agents refresh` loop no sync could
+            // clear. This also matches `agents doctor`/`prune`, which read the
+            // unfiltered listCommandsInVersionHome.
+            return nativeCommands;
         },
     };
 }

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

@@ -44,6 +44,8 @@ export interface SyncManifest {
     v: typeof MANIFEST_VERSION;
     syncedAt: string;
     commands: Record<string, FileEntry>;
+    /** Command names the version writer emitted during the preceding full sync. */
+    writtenCommands?: string[];
     skills: Record<string, DirEntry>;
     hooks: Record<string, FileEntry>;
     rules: RulesEntry;