@cloudcli-ai/cloudcli 1.36.2 → 1.37.0

package/server/modules/providers/list/codex/codex-sessions.provider.ts

@@ -2,7 +2,7 @@ import fsSync from 'node:fs';
 import readline from 'node:readline';
 
 import { sessionsDb } from '@/modules/database/index.js';
-import { toImageAttachments } from '@/shared/image-attachments.js';
+import { parseFilesInputTag, toImageAttachments } from '@/shared/image-attachments.js';
 import type { IProviderSessions } from '@/shared/interfaces.js';
 import type { AnyRecord, FetchHistoryOptions, FetchHistoryResult, NormalizedMessage } from '@/shared/types.js';
 import { createNormalizedMessage, generateMessageId, readObjectRecord, sliceTailPage } from '@/shared/utils.js';
@@ -93,6 +93,144 @@ function extractCodexTextContent(content: unknown): string {
     .join('\n');
 }
 
+function extractCodexToolOutput(output: unknown): string {
+  if (typeof output === 'string') {
+    return output;
+  }
+
+  if (!Array.isArray(output)) {
+    return output == null ? '' : JSON.stringify(output);
+  }
+
+  return output
+    .map((item) => {
+      const record = readObjectRecord(item);
+      return typeof record?.text === 'string' ? record.text : '';
+    })
+    .filter(Boolean)
+    .join('');
+}
+
+function readRunningExecOutput(output: string): { cellId: string; content: string } | null {
+  const runningCell = /Script running with cell ID\s+(\S+)/i.exec(output);
+  if (!runningCell) {
+    return null;
+  }
+
+  const outputMarker = /\r?\nOutput:\r?\n/i.exec(output);
+  return {
+    cellId: runningCell[1],
+    content: outputMarker ? output.slice((outputMarker.index || 0) + outputMarker[0].length) : '',
+  };
+}
+
+function decodeJavaScriptStringLiteral(literal: string): string {
+  if (literal.startsWith('"')) {
+    try {
+      return JSON.parse(literal) as string;
+    } catch {
+      return literal.slice(1, -1);
+    }
+  }
+
+  return literal
+    .slice(1, -1)
+    .replace(/\\n/g, '\n')
+    .replace(/\\r/g, '\r')
+    .replace(/\\t/g, '\t')
+    .replace(/\\([\\'`])/g, '$1');
+}
+
+function extractNestedCodexCommands(source: string): string[] {
+  const commands: string[] = [];
+  const commandPattern = /\bcommand\s*:\s*("(?:\\.|[^"\\])*"|'(?:\\.|[^'\\])*'|`(?:\\.|[^`\\])*`)/gs;
+  for (const match of source.matchAll(commandPattern)) {
+    commands.push(decodeJavaScriptStringLiteral(match[1]));
+  }
+
+  if (commands.length === 0) {
+    const arrayPattern = /\b(?:const|let|var)\s+([A-Za-z_$][\w$]*)\s*=\s*\[([\s\S]*?)\]\s*;/g;
+    const stringPattern = /("(?:\\.|[^"\\])*"|'(?:\\.|[^'\\])*'|`(?:\\.|[^`\\])*`)/g;
+
+    for (const arrayMatch of source.matchAll(arrayPattern)) {
+      const arrayName = arrayMatch[1];
+      if (!new RegExp(`\\b${arrayName}\\.map\\s*\\(`).test(source)) {
+        continue;
+      }
+      for (const stringMatch of arrayMatch[2].matchAll(stringPattern)) {
+        commands.push(decodeJavaScriptStringLiteral(stringMatch[1]));
+      }
+    }
+  }
+
+  return commands;
+}
+
+/**
+ * Newer Codex rollouts persist the orchestration wrapper (`exec`) instead of
+ * the nested tool name. Recover the useful UI-level operation so history does
+ * not degrade into rows labelled only "exec / Parameters".
+ */
+function translateCodexExecInput(input: unknown): { toolName: string; toolInput: string } | null {
+  const source = typeof input === 'string' ? input : String(input || '');
+  if (/\btools\.shell_command\s*\(/.test(source)) {
+    const commands = extractNestedCodexCommands(source);
+    if (commands.length > 0) {
+      return {
+        toolName: 'Bash',
+        toolInput: JSON.stringify({ command: commands.join('\n') }),
+      };
+    }
+  }
+
+  return null;
+}
+
+function humanizeCodexToolName(toolName: string): string {
+  return toolName
+    .replace(/__/g, ' ')
+    .replace(/_/g, ' ')
+    .replace(/\b\w/g, (character) => character.toUpperCase());
+}
+
+type CodexSubagentRecord = {
+  toolCallId: string;
+  message: AnyRecord;
+  agentPath?: string;
+  isComplete: boolean;
+};
+
+function parseCodexSubagentMessage(payload: AnyRecord): {
+  author: string;
+  messageType: string;
+  result: string;
+} | null {
+  const text = extractCodexTextContent(payload.content);
+  const header = /Message Type:\s*([^\r\n]+)[\s\S]*?Sender:\s*([^\r\n]+)[\s\S]*?Payload:\s*\r?\n([\s\S]*)/i.exec(text);
+  const author = readNonEmptyString(payload.author) || header?.[2]?.trim();
+  if (!author) {
+    return null;
+  }
+
+  return {
+    author,
+    messageType: header?.[1]?.trim().toUpperCase() || 'MESSAGE',
+    result: header?.[3]?.trim() || '',
+  };
+}
+
+const CODEX_COLLABORATION_CONTROL_TOOLS = new Set([
+  'followup_task',
+  'interrupt_agent',
+  'list_agents',
+  'send_message',
+  'wait_agent',
+]);
+
+function readNonEmptyString(value: unknown): string | undefined {
+  return typeof value === 'string' && value.length > 0 ? value : undefined;
+}
+
 async function getCodexSessionMessages(
   sessionId: string,
   limit: number | null = null,
@@ -108,6 +246,14 @@ async function getCodexSessionMessages(
 
     const messages: AnyRecord[] = [];
     let tokenUsage: AnyRecord | null = null;
+    const ignoredToolCallIds = new Set<string>();
+    const execToolCallIds = new Set<string>();
+    const execCallByCellId = new Map<string, string>();
+    const waitCallToExecCall = new Map<string, string>();
+    const pendingExecOutput = new Map<string, string>();
+    const completedExecCalls = new Set<string>();
+    const subagentsByCallId = new Map<string, CodexSubagentRecord>();
+    const subagentsByPath = new Map<string, CodexSubagentRecord>();
     const fileStream = fsSync.createReadStream(sessionFilePath);
     const rl = readline.createInterface({
       input: fileStream,
@@ -121,7 +267,6 @@ async function getCodexSessionMessages(
 
       try {
         const entry = JSON.parse(line) as AnyRecord;
-
         if (entry.type === 'event_msg' && entry.payload?.type === 'token_count' && entry.payload?.info) {
           const info = entry.payload.info as AnyRecord;
           if (info.total_token_usage) {
@@ -133,6 +278,20 @@ async function getCodexSessionMessages(
           }
         }
 
+        if (
+          entry.type === 'event_msg'
+          && entry.payload?.type === 'sub_agent_activity'
+          && entry.payload.kind === 'started'
+        ) {
+          const eventId = readNonEmptyString(entry.payload.event_id);
+          const agentPath = readNonEmptyString(entry.payload.agent_path);
+          const subagent = eventId ? subagentsByCallId.get(eventId) : undefined;
+          if (subagent && agentPath) {
+            subagent.agentPath = agentPath;
+            subagentsByPath.set(agentPath, subagent);
+          }
+        }
+
         if (entry.type === 'event_msg' && isVisibleCodexUserMessage(entry.payload as AnyRecord)) {
           messages.push({
             type: 'user',
@@ -183,10 +342,101 @@ async function getCodexSessionMessages(
           }
         }
 
+        if (entry.type === 'response_item' && entry.payload?.type === 'agent_message') {
+          const agentMessage = parseCodexSubagentMessage(entry.payload as AnyRecord);
+          if (agentMessage && agentMessage.messageType === 'FINAL_ANSWER' && agentMessage.result) {
+            let subagent = subagentsByPath.get(agentMessage.author);
+            if (!subagent) {
+              const fallbackCallId = entry.payload.id || generateMessageId('codex-subagent');
+              const taskName = agentMessage.author.split('/').filter(Boolean).pop() || 'agent';
+              const taskMessage: AnyRecord = {
+                uuid: fallbackCallId,
+                type: 'tool_use',
+                timestamp: entry.timestamp,
+                toolName: 'Task',
+                toolInput: JSON.stringify({
+                  subagent_type: 'Codex',
+                  description: humanizeCodexToolName(taskName),
+                }),
+                toolCallId: fallbackCallId,
+              };
+              messages.push(taskMessage);
+              subagent = {
+                toolCallId: fallbackCallId,
+                message: taskMessage,
+                agentPath: agentMessage.author,
+                isComplete: false,
+              };
+              subagentsByCallId.set(fallbackCallId, subagent);
+              subagentsByPath.set(agentMessage.author, subagent);
+            }
+
+            if (!subagent.isComplete) {
+              messages.push({
+                type: 'tool_result',
+                timestamp: entry.timestamp,
+                toolCallId: subagent.toolCallId,
+                output: agentMessage.result,
+              });
+              subagent.isComplete = true;
+            }
+          }
+        }
+
         if (entry.type === 'response_item' && entry.payload?.type === 'function_call') {
           let toolName = entry.payload.name;
           let toolInput = entry.payload.arguments;
 
+          if (toolName === 'spawn_agent') {
+            let taskName = 'agent';
+            try {
+              const args = JSON.parse(String(entry.payload.arguments || '{}')) as AnyRecord;
+              taskName = readNonEmptyString(args.task_name) || taskName;
+            } catch {
+              // The activity event can still provide the canonical agent path.
+            }
+
+            const taskMessage: AnyRecord = {
+              uuid: entry.payload.call_id,
+              type: 'tool_use',
+              timestamp: entry.timestamp,
+              toolName: 'Task',
+              toolInput: JSON.stringify({
+                subagent_type: 'Codex',
+                description: humanizeCodexToolName(taskName),
+              }),
+              toolCallId: entry.payload.call_id,
+            };
+            messages.push(taskMessage);
+            subagentsByCallId.set(entry.payload.call_id, {
+              toolCallId: entry.payload.call_id,
+              message: taskMessage,
+              isComplete: false,
+            });
+            ignoredToolCallIds.add(entry.payload.call_id);
+            continue;
+          }
+
+          if (toolName === 'wait') {
+            try {
+              const args = JSON.parse(String(entry.payload.arguments || '{}')) as AnyRecord;
+              const cellId = String(args.cell_id || '');
+              const execCallId = execCallByCellId.get(cellId);
+              if (execCallId) {
+                waitCallToExecCall.set(entry.payload.call_id, execCallId);
+              }
+            } catch {
+              // Suppress the orchestration wait even when its payload is malformed.
+            }
+            ignoredToolCallIds.add(entry.payload.call_id);
+            continue;
+          }
+
+          if (CODEX_COLLABORATION_CONTROL_TOOLS.has(toolName)) {
+            ignoredToolCallIds.add(entry.payload.call_id);
+            continue;
+          }
+
           if (toolName === 'shell_command') {
             toolName = 'Bash';
             try {
@@ -207,18 +457,74 @@ async function getCodexSessionMessages(
         }
 
         if (entry.type === 'response_item' && entry.payload?.type === 'function_call_output') {
+          const waitExecCallId = waitCallToExecCall.get(entry.payload.call_id);
+          if (waitExecCallId) {
+            const output = extractCodexToolOutput(entry.payload.output);
+            const runningOutput = readRunningExecOutput(output);
+            const accumulatedOutput = `${pendingExecOutput.get(waitExecCallId) || ''}${runningOutput?.content ?? output}`;
+            pendingExecOutput.set(waitExecCallId, accumulatedOutput);
+
+            if (!runningOutput && !completedExecCalls.has(waitExecCallId)) {
+              messages.push({
+                type: 'tool_result',
+                timestamp: entry.timestamp,
+                toolCallId: waitExecCallId,
+                output: accumulatedOutput,
+              });
+              completedExecCalls.add(waitExecCallId);
+            }
+            continue;
+          }
+
+          const subagent = subagentsByCallId.get(entry.payload.call_id);
+          if (subagent) {
+            const output = extractCodexToolOutput(entry.payload.output);
+            try {
+              const taskPath = readNonEmptyString((JSON.parse(output) as AnyRecord).task_name);
+              if (taskPath) {
+                subagent.agentPath = taskPath;
+                subagentsByPath.set(taskPath, subagent);
+              }
+            } catch {
+              // The sub_agent_activity event normally supplies the path.
+            }
+            continue;
+          }
+
+          if (ignoredToolCallIds.has(entry.payload.call_id)) {
+            continue;
+          }
+
           messages.push({
             type: 'tool_result',
             timestamp: entry.timestamp,
             toolCallId: entry.payload.call_id,
-            output: entry.payload.output,
+            output: extractCodexToolOutput(entry.payload.output),
           });
         }
 
         if (entry.type === 'response_item' && entry.payload?.type === 'custom_tool_call') {
-          const toolName = entry.payload.name || 'custom_tool';
+          let toolName = entry.payload.name || 'custom_tool';
           const input = entry.payload.input || '';
 
+          if (toolName === 'exec') {
+            const translated = translateCodexExecInput(input);
+            if (!translated) {
+              ignoredToolCallIds.add(entry.payload.call_id);
+              continue;
+            }
+            toolName = translated.toolName;
+            messages.push({
+              type: 'tool_use',
+              timestamp: entry.timestamp,
+              toolName,
+              toolInput: translated.toolInput,
+              toolCallId: entry.payload.call_id,
+            });
+            execToolCallIds.add(entry.payload.call_id);
+            continue;
+          }
+
           if (toolName === 'apply_patch') {
             const fileMatch = String(input).match(/\*\*\* Update File: (.+)/);
             const filePath = fileMatch ? fileMatch[1].trim() : 'unknown';
@@ -257,11 +563,26 @@ async function getCodexSessionMessages(
         }
 
         if (entry.type === 'response_item' && entry.payload?.type === 'custom_tool_call_output') {
+          if (ignoredToolCallIds.has(entry.payload.call_id)) {
+            continue;
+          }
+
+          const output = extractCodexToolOutput(entry.payload.output);
+          if (execToolCallIds.has(entry.payload.call_id)) {
+            const runningOutput = readRunningExecOutput(output);
+            if (runningOutput) {
+              execCallByCellId.set(runningOutput.cellId, entry.payload.call_id);
+              pendingExecOutput.set(entry.payload.call_id, runningOutput.content);
+              continue;
+            }
+            completedExecCalls.add(entry.payload.call_id);
+          }
+
           messages.push({
             type: 'tool_result',
             timestamp: entry.timestamp,
             toolCallId: entry.payload.call_id,
-            output: entry.payload.output || '',
+            output,
           });
         }
       } catch {
@@ -334,8 +655,10 @@ export class CodexSessionsProvider implements IProviderSessions {
               .filter(Boolean)
               .join('\n')
           : String(raw.message.content || '');
+      const parsedFiles = parseFilesInputTag(content);
       const rawImages = Array.isArray(raw.images) && raw.images.length > 0 ? raw.images : undefined;
-      if (!content.trim() && !rawImages) {
+      const files = parsedFiles.attachments.length > 0 ? parsedFiles.attachments : undefined;
+      if (!parsedFiles.text.trim() && !rawImages && !files) {
         return [];
       }
       return [createNormalizedMessage({
@@ -345,8 +668,9 @@ export class CodexSessionsProvider implements IProviderSessions {
         provider: PROVIDER,
         kind: 'text',
         role: 'user',
-        content,
+        content: parsedFiles.text,
         images: rawImages,
+        files,
       })];
     }
 

package/server/modules/providers/list/codex/codex-skills.provider.ts

@@ -44,6 +44,11 @@ export class CodexSkillsProvider extends SkillsProvider {
       rootDir: path.join(os.homedir(), '.agents', 'skills'),
       commandPrefix: '$',
     });
+    addUniqueProviderSkillSource(sources, seenRootDirs, {
+      scope: 'user',
+      rootDir: path.join(os.homedir(), '.codex', 'skills'),
+      commandPrefix: '$',
+    });
     addUniqueProviderSkillSource(sources, seenRootDirs, {
       scope: 'admin',
       rootDir: path.join('/etc', 'codex', 'skills'),

package/server/modules/providers/list/codex/codex.provider.ts

@@ -1,6 +1,7 @@
 import { AbstractProvider } from '@/modules/providers/shared/base/abstract.provider.js';
 import { CodexProviderAuth } from '@/modules/providers/list/codex/codex-auth.provider.js';
 import { CodexProviderModels } from '@/modules/providers/list/codex/codex-models.provider.js';
+import { codexRuntime } from '@/modules/providers/list/codex/codex-runtime.provider.js';
 import { CodexMcpProvider } from '@/modules/providers/list/codex/codex-mcp.provider.js';
 import { CodexSessionSynchronizer } from '@/modules/providers/list/codex/codex-session-synchronizer.provider.js';
 import { CodexSessionsProvider } from '@/modules/providers/list/codex/codex-sessions.provider.js';
@@ -8,12 +9,14 @@ import { CodexSkillsProvider } from '@/modules/providers/list/codex/codex-skills
 import type {
   IProviderAuth,
   IProviderModels,
+  IProviderRuntime,
   IProviderSessionSynchronizer,
   IProviderSkills,
   IProviderSessions,
 } from '@/shared/interfaces.js';
 
 export class CodexProvider extends AbstractProvider {
+  readonly runtime: IProviderRuntime = codexRuntime;
   readonly models: IProviderModels = new CodexProviderModels();
   readonly mcp = new CodexMcpProvider();
   readonly auth: IProviderAuth = new CodexProviderAuth();

package/server/modules/providers/list/cursor/cursor-models.provider.ts

@@ -6,16 +6,13 @@ import crossSpawn from 'cross-spawn';
 
 import type { IProviderModels } from '@/shared/interfaces.js';
 import type {
-  ProviderChangeActiveModelInput,
   ProviderCurrentActiveModel,
   ProviderModelOption,
   ProviderModelsDefinition,
-  ProviderSessionActiveModelChange,
 } from '@/shared/types.js';
 import {
   buildDefaultProviderCurrentActiveModel,
   sanitizeLeafDirectoryName,
-  writeProviderSessionActiveModelChange,
 } from '@/shared/utils.js';
 
 export const CURSOR_FALLBACK_MODELS: ProviderModelsDefinition = {
@@ -796,11 +793,5 @@ export class CursorProviderModels implements IProviderModels {
 
     return buildDefaultProviderCurrentActiveModel(await this.getSupportedModels());
   }
-
-  async changeActiveModel(
-    input: ProviderChangeActiveModelInput,
-  ): Promise<ProviderSessionActiveModelChange> {
-    return writeProviderSessionActiveModelChange('cursor', input);
-  }
 }
 

package/server/{cursor-cli.js → modules/providers/list/cursor/cursor-runtime.provider.js}

@@ -1,11 +1,12 @@
 import crossSpawn from 'cross-spawn';
 
-import { appendImagesInputTag } from './shared/image-attachments.js';
-import { notifyRunFailed, notifyRunStopped } from './services/notification-orchestrator.js';
-import { sessionsService } from './modules/providers/services/sessions.service.js';
-import { providerAuthService } from './modules/providers/services/provider-auth.service.js';
-import { providerModelsService } from './modules/providers/services/provider-models.service.js';
-import { createCompleteMessage, createNormalizedMessage, flattenPromptForWindowsShell } from './shared/utils.js';
+import {
+  appendFilesInputTag,
+  appendImagesInputTag,
+  normalizeAttachmentDescriptors
+} from '@/shared/image-attachments.js';
+import { notifyRunFailed, notifyRunStopped } from '@/modules/notifications/index.js';
+import { createCompleteMessage, createNormalizedMessage, flattenPromptForWindowsShell } from '@/shared/utils.js';
 
 // cross-spawn resolves .cmd shims/PATHEXT on Windows and delegates to
 // child_process.spawn everywhere else.
@@ -28,11 +29,24 @@ function isWorkspaceTrustPrompt(text = '') {
   return WORKSPACE_TRUST_PATTERNS.some((pattern) => pattern.test(text));
 }
 
-async function spawnCursor(command, options = {}, ws) {
+async function spawnCursor(command, options = {}, ws, context) {
   return new Promise(async (resolve, reject) => {
-    const { sessionId, projectPath, cwd, toolsSettings, skipPermissions, model, sessionSummary, images } = options;
-    const resolvedModel = await providerModelsService.resolveResumeModel('cursor', sessionId, model);
-    let capturedSessionId = sessionId; // Track session ID throughout the process
+    const {
+      sessionId,
+      projectPath,
+      cwd,
+      toolsSettings,
+      skipPermissions,
+      model,
+      sessionSummary,
+      images,
+      files
+    } = options;
+    // Callers pass the stable app session id; the CLI resumes with the
+    // provider-native id recorded on the session row.
+    const providerSessionId = context.resolveProviderSessionId(sessionId);
+    const resolvedModel = await context.resolveResumeModel(sessionId, model);
+    let capturedSessionId = providerSessionId; // Track the provider-native session id throughout the process
     let sessionCreatedSent = false; // Track if we've already sent session-created event
     let hasRetriedWithTrust = false;
     let settled = false;
@@ -51,18 +65,25 @@ async function spawnCursor(command, options = {}, ws) {
     const baseArgs = [];
 
     // Build flags allowing both resume and prompt together (reply in existing session)
-    // Treat presence of sessionId as intention to resume, regardless of resume flag
-    if (sessionId) {
-      baseArgs.push('--resume=' + sessionId);
+    // Treat a known provider-native id as intention to resume
+    if (providerSessionId) {
+      baseArgs.push('--resume=' + providerSessionId);
     }
 
-    if (command && command.trim()) {
+    const hasAttachments =
+      normalizeAttachmentDescriptors(images).length > 0
+      || normalizeAttachmentDescriptors(files).length > 0;
+    if ((command && command.trim()) || hasAttachments) {
       // Provide a prompt (works for both new and resumed sessions). Image
       // attachments ride along as an <images_input> path list appended to the
       // prompt; the session history reader strips the tag back out for display.
       // cursor-agent is a .cmd shim on Windows, so the whole argument must be
       // newline-free or cmd.exe silently truncates it at the first newline.
-      baseArgs.push('-p', flattenPromptForWindowsShell(appendImagesInputTag(command, images)));
+      const promptWithAttachments = appendFilesInputTag(
+        appendImagesInputTag(command || '', images),
+        files
+      );
+      baseArgs.push('-p', flattenPromptForWindowsShell(promptWithAttachments));
 
       // Model overrides are applied to both new and resumed sessions so a
       // session-scoped change request can take effect on the next turn.
@@ -82,8 +103,9 @@ async function spawnCursor(command, options = {}, ws) {
     // Use cwd (actual project directory) instead of projectPath
     const workingDir = cwd || projectPath || process.cwd();
 
-    // Store process reference for potential abort
-    const processKey = capturedSessionId || Date.now().toString();
+    // Store process reference for potential abort — keyed by the app session
+    // id when the caller supplied one, so abort-by-app-id always works.
+    const processKey = sessionId || Date.now().toString();
 
     const settleOnce = (callback) => {
       if (settled) {
@@ -106,7 +128,8 @@ async function spawnCursor(command, options = {}, ws) {
 
         terminalNotificationSent = true;
 
-        const finalSessionId = capturedSessionId || sessionId || processKey;
+        // Notifications are app-facing, so they carry the app session id.
+        const finalSessionId = sessionId || capturedSessionId || processKey;
         if (code === 0 && !error) {
           notifyRunStopped({
             userId: ws?.userId || null,
@@ -167,8 +190,9 @@ async function spawnCursor(command, options = {}, ws) {
                 if (response.session_id && !capturedSessionId) {
                   capturedSessionId = response.session_id;
 
-                  // Update process key with captured session ID
-                  if (processKey !== capturedSessionId) {
+                  // Legacy/direct callers without an app session id re-key the
+                  // process under the provider-native id once it is known.
+                  if (!sessionId && processKey !== capturedSessionId) {
                     activeCursorProcesses.delete(processKey);
                     activeCursorProcesses.set(capturedSessionId, cursorProcess);
                   }
@@ -178,8 +202,8 @@ async function spawnCursor(command, options = {}, ws) {
                     ws.setSessionId(capturedSessionId);
                   }
 
-                  // Send session-created event only once for new sessions
-                  if (!sessionId && !sessionCreatedSent) {
+                  // Send session-created event only once for sessions with nothing to resume
+                  if (!providerSessionId && !sessionCreatedSent) {
                     sessionCreatedSent = true;
                     ws.send(createNormalizedMessage({ kind: 'session_created', newSessionId: capturedSessionId, model: response.model, cwd: response.cwd, sessionId: capturedSessionId, provider: 'cursor' }));
                   }
@@ -196,7 +220,7 @@ async function spawnCursor(command, options = {}, ws) {
             case 'assistant':
               // Accumulate assistant message chunks
               if (response.message && response.message.content && response.message.content.length > 0) {
-                const normalized = sessionsService.normalizeMessage('cursor', response, capturedSessionId || sessionId || null);
+                const normalized = context.normalizeMessage(response, capturedSessionId || sessionId || null);
                 for (const msg of normalized) ws.send(msg);
               }
               break;
@@ -223,7 +247,7 @@ async function spawnCursor(command, options = {}, ws) {
           }
 
           // If not JSON, send as stream delta via adapter
-          const normalized = sessionsService.normalizeMessage('cursor', line, capturedSessionId || sessionId || null);
+          const normalized = context.normalizeMessage(line, capturedSessionId || sessionId || null);
           for (const msg of normalized) ws.send(msg);
         }
       };
@@ -256,7 +280,9 @@ async function spawnCursor(command, options = {}, ws) {
 
       // Handle process completion
       cursorProcess.on('close', async (code) => {
-        const finalSessionId = capturedSessionId || sessionId || processKey;
+        // The process map is keyed by the app session id when one was given,
+        // otherwise by the captured provider id (or the timestamp fallback).
+        const finalSessionId = sessionId || capturedSessionId || processKey;
         activeCursorProcesses.delete(finalSessionId);
 
         // Flush any final unterminated stdout line before completion handling.
@@ -297,11 +323,11 @@ async function spawnCursor(command, options = {}, ws) {
         console.error('Cursor CLI process error:', error);
 
         // Clean up process reference on error
-        const finalSessionId = capturedSessionId || sessionId || processKey;
+        const finalSessionId = sessionId || capturedSessionId || processKey;
         activeCursorProcesses.delete(finalSessionId);
 
         // Check if Cursor CLI is installed for a clearer error message
-        const installed = await providerAuthService.isProviderInstalled('cursor');
+        const installed = await context.isProviderInstalled();
         const errorContent = !installed
           ? 'Cursor CLI is not installed. Please install it from https://cursor.com'
           : error.message;
@@ -346,6 +372,11 @@ function getActiveCursorSessions() {
   return Array.from(activeCursorProcesses.keys());
 }
 
+export const cursorRuntime = {
+  run: spawnCursor,
+  abort: abortCursorSession,
+};
+
 export {
   spawnCursor,
   abortCursorSession,