orquesta-agent 0.2.234 → 0.2.238

package/dist/executor.js

@@ -122,11 +122,12 @@ import * as logger from './logger.js';
 // interactive-session spawn — node-pty can't launch the `.cmd` shim).
 const nodeRequire = createRequire(import.meta.url);
 import { isSandboxAvailable, buildBwrapArgs, shQuote, ensureStrictProjectDirs, encodeClaudeProjectDir } from './sandbox.js';
+import { isLoggedOutMessage } from './cli-auth-detect.js';
 import { parseCoordSpec, runCoordination } from './coordination.js';
 import { parseSudosudoInstallSpec, runSudosudoInstall } from './sudosudo.js';
 import { sendOutput, sendComplete, sendError, sendSupervisionRequest, sendExecutionResumed, updatePromptStatus, persistOutputLogs, clearOutputBuffer, sendRequirement, persistRequirement, sendQAInstructions, persistQAInstructions, sendPlanItemsGenerated, sendSessionOutput, sendSessionStarted, sendSessionEnded, sendSessionError, sendSessionLog, reportAgentError } from './supabase.js';
 import { startTranscriptTail } from './claude-transcript.js';
-import { createThinkingLog, createToolCallLog, createToolResultLog, createOutputLog, createErrorLog, createSystemLog, } from './types/agent-logs.js';
+import { createThinkingLog, createToolCallLog, createToolResultLog, createOutputLog, createErrorLog, createSystemLog, createProgressLog, } from './types/agent-logs.js';
 /**
  * Build args for the `script` PTY wrapper, accounting for BSD vs util-linux differences.
  * - util-linux (Linux):  `script -q -c "<cmd>" /dev/null`
@@ -874,6 +875,101 @@ export function resolveKimiBinary() {
 export function isKimiCliAvailable() {
     return resolveKimiBinary() !== null;
 }
+// Resolve Cursor's headless CLI (`cursor-agent`). Its installer
+// (`curl https://cursor.com/install -fsS | bash`) drops the binary in
+// ~/.local/bin and only PRINTS a reminder to add that to PATH — so on a machine
+// where the user never edited their shell profile, a bare `cursor-agent` lookup
+// fails while the CLI is in fact installed. Same trap as kimi.
+// Order: CURSOR_AGENT_PATH → on PATH → ~/.local/bin/cursor-agent.
+// On Windows the PowerShell installer does put it on PATH, so the PATH probe is
+// the working path there.
+let cursorBinaryCache = null;
+export function resolveCursorBinary() {
+    const now = Date.now();
+    if (cursorBinaryCache && now - cursorBinaryCache.at < CLI_DETECTION_TTL_MS)
+        return cursorBinaryCache.path;
+    let resolved = null;
+    const envPath = process.env.CURSOR_AGENT_PATH;
+    if (envPath) {
+        try {
+            fs.accessSync(envPath, fs.constants.X_OK);
+            resolved = envPath;
+        }
+        catch { /* bad override */ }
+    }
+    if (!resolved) {
+        try {
+            execSync('cursor-agent --version', { stdio: 'pipe', timeout: 15000 });
+            resolved = 'cursor-agent';
+        }
+        catch { /* not on PATH */ }
+    }
+    if (!resolved) {
+        const candidate = path.join(os.homedir(), '.local', 'bin', 'cursor-agent');
+        try {
+            fs.accessSync(candidate, fs.constants.X_OK);
+            resolved = candidate;
+        }
+        catch { /* not installed there */ }
+    }
+    cursorBinaryCache = { path: resolved, at: now };
+    return resolved;
+}
+// Cursor CLI (the `cursor-agent` binary). Authenticated separately with
+// `cursor-agent login` against the user's own Cursor subscription — Orquesta
+// never sees that credential.
+export function isCursorCliAvailable() {
+    return resolveCursorBinary() !== null;
+}
+// Is cursor-agent actually LOGGED IN, not just installed?
+//
+// Installed-but-logged-out is a real state and used to be invisible: the agent
+// reported `authenticated: available`, so the dashboard showed a green tick, the
+// user pinned Cursor, and every prompt failed at execution with cursor's own
+// auth error. `cursor-agent status` is the documented way to ask.
+//
+// Deliberately conservative: it reports NOT authenticated only when cursor says
+// so in words. Any other outcome (an older build with no `status` subcommand, a
+// timeout, an unparseable answer) reports authenticated with a null method —
+// crying wolf on a working machine is worse than the tick we had before, and
+// nothing about EXECUTION depends on this flag; selectCli() still keys purely on
+// the binary existing.
+let cursorAuthCache = null;
+export function checkCursorAuth() {
+    const now = Date.now();
+    if (cursorAuthCache && now - cursorAuthCache.at < CLI_DETECTION_TTL_MS)
+        return cursorAuthCache.result;
+    const cache = (result) => {
+        cursorAuthCache = { result, at: now };
+        return result;
+    };
+    const binary = resolveCursorBinary();
+    if (!binary)
+        return cache({ available: false, authenticated: false, method: null });
+    // An API key in the environment authenticates cursor-agent on its own, and is
+    // what CI machines use — no point spawning a process to confirm it.
+    if (process.env.CURSOR_API_KEY)
+        return cache({ available: true, authenticated: true, method: 'api_key' });
+    try {
+        const out = execSync(`"${binary}" status`, {
+            stdio: ['ignore', 'pipe', 'pipe'],
+            timeout: 15000,
+            encoding: 'utf-8',
+        });
+        if (isLoggedOutMessage(out))
+            return cache({ available: true, authenticated: false, method: null });
+        return cache({ available: true, authenticated: true, method: 'subscription' });
+    }
+    catch (error) {
+        // Non-zero exit covers both "logged out" and "this build has no `status`",
+        // so the OUTPUT decides, not the exit code.
+        const err = error;
+        const combined = `${err.stdout ?? ''}${err.stderr ?? ''}`;
+        if (isLoggedOutMessage(combined))
+            return cache({ available: true, authenticated: false, method: null });
+        return cache({ available: true, authenticated: true, method: null });
+    }
+}
 // Dedupe the fallback warning: selectCli() runs on every heartbeat (the agent
 // reports activeCli), so logging unconditionally spammed thousands of identical
 // WARN lines. Only log when the message actually changes.
@@ -884,53 +980,48 @@ function warnCliOnce(msg) {
     lastCliWarn = msg;
     logger.warn(msg);
 }
+// Preference order when nothing is pinned, and the order a fallback walks when
+// the pinned CLI turns out not to be installed. Table-driven rather than a nest
+// of pairwise ifs: every CLI added here otherwise costs another N branches, and
+// the pair that got missed is exactly how a preference silently no-ops.
+const CLI_AUTO_ORDER = ['orquesta', 'claude', 'kimi', 'cursor'];
+const CLI_AUTO_REASON = {
+    orquesta: 'Auto: orquesta available (local LLM)',
+    claude: 'Auto: claude available (Anthropic API)',
+    kimi: 'Auto: kimi available',
+    cursor: 'Auto: cursor-agent available',
+};
 // Select which CLI to use based on availability and preference
 export function selectCli() {
-    const hasOrquesta = isOrquestaCliAvailable();
-    const hasClaude = isClaudeCliAvailable();
-    const hasKimi = isKimiCliAvailable();
-    // If none available, return null
-    if (!hasOrquesta && !hasClaude && !hasKimi) {
-        return { cli: null, reason: 'No CLI found (orquesta, claude, kimi)' };
+    const available = {
+        orquesta: isOrquestaCliAvailable(),
+        claude: isClaudeCliAvailable(),
+        kimi: isKimiCliAvailable(),
+        cursor: isCursorCliAvailable(),
+    };
+    if (!CLI_AUTO_ORDER.some(cli => available[cli])) {
+        return { cli: null, reason: `No CLI found (${CLI_AUTO_ORDER.join(', ')})` };
     }
+    const preferred = globalCliPreference;
     // Explicit preference, available → use it.
-    if (globalCliPreference === 'orquesta' && hasOrquesta)
-        return { cli: 'orquesta', reason: 'User preference: orquesta' };
-    if (globalCliPreference === 'claude' && hasClaude)
-        return { cli: 'claude', reason: 'User preference: claude' };
-    if (globalCliPreference === 'kimi' && hasKimi)
-        return { cli: 'kimi', reason: 'User preference: kimi' };
-    // Explicit preference, NOT available → warn once + fall back (orquesta → claude → kimi).
-    if (globalCliPreference === 'kimi' && !hasKimi) {
-        warnCliOnce('Kimi CLI preferred but not available, falling back');
-        if (hasOrquesta)
-            return { cli: 'orquesta', reason: 'Fallback: kimi not available' };
-        if (hasClaude)
-            return { cli: 'claude', reason: 'Fallback: kimi not available' };
-    }
-    if (globalCliPreference === 'orquesta' && !hasOrquesta) {
-        warnCliOnce('Orquesta CLI preferred but not available, falling back');
-        if (hasClaude)
-            return { cli: 'claude', reason: 'Fallback: orquesta not available' };
-        if (hasKimi)
-            return { cli: 'kimi', reason: 'Fallback: orquesta not available' };
-    }
-    if (globalCliPreference === 'claude' && !hasClaude) {
-        warnCliOnce('Claude CLI preferred but not available, falling back');
-        if (hasOrquesta)
-            return { cli: 'orquesta', reason: 'Fallback: claude not available' };
-        if (hasKimi)
-            return { cli: 'kimi', reason: 'Fallback: claude not available' };
-    }
-    // Auto mode: prefer orquesta → claude → kimi.
-    if (hasOrquesta) {
+    if (preferred !== 'auto' && available[preferred]) {
+        lastCliWarn = null;
+        return { cli: preferred, reason: `User preference: ${preferred}` };
+    }
+    // Explicit preference, NOT available → warn once, then fall through to the
+    // auto order skipping the one that isn't there.
+    if (preferred !== 'auto') {
+        warnCliOnce(`${preferred} CLI preferred but not available, falling back`);
+        const fallback = CLI_AUTO_ORDER.find(cli => cli !== preferred && available[cli]);
+        if (fallback)
+            return { cli: fallback, reason: `Fallback: ${preferred} not available` };
+        return { cli: null, reason: 'No CLI found' };
+    }
+    const auto = CLI_AUTO_ORDER.find(cli => available[cli]);
+    if (auto) {
         lastCliWarn = null;
-        return { cli: 'orquesta', reason: 'Auto: orquesta available (local LLM)' };
+        return { cli: auto, reason: CLI_AUTO_REASON[auto] };
     }
-    if (hasClaude)
-        return { cli: 'claude', reason: 'Auto: claude available (Anthropic API)' };
-    if (hasKimi)
-        return { cli: 'kimi', reason: 'Auto: kimi available' };
     return { cli: null, reason: 'No CLI found' };
 }
 // Check if Claude CLI is authenticated
@@ -1762,6 +1853,36 @@ export function getCurrentGitBranch(cwd) {
         return null;
     }
 }
+// Args for a file-editing tool, trimmed so the live stream can show WHAT
+// changed without carrying a whole file through the socket. Returns null for
+// anything that isn't a file edit — those args stay dropped when oversized.
+const EDIT_SIDE_CAP = 800;
+export function compactFileEditArgs(args) {
+    if (!args || typeof args !== 'object')
+        return null;
+    const a = args;
+    const path = a.file_path ?? a.filePath ?? a.path;
+    if (typeof path !== 'string' || !path)
+        return null;
+    const trim = (v) => {
+        if (typeof v !== 'string')
+            return undefined;
+        return v.length > EDIT_SIDE_CAP ? v.slice(0, EDIT_SIDE_CAP) + '\n…[truncated]' : v;
+    };
+    const out = { file_path: path };
+    const oldStr = trim(a.old_string ?? a.oldString);
+    const newStr = trim(a.new_string ?? a.newString ?? a.content);
+    if (oldStr !== undefined)
+        out.old_string = oldStr;
+    if (newStr !== undefined)
+        out.new_string = newStr;
+    if (typeof a.reason === 'string')
+        out.reason = a.reason.slice(0, 200);
+    // A bare path (read/list) carries no diff — not worth a payload.
+    if (oldStr === undefined && newStr === undefined)
+        return null;
+    return JSON.stringify(out, null, 2);
+}
 export async function execute(options) {
     const { commandId, promptId, content, workingDirectory, channel, permissionMode, attachments } = options;
     const startTime = Date.now();
@@ -1959,13 +2080,21 @@ ${userRequestBody}`;
         // (cliCommand stays the TYPE for flag decisions.)
         const cliBinary = cliCommand === 'kimi'
             ? (resolveKimiBinary() || 'kimi')
-            : cliCommand === 'claude'
-                ? (resolveClaudeBinary() || 'claude')
-                : (cliCommand || 'claude');
+            : cliCommand === 'cursor'
+                ? (resolveCursorBinary() || 'cursor-agent')
+                : cliCommand === 'claude'
+                    ? (resolveClaudeBinary() || 'claude')
+                    : (cliCommand || 'claude');
         const cwd = workingDirectory || process.cwd();
         // Which branch this prompt runs on — captured up front so it's persisted even
         // if the run fails, and broadcast live below once sendSpecialEvent exists.
         const currentBranch = getCurrentGitBranch(cwd);
+        // Last commit this run produced. Detected from the CLI's own output further
+        // down; it used to be broadcast live and then dropped on the floor, so a run
+        // that committed AND pushed still left prompts.git_commit_sha NULL and the UI
+        // had no way to link the change it just shipped.
+        let detectedCommitSha = null;
+        let detectedCommitUrl = null;
         logger.info(`CLI Selection: ${cliCommand} (${reason})`);
         logger.info(`Spawning: ${cliBinary} -p "${fullContent.slice(0, 50)}..." in ${cwd}${currentBranch ? ` on branch ${currentBranch}` : ''}`);
         // Hoist the static block into the CLI system prompt (claude/orquesta support
@@ -1974,7 +2103,9 @@ ${userRequestBody}`;
         // can never regress to a worse state than before.
         let promptContent = fullContent;
         let sysPromptFilePath = null;
-        if (cliCommand !== 'kimi') {
+        // kimi and cursor-agent have no --append-system-prompt-file, so their static
+        // context stays inline in the prompt.
+        if (cliCommand !== 'kimi' && cliCommand !== 'cursor') {
             try {
                 const promptDir = process.platform === 'win32'
                     ? os.tmpdir()
@@ -2001,15 +2132,28 @@ ${userRequestBody}`;
         // Orquesta CLI doesn't need special format flags - it outputs directly
         const baseFlags = cliCommand === 'orquesta'
             ? '--verbose' // Orquesta: simple verbose output
-            : cliCommand === 'kimi'
-                ? '--output-format text' // Kimi: plain text. NOTE: -p (one-shot) CANNOT be
-                // combined with -y ("Cannot combine --prompt with
-                // --yolo"), so dispatched kimi prompts respond as
-                // chat (no autonomous tool use). Interactive kimi
-                // sessions DO get -y (see ptyArgs below).
-                : '--verbose --output-format stream-json'; // Claude: stream-json format
-        // Kimi has no --dangerously-skip-permissions, and -p forbids -y.
-        const permFlags = cliCommand === 'kimi' ? '' : (mode === 'auto' ? '--dangerously-skip-permissions' : '');
+            : cliCommand === 'cursor'
+                ? '--output-format text' // Cursor: plain text. Its stream-json events are a
+                // different shape from Claude's, and parseStreamJson
+                // below only understands Claude's and orquesta-cli's,
+                // so asking for it would give us an unparseable
+                // stream instead of an answer.
+                : cliCommand === 'kimi'
+                    ? '--output-format text' // Kimi: plain text. NOTE: -p (one-shot) CANNOT be
+                    // combined with -y ("Cannot combine --prompt with
+                    // --yolo"), so dispatched kimi prompts respond as
+                    // chat (no autonomous tool use). Interactive kimi
+                    // sessions DO get -y (see ptyArgs below).
+                    : '--verbose --output-format stream-json'; // Claude: stream-json format
+        // Kimi has no --dangerously-skip-permissions, and -p forbids -y. Cursor spells
+        // the same thing --force (alias --yolo).
+        const permFlags = cliCommand === 'kimi'
+            ? ''
+            : mode !== 'auto'
+                ? ''
+                : cliCommand === 'cursor'
+                    ? '--force'
+                    : '--dangerously-skip-permissions';
         // Per-project endpoint override (orquesta CLI only). Single-quoted for the
         // shell-wrapped (Linux) path; pushed as a separate arg on Win/macOS below.
         const useEndpoint = cliCommand === 'orquesta' && !!globalCliEndpoint;
@@ -2130,6 +2274,13 @@ ${userRequestBody}`;
                             else if (action === 'failed') {
                                 output += `\n❌ Failed: ${title}\n`;
                             }
+                            // Persist the transition too. These used to be marker text ONLY, so a
+                            // replayed run had zero progress rows and rendered as a different run
+                            // than the one the user watched live (no plan, no checklist). `phase`
+                            // carries the action so a reader can rebuild the checklist state.
+                            if (action && title) {
+                                logs.push(createProgressLog(String(title), undefined, action === 'failed' ? 'error' : 'info', promptId, undefined, undefined, String(action)));
+                            }
                         }
                         else if (json.event === 'tool_call') {
                             const { tool, args } = json.data;
@@ -2138,6 +2289,15 @@ ${userRequestBody}`;
                             if (argsStr.length < 500) {
                                 output += `${argsStr}\n`;
                             }
+                            else {
+                                // A file edit is the one thing the user actually wants to SEE, and
+                                // its args are almost always over the cap (old+new string), so the
+                                // live stream showed nothing while the DB row had the whole diff.
+                                // Emit a trimmed edit payload instead of dropping it entirely.
+                                const compact = compactFileEditArgs(args);
+                                if (compact)
+                                    output += `${compact}\n`;
+                            }
                             logs.push(createToolCallLog(tool, args, 'info', promptId));
                             currentToolName = tool;
                         }
@@ -2448,6 +2608,8 @@ ${userRequestBody}`;
                     catch {
                         // Ignore errors getting git remote
                     }
+                    detectedCommitSha = commitMatch[1];
+                    detectedCommitUrl = commitUrl;
                     sendSpecialEvent('git_commit', {
                         commitSha: commitMatch[1],
                         message: commitMatch[2] || '',
@@ -2628,15 +2790,25 @@ ${userRequestBody}`;
                 // Record WHICH CLI + model executed it (timeline/history). Model is
                 // best-effort — the CLI/proxy pick the true upstream model internally
                 // (batuta-auto fans out per prompt), so we report the CLI's MODEL CONFIG:
-                const cliTypeForDb = cliCommand === 'orquesta' ? 'orquesta-cli' : cliCommand === 'kimi' ? 'kimi-cli' : 'claude-cli';
+                const cliTypeForDb = cliCommand === 'orquesta'
+                    ? 'orquesta-cli'
+                    : cliCommand === 'kimi'
+                        ? 'kimi-cli'
+                        : cliCommand === 'cursor'
+                            ? 'cursor-cli'
+                            : 'claude-cli';
                 let modelForDb;
                 if (cliCommand === 'kimi')
                     modelForDb = 'kimi-for-coding';
+                // cursor-agent picks the model from the user's own Cursor settings and does
+                // not report it in text mode, so leave it unset rather than guess.
+                else if (cliCommand === 'cursor')
+                    modelForDb = undefined;
                 else if (cliCommand === 'orquesta')
                     modelForDb = (globalCliEndpoint === 'batuta' || !globalCliEndpoint) ? 'batuta-auto' : globalCliEndpoint;
                 else if (cliCommand === 'claude')
                     modelForDb = process.env.ANTHROPIC_MODEL || undefined;
-                updatePromptStatus(promptId, status, summary || undefined, Object.keys(usage).length > 0 ? usage : undefined, finalResult, { cliType: cliTypeForDb, model: modelForDb, gitBranch: currentBranch || undefined }).catch(err => {
+                updatePromptStatus(promptId, status, summary || undefined, Object.keys(usage).length > 0 ? usage : undefined, finalResult, { cliType: cliTypeForDb, model: modelForDb, gitBranch: currentBranch || undefined, gitCommitSha: detectedCommitSha || undefined, gitCommitUrl: detectedCommitUrl || undefined }).catch(err => {
                     logger.error(`Failed to update prompt status: ${err}`);
                 });
                 // Auto-publish any documents/assets the run generated so the operator
@@ -3490,20 +3662,30 @@ export async function startSession(options) {
     // inside bwrap (/ is ro-bound). cliCommand stays the TYPE.
     const cliBinary = cliCommand === 'kimi'
         ? (resolveKimiBinary() || 'kimi')
-        : cliCommand === 'claude'
-            ? (resolveClaudeBinary() || 'claude')
-            : cliCommand;
-    logger.info(`Interactive session CLI: ${cliCommand}${cliCommand === 'kimi' ? ` (${cliBinary})` : ''}`);
+        : cliCommand === 'cursor'
+            ? (resolveCursorBinary() || 'cursor-agent')
+            : cliCommand === 'claude'
+                ? (resolveClaudeBinary() || 'claude')
+                : cliCommand;
+    const resolvedByPath = cliCommand === 'kimi' || cliCommand === 'cursor';
+    logger.info(`Interactive session CLI: ${cliCommand}${resolvedByPath ? ` (${cliBinary})` : ''}`);
     // Best-effort model + cli label reported in session:started so the dashboard
     // can tag the interactive prompt (same mapping dispatched prompts use on
     // completion). claude's exact model isn't knowable from a raw PTY, so it falls
     // back to ANTHROPIC_MODEL when set, else undefined.
     const sessionModel = cliCommand === 'kimi'
         ? 'kimi-for-coding'
-        : cliCommand === 'orquesta'
-            ? ((globalCliEndpoint === 'batuta' || !globalCliEndpoint) ? 'batuta-auto' : globalCliEndpoint)
-            : (process.env.ANTHROPIC_MODEL || undefined);
-    const sessionCliType = cliCommand === 'orquesta' ? 'orquesta' : cliCommand === 'kimi' ? 'kimi' : 'claude';
+        : cliCommand === 'cursor'
+            // cursor-agent uses whatever model the user selected in their own Cursor
+            // account; it isn't knowable from the PTY, so report nothing rather than lie.
+            ? undefined
+            : cliCommand === 'orquesta'
+                ? ((globalCliEndpoint === 'batuta' || !globalCliEndpoint) ? 'batuta-auto' : globalCliEndpoint)
+                : (process.env.ANTHROPIC_MODEL || undefined);
+    const sessionCliType = cliCommand === 'orquesta' ? 'orquesta'
+        : cliCommand === 'kimi' ? 'kimi'
+            : cliCommand === 'cursor' ? 'cursor'
+                : 'claude';
     // Filter undefined env values — node-pty requires Record<string, string>.
     // In strict sandbox mode, sandboxEnv() first reduces to the allowlist so the
     // interactive CLI can't read unrelated host secrets from its own env.
@@ -3583,7 +3765,7 @@ export async function startSession(options) {
     // `ps aux`. Default-off because a file unreadable inside bwrap would silently
     // strip the system prompt (degraded session, not a crash) — flip the default
     // only after E2E confirms the sandbox reads it. Rollback = unset the var.
-    const wantSysPromptFile = cliCommand !== 'kimi' && ((process.platform === 'win32' && cliCommand === 'orquesta') ||
+    const wantSysPromptFile = cliCommand !== 'kimi' && cliCommand !== 'cursor' && ((process.platform === 'win32' && cliCommand === 'orquesta') ||
         /^(1|true|yes|on)$/i.test(process.env.ORQUESTA_SYSPROMPT_FILE || ''));
     if (wantSysPromptFile) {
         try {
@@ -3602,7 +3784,13 @@ export async function startSession(options) {
         }
     }
     let ptyArgs;
-    if (cliCommand === 'kimi') {
+    if (cliCommand === 'cursor') {
+        // cursor-agent has no --append-system-prompt; it reads AGENTS.md / CLAUDE.md
+        // from the working dir (which the agent already syncs), so the capabilities
+        // block isn't injected. `--force` is its --dangerously-skip-permissions.
+        ptyArgs = ['--force'];
+    }
+    else if (cliCommand === 'kimi') {
         // Kimi has neither --dangerously-skip-permissions nor --append-system-prompt.
         // `-y` auto-approves the interactive session; it reads project conventions from
         // CLAUDE.md / AGENTS.md in the working dir (which the agent already syncs), so
@@ -3620,10 +3808,11 @@ export async function startSession(options) {
     // resume flag, so the option is silently ignored there. Prepended so it's an
     // unambiguous standalone flag, separate from --append-system-prompt's value.
     if ((resume || resumeSessionId) && cliCommand !== 'kimi') {
+        // cursor-agent spells these the same way claude does (--continue / --resume <id>).
         // claude can target a SPECIFIC past conversation by id (--resume <id>);
         // orquesta-cli only reattaches the latest (--continue). So when a specific
         // id is requested and we're on claude, use --resume; otherwise --continue.
-        if (resumeSessionId && cliCommand === 'claude') {
+        if (resumeSessionId && (cliCommand === 'claude' || cliCommand === 'cursor')) {
             ptyArgs.unshift('--resume', resumeSessionId);
             logger.info(`[Session] Resuming conversation ${resumeSessionId} (--resume) for ${cliCommand}`);
         }