@cloudcli-ai/cloudcli 1.36.3 → 1.37.0

package/server/{openai-codex.js → modules/providers/list/codex/codex-runtime.provider.js}

@@ -3,11 +3,11 @@
  * =============================
  *
  * This module provides integration with the OpenAI Codex SDK for non-interactive
- * chat sessions. It mirrors the pattern used in claude-sdk.js for consistency.
+ * chat sessions. It mirrors the Claude runtime adapter for consistency.
  *
  * ## Usage
  *
- * - queryCodex(command, options, ws) - Execute a prompt with streaming via WebSocket
+ * - codexRuntime.run(command, options, writer, context) - Execute a streamed prompt
  * - abortCodexSession(sessionId) - Cancel an active session
  * - isCodexSessionActive(sessionId) - Check if a session is running
  * - getActiveCodexSessions() - List all active sessions
@@ -15,12 +15,13 @@
 
 import { Codex } from '@openai/codex-sdk';
 
-import { buildCodexInputItems, normalizeImageDescriptors } 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 } from './shared/utils.js';
+import {
+  appendFilesInputTag,
+  buildCodexInputItems,
+  normalizeImageDescriptors
+} from '@/shared/image-attachments.js';
+import { notifyRunFailed, notifyRunStopped } from '@/modules/notifications/index.js';
+import { createCompleteMessage, createNormalizedMessage } from '@/shared/utils.js';
 
 const activeCodexSessions = new Map();
 
@@ -222,7 +223,7 @@ function mapPermissionModeToCodexOptions(permissionMode) {
  * @param {object} options - Options including cwd, sessionId, model, permissionMode
  * @param {WebSocket|object} ws - WebSocket connection or response writer
  */
-export async function queryCodex(command, options = {}, ws) {
+export async function queryCodex(command, options = {}, ws, context) {
   const {
     sessionId,
     sessionSummary,
@@ -231,18 +232,19 @@ export async function queryCodex(command, options = {}, ws) {
     model,
     effort,
     images,
+    files,
     permissionMode = 'default'
   } = options;
 
-  const resolvedModel = await providerModelsService.resolveResumeModel(
-    'codex',
-    sessionId,
-    model,
-  );
+  // Callers pass the stable app session id; the SDK resumes threads with the
+  // provider-native id recorded on the session row.
+  const providerSessionId = context.resolveProviderSessionId(sessionId);
+
+  const resolvedModel = await context.resolveResumeModel(sessionId, model);
 
   const workingDirectory = cwd || projectPath || process.cwd();
   const { sandboxMode, approvalPolicy } = mapPermissionModeToCodexOptions(permissionMode);
-  const catalog = (await providerModelsService.getProviderModels('codex')).models;
+  const catalog = await context.getProviderModels();
   const selectedModel = catalog.OPTIONS.find((option) => option.value === resolvedModel) || null;
   const allowedEfforts = selectedModel?.effort?.values?.map((value) => value.value) || [];
   const resolvedEffort = typeof effort === 'string' && effort !== 'default' && allowedEfforts.includes(effort)
@@ -251,10 +253,15 @@ export async function queryCodex(command, options = {}, ws) {
 
   let codex;
   let thread;
-  let capturedSessionId = sessionId;
+  // Provider-native thread id (starts as the resume id, or is captured from
+  // the stream for brand-new sessions).
+  let capturedSessionId = providerSessionId;
   let sessionCreatedSent = false;
   let terminalFailure = null;
   const abortController = new AbortController();
+  // Session-map key: the app session id when the caller supplied one, else
+  // the provider-native thread id once captured (legacy/direct API callers).
+  const sessionKey = () => sessionId || capturedSessionId || null;
 
   try {
     codex = new Codex();
@@ -268,8 +275,8 @@ export async function queryCodex(command, options = {}, ws) {
       modelReasoningEffort: resolvedEffort,
     };
 
-    if (sessionId) {
-      thread = codex.resumeThread(sessionId, threadOptions);
+    if (providerSessionId) {
+      thread = codex.resumeThread(providerSessionId, threadOptions);
     } else {
       thread = codex.startThread(threadOptions);
     }
@@ -287,15 +294,16 @@ export async function queryCodex(command, options = {}, ws) {
       });
     };
 
-    if (capturedSessionId) {
-      registerSession(capturedSessionId);
+    if (sessionKey()) {
+      registerSession(sessionKey());
     }
 
     // Execute with streaming. Turns with image attachments send structured
     // input items so Codex reads the images from their local asset paths.
+    const promptWithFiles = appendFilesInputTag(command, files);
     const turnInput = normalizeImageDescriptors(images).length > 0
-      ? buildCodexInputItems(command, images, workingDirectory)
-      : command;
+      ? buildCodexInputItems(promptWithFiles, images, workingDirectory)
+      : promptWithFiles;
     const streamedTurn = await thread.runStreamed(turnInput, {
       signal: abortController.signal
     });
@@ -306,13 +314,13 @@ export async function queryCodex(command, options = {}, ws) {
         const discoveredSessionId = event.thread_id || event.id || null;
         if (discoveredSessionId && !capturedSessionId) {
           capturedSessionId = discoveredSessionId;
-          registerSession(capturedSessionId);
+          registerSession(sessionKey());
 
           if (ws.setSessionId && typeof ws.setSessionId === 'function') {
             ws.setSessionId(capturedSessionId);
           }
 
-          if (!sessionId && !sessionCreatedSent) {
+          if (!providerSessionId && !sessionCreatedSent) {
             sessionCreatedSent = true;
             sendMessage(ws, createNormalizedMessage({ kind: 'session_created', newSessionId: capturedSessionId, sessionId: capturedSessionId, provider: 'codex' }));
           }
@@ -323,8 +331,8 @@ export async function queryCodex(command, options = {}, ws) {
       if (abortController.signal.aborted) {
         break;
       }
-      if (capturedSessionId) {
-        const session = activeCodexSessions.get(capturedSessionId);
+      if (sessionKey()) {
+        const session = activeCodexSessions.get(sessionKey());
         if (session?.status === 'aborted') {
           break;
         }
@@ -337,17 +345,18 @@ export async function queryCodex(command, options = {}, ws) {
       const transformed = transformCodexEvent(event);
 
       // Normalize the transformed event into NormalizedMessage(s) via adapter
-      const normalizedMsgs = sessionsService.normalizeMessage('codex', transformed, capturedSessionId || sessionId || null);
+      const normalizedMsgs = context.normalizeMessage(transformed, capturedSessionId || sessionId || null);
       for (const msg of normalizedMsgs) {
         sendMessage(ws, msg);
       }
 
       if (event.type === 'turn.failed' && !terminalFailure) {
         terminalFailure = event.error || new Error('Turn failed');
+        // Notifications are app-facing, so they carry the app session id.
         notifyRunFailed({
           userId: ws?.userId || null,
           provider: 'codex',
-          sessionId: capturedSessionId || sessionId || null,
+          sessionId: sessionId || capturedSessionId || null,
           sessionName: sessionSummary,
           error: terminalFailure
         });
@@ -364,7 +373,7 @@ export async function queryCodex(command, options = {}, ws) {
 
     // Send the terminal completion event — skipped for aborted runs, whose
     // terminal `complete` (aborted: true) was already sent by abort-session.
-    const runSession = capturedSessionId ? activeCodexSessions.get(capturedSessionId) : null;
+    const runSession = sessionKey() ? activeCodexSessions.get(sessionKey()) : null;
     const runAborted = runSession?.status === 'aborted' || abortController.signal.aborted;
     if (!runAborted) {
       sendMessage(ws, createCompleteMessage({
@@ -377,7 +386,7 @@ export async function queryCodex(command, options = {}, ws) {
         notifyRunStopped({
           userId: ws?.userId || null,
           provider: 'codex',
-          sessionId: capturedSessionId || sessionId || null,
+          sessionId: sessionId || capturedSessionId || null,
           sessionName: sessionSummary,
           stopReason: 'completed'
         });
@@ -385,7 +394,7 @@ export async function queryCodex(command, options = {}, ws) {
     }
 
   } catch (error) {
-    const session = capturedSessionId ? activeCodexSessions.get(capturedSessionId) : null;
+    const session = sessionKey() ? activeCodexSessions.get(sessionKey()) : null;
     const wasAborted =
       session?.status === 'aborted' ||
       error?.name === 'AbortError' ||
@@ -395,7 +404,7 @@ export async function queryCodex(command, options = {}, ws) {
       console.error('[Codex] Error:', error);
 
       // Check if Codex SDK is available for a clearer error message
-      const installed = await providerAuthService.isProviderInstalled('codex');
+      const installed = await context.isProviderInstalled();
       const errorContent = !installed
         ? 'Codex CLI is not configured. Please set up authentication first.'
         : error.message;
@@ -410,7 +419,7 @@ export async function queryCodex(command, options = {}, ws) {
         notifyRunFailed({
           userId: ws?.userId || null,
           provider: 'codex',
-          sessionId: capturedSessionId || sessionId || null,
+          sessionId: sessionId || capturedSessionId || null,
           sessionName: sessionSummary,
           error
         });
@@ -419,8 +428,8 @@ export async function queryCodex(command, options = {}, ws) {
 
   } finally {
     // Update session status
-    if (capturedSessionId) {
-      const session = activeCodexSessions.get(capturedSessionId);
+    if (sessionKey()) {
+      const session = activeCodexSessions.get(sessionKey());
       if (session) {
         session.status = session.status === 'aborted' ? 'aborted' : 'completed';
       }
@@ -480,6 +489,11 @@ export function getActiveCodexSessions() {
   return sessions;
 }
 
+export const codexRuntime = {
+  run: queryCodex,
+  abort: abortCodexSession,
+};
+
 /**
  * Helper to send message via WebSocket or writer
  * @param {WebSocket|object} ws - WebSocket or response writer
@@ -500,7 +514,7 @@ function sendMessage(ws, data) {
 }
 
 // Clean up old completed sessions periodically
-setInterval(() => {
+const completedSessionCleanupTimer = setInterval(() => {
   const now = Date.now();
   const maxAge = 30 * 60 * 1000; // 30 minutes
 
@@ -513,3 +527,7 @@ setInterval(() => {
     }
   }
 }, 5 * 60 * 1000); // Every 5 minutes
+
+// Runtime cleanup should not keep focused tests or one-off scripts alive after
+// their provider work has completed.
+completedSessionCleanupTimer.unref?.();

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'),