@swarmclawai/swarmclaw 1.7.0 → 1.7.1

package/src/lib/home-launchpad.test.ts

@@ -1,12 +1,6 @@
 import assert from 'node:assert/strict'
 import { test } from 'node:test'
-import {
-  DEFAULT_BUILDER_ROUTE,
-  deriveHomeMode,
-  getLaunchPathCards,
-  isSparseWorkspace,
-  resolveLaunchPathHref,
-} from './home-launchpad'
+import { deriveHomeMode, isSparseWorkspace } from './home-launchpad'
 
 test('isSparseWorkspace detects a fresh workspace', () => {
   assert.equal(isSparseWorkspace({
@@ -53,27 +47,3 @@ test('deriveHomeMode falls back to ops for active workspaces', () => {
     todayCost: 0,
   }), 'ops')
 })
-
-test('getLaunchPathCards returns the three first-run paths in order', () => {
-  const cards = getLaunchPathCards({ firstAgentName: 'Ada' })
-  assert.deepEqual(cards.map((card) => card.id), ['assistant', 'workflow', 'mission'])
-  assert.equal(cards[0]?.title, 'Work with Ada')
-  assert.equal(cards[0]?.primaryLabel, 'Open Chat')
-  assert.equal(cards[1]?.primaryLabel, 'Open Builder')
-  assert.equal(cards[2]?.secondaryLabel, 'Quality Center')
-})
-
-test('getLaunchPathCards falls back to agent creation copy when no agent exists', () => {
-  const [assistant] = getLaunchPathCards()
-  assert.equal(assistant?.title, 'Create the first agent')
-  assert.equal(assistant?.primaryLabel, 'Open Agents')
-})
-
-test('resolveLaunchPathHref builds primary and secondary destinations', () => {
-  assert.equal(resolveLaunchPathHref('assistant', 'primary', 'agent one'), '/agents/agent%20one')
-  assert.equal(resolveLaunchPathHref('assistant', 'secondary', 'agent one'), '/connectors')
-  assert.equal(resolveLaunchPathHref('workflow', 'primary'), DEFAULT_BUILDER_ROUTE)
-  assert.equal(resolveLaunchPathHref('workflow', 'secondary'), '/protocols')
-  assert.equal(resolveLaunchPathHref('mission', 'primary'), '/missions')
-  assert.equal(resolveLaunchPathHref('mission', 'secondary'), '/quality')
-})

package/src/lib/home-launchpad.ts

@@ -2,17 +2,6 @@ export const HOME_LAUNCHPAD_AFTER_SETUP_KEY = 'sc_launchpad_after_setup_v1'
 export const DEFAULT_BUILDER_ROUTE = '/protocols/builder/facilitated_discussion'
 
 export type HomeMode = 'launchpad' | 'ops'
-export type LaunchPathId = 'assistant' | 'workflow' | 'mission'
-export type LaunchPathAction = 'primary' | 'secondary'
-
-export interface LaunchPathCardCopy {
-  id: LaunchPathId
-  kicker: string
-  title: string
-  description: string
-  primaryLabel: string
-  secondaryLabel: string
-}
 
 export interface HomeModeInput {
   hasLaunchpadFlag: boolean
@@ -39,50 +28,3 @@ export function deriveHomeMode(input: HomeModeInput): HomeMode {
   if (input.hasLaunchpadFlag) return 'launchpad'
   return isSparseWorkspace(input) ? 'launchpad' : 'ops'
 }
-
-export function getLaunchPathCards(input: { firstAgentName?: string | null } = {}): LaunchPathCardCopy[] {
-  const firstAgentName = input.firstAgentName?.trim() || null
-  return [
-    {
-      id: 'assistant',
-      kicker: 'Assistant',
-      title: firstAgentName ? `Work with ${firstAgentName}` : 'Create the first agent',
-      description: 'Open a live agent chat, then add memory, local tools, provider routing, or connector access as the work demands.',
-      primaryLabel: firstAgentName ? 'Open Chat' : 'Open Agents',
-      secondaryLabel: 'Connect Platform',
-    },
-    {
-      id: 'workflow',
-      kicker: 'Workflow',
-      title: 'Shape a reusable run',
-      description: 'Use protocol templates and the builder to turn review, research, planning, or release checks into durable workflows.',
-      primaryLabel: 'Open Builder',
-      secondaryLabel: 'Use Templates',
-    },
-    {
-      id: 'mission',
-      kicker: 'Mission',
-      title: 'Run with budgets',
-      description: 'Start a mission template for release QA, research, support triage, cost audit, or failed-run review with reports and caps.',
-      primaryLabel: 'Open Missions',
-      secondaryLabel: 'Quality Center',
-    },
-  ]
-}
-
-export function resolveLaunchPathHref(
-  id: LaunchPathId,
-  action: LaunchPathAction,
-  firstAgentId?: string | null,
-): string {
-  if (id === 'assistant') {
-    if (action === 'primary') {
-      return firstAgentId ? `/agents/${encodeURIComponent(firstAgentId)}` : '/agents'
-    }
-    return '/connectors'
-  }
-  if (id === 'workflow') {
-    return action === 'primary' ? DEFAULT_BUILDER_ROUTE : '/protocols'
-  }
-  return action === 'primary' ? '/missions' : '/quality'
-}

package/src/lib/providers/cli-utils.test.ts

@@ -1,7 +1,17 @@
 import assert from 'node:assert/strict'
+import fs from 'node:fs'
+import os from 'node:os'
+import path from 'node:path'
 import { describe, it } from 'node:test'
 
-import { isStderrNoise, buildCliEnv, isCliProvider, CLI_PROVIDER_CAPABILITIES } from './cli-utils'
+import {
+  isStderrNoise,
+  buildCliEnv,
+  isCliProvider,
+  CLI_PROVIDER_CAPABILITIES,
+  resolveCodexProbeInvocation,
+  ensureCliWorkingDirectory,
+} from './cli-utils'
 
 // ---------------------------------------------------------------------------
 // isStderrNoise
@@ -142,3 +152,57 @@ describe('CLI_PROVIDER_CAPABILITIES', () => {
     }
   })
 })
+
+// ---------------------------------------------------------------------------
+// resolveCodexProbeInvocation
+// ---------------------------------------------------------------------------
+
+describe('resolveCodexProbeInvocation', () => {
+  it('uses node directly for codex JS wrappers discovered through a symlink', () => {
+    const tmpRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'swarmclaw-codex-probe-'))
+    try {
+      const realScript = path.join(tmpRoot, 'codex.js')
+      fs.writeFileSync(realScript, '#!/usr/bin/env node\nconsole.log("ok")\n')
+      fs.chmodSync(realScript, 0o755)
+
+      const wrapperPath = path.join(tmpRoot, 'codex')
+      fs.symlinkSync(realScript, wrapperPath)
+
+      const invocation = resolveCodexProbeInvocation(wrapperPath)
+      assert.equal(invocation.command, process.execPath)
+      assert.deepEqual(invocation.args, [fs.realpathSync(realScript), 'login', 'status'])
+    } finally {
+      fs.rmSync(tmpRoot, { recursive: true, force: true })
+    }
+  })
+
+  it('uses the binary directly for non-JS executables', () => {
+    const invocation = resolveCodexProbeInvocation('/usr/local/bin/codex-bin')
+    assert.equal(invocation.command, '/usr/local/bin/codex-bin')
+    assert.deepEqual(invocation.args, ['login', 'status'])
+  })
+})
+
+// ---------------------------------------------------------------------------
+// ensureCliWorkingDirectory
+// ---------------------------------------------------------------------------
+
+describe('ensureCliWorkingDirectory', () => {
+  it('creates a missing working directory recursively', () => {
+    const tmpRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'swarmclaw-cli-cwd-'))
+    const target = path.join(tmpRoot, 'nested', 'room')
+    try {
+      assert.equal(fs.existsSync(target), false)
+      const resolved = ensureCliWorkingDirectory(target)
+      assert.equal(resolved, target)
+      assert.equal(fs.existsSync(target), true)
+      assert.equal(fs.statSync(target).isDirectory(), true)
+    } finally {
+      fs.rmSync(tmpRoot, { recursive: true, force: true })
+    }
+  })
+
+  it('falls back to process.cwd when cwd is blank', () => {
+    assert.equal(ensureCliWorkingDirectory(''), process.cwd())
+  })
+})

package/src/lib/providers/cli-utils.ts

@@ -10,6 +10,7 @@ import os from 'os'
 import { findBinaryOnPath } from '../server/session-tools/context'
 import path from 'path'
 import { spawnSync, type ChildProcess } from 'child_process'
+import { realpathSync } from 'fs'
 import { log } from '../server/logger'
 
 // ---------------------------------------------------------------------------
@@ -168,6 +169,25 @@ export interface AuthProbeResult {
   errorMessage?: string
 }
 
+export function resolveCodexProbeInvocation(binary: string): { command: string; args: string[] } {
+  try {
+    const resolved = realpathSync(binary)
+    if (resolved.toLowerCase().endsWith('.js')) {
+      return { command: process.execPath, args: [resolved, 'login', 'status'] }
+    }
+  } catch {
+    // Fall through to direct execution when the binary cannot be resolved.
+  }
+
+  return { command: binary, args: ['login', 'status'] }
+}
+
+export function ensureCliWorkingDirectory(cwd?: string | null): string {
+  const resolved = typeof cwd === 'string' && cwd.trim() ? cwd.trim() : process.cwd()
+  fs.mkdirSync(resolved, { recursive: true })
+  return resolved
+}
+
 /**
  * Unified auth check for supported CLI-backed providers.
  */
@@ -198,7 +218,8 @@ export function probeCliAuth(
   }
 
   if (backend === 'codex') {
-    const probe = spawnSync(binary, ['login', 'status'], {
+    const invocation = resolveCodexProbeInvocation(binary)
+    const probe = spawnSync(invocation.command, invocation.args, {
       cwd, env, encoding: 'utf-8', timeout: 8000,
     })
     const probeText = `${probe.stdout || ''}\n${probe.stderr || ''}`.toLowerCase()

package/src/lib/providers/codex-cli.ts

@@ -5,7 +5,7 @@ import { spawn } from 'child_process'
 import type { StreamChatOptions } from './index'
 import { log } from '../server/logger'
 import { loadRuntimeSettings } from '@/lib/server/runtime/runtime-settings'
-import { resolveCliBinary, buildCliEnv, probeCliAuth, attachAbortHandler, symlinkConfigFiles, isStderrNoise } from './cli-utils'
+import { resolveCliBinary, buildCliEnv, probeCliAuth, attachAbortHandler, symlinkConfigFiles, isStderrNoise, ensureCliWorkingDirectory } from './cli-utils'
 import { getAgent } from '@/lib/server/agents/agent-repository'
 import { loadMcpServers } from '@/lib/server/storage'
 
@@ -27,6 +27,9 @@ export function streamCodexCliChat({ session, message, imagePath, systemPrompt,
 
   const prompt = message
   const args: string[] = ['exec']
+  // Use ~/.codex-sessions/ not /tmp — codex refuses to create helper binaries under /tmp.
+  const sessionsDir = path.join(os.homedir(), '.codex-sessions')
+  const perSessionHome = path.join(sessionsDir, session.id)
 
   // Session resume
   if (session.codexThreadId) {
@@ -53,15 +56,16 @@ export function streamCodexCliChat({ session, message, imagePath, systemPrompt,
 
   // Build clean env — preserves user's CODEX_HOME for auth
   const env = buildCliEnv()
+  const effectiveCwd = ensureCliWorkingDirectory(session.cwd)
 
   // Pass API key if available
   if (session.apiKey) {
     env.OPENAI_API_KEY = session.apiKey
   }
 
-  // Auth probe BEFORE creating temp CODEX_HOME — uses real config dir
+  // Auth probe BEFORE creating the session CODEX_HOME — uses real config dir
   if (!session.apiKey) {
-    const auth = probeCliAuth(binary, 'codex', env, session.cwd)
+    const auth = probeCliAuth(binary, 'codex', env, effectiveCwd)
     if (!auth.authenticated) {
       log.error('codex-cli', auth.errorMessage || 'Auth failed')
       write(`data: ${JSON.stringify({ t: 'err', text: auth.errorMessage || 'Codex CLI is not authenticated.' })}\n\n`)
@@ -69,86 +73,80 @@ export function streamCodexCliChat({ session, message, imagePath, systemPrompt,
     }
   }
 
-  // System prompt + MCP injection: create a temp CODEX_HOME when needed
-  // Symlink auth files from the real config dir so auth still works
-  let tempCodexHome: string | null = null
+  // Always use a stable per-session CODEX_HOME for the actual Codex run. A first
+  // turn can emit a thread id even without system-prompt or MCP injection, and
+  // the next turn needs the same local metadata to resume that thread.
+  const sessionCodexHome = perSessionHome
   const agentForMcp = session.agentId ? getAgent(session.agentId as string) : null
   const agentMcpServerIds: string[] = agentForMcp?.mcpServerIds || []
-  const needsTempHome = (systemPrompt && !session.codexThreadId) || agentMcpServerIds.length > 0
-  if (needsTempHome) {
-    const realCodexHome = process.env.CODEX_HOME || path.join(os.homedir(), '.codex')
-    // Use ~/.codex-sessions/ not /tmp — codex refuses to create helper binaries under /tmp
-    const sessionsDir = path.join(os.homedir(), '.codex-sessions')
-    tempCodexHome = path.join(sessionsDir, session.id)
-    fs.mkdirSync(tempCodexHome, { recursive: true })
-
-    // Symlink auth/config files from real CODEX_HOME into temp dir
-    symlinkConfigFiles(realCodexHome, tempCodexHome)
-
-    // Write system prompt as AGENTS.override.md (first turn only)
-    if (systemPrompt && !session.codexThreadId) {
-      fs.writeFileSync(path.join(tempCodexHome, 'AGENTS.override.md'), systemPrompt)
-    }
+  const realCodexHome = process.env.CODEX_HOME || path.join(os.homedir(), '.codex')
+  fs.mkdirSync(sessionCodexHome, { recursive: true })
 
-    // Inject agent-assigned MCP servers into config.toml
-    if (agentMcpServerIds.length > 0) {
-      try {
-        const allMcpServers = loadMcpServers()
-        const tomlParts: string[] = []
-        for (const serverId of agentMcpServerIds) {
-          const config = allMcpServers[serverId]
-          if (!config) continue
-          const name = config.name.replace(/[^a-zA-Z0-9_]/g, '_')
-          if (config.transport === 'stdio' && config.command) {
-            tomlParts.push(`[mcp_servers.${name}]`)
-            tomlParts.push(`command = ${JSON.stringify(config.command)}`)
-            const argsStr = (config.args || []).map((a: string) => JSON.stringify(a)).join(', ')
-            tomlParts.push(`args = [${argsStr}]`)
-            if (config.cwd) tomlParts.push(`cwd = ${JSON.stringify(config.cwd)}`)
-            tomlParts.push('')
-            // Env vars go in a separate subsection: [mcp_servers.name.env]
-            if (config.env && Object.keys(config.env).length > 0) {
-              tomlParts.push(`[mcp_servers.${name}.env]`)
-              for (const [k, v] of Object.entries(config.env as Record<string, string>)) {
-                tomlParts.push(`${k} = ${JSON.stringify(v)}`)
-              }
-              tomlParts.push('')
+  // Symlink auth/config files from real CODEX_HOME into session dir
+  symlinkConfigFiles(realCodexHome, sessionCodexHome)
+
+  // Write system prompt as AGENTS.override.md (first turn only)
+  if (systemPrompt && !session.codexThreadId) {
+    fs.writeFileSync(path.join(sessionCodexHome, 'AGENTS.override.md'), systemPrompt)
+  }
+
+  // Inject agent-assigned MCP servers into config.toml
+  if (agentMcpServerIds.length > 0) {
+    try {
+      const allMcpServers = loadMcpServers()
+      const tomlParts: string[] = []
+      for (const serverId of agentMcpServerIds) {
+        const config = allMcpServers[serverId]
+        if (!config) continue
+        const name = config.name.replace(/[^a-zA-Z0-9_]/g, '_')
+        if (config.transport === 'stdio' && config.command) {
+          tomlParts.push(`[mcp_servers.${name}]`)
+          tomlParts.push(`command = ${JSON.stringify(config.command)}`)
+          const argsStr = (config.args || []).map((a: string) => JSON.stringify(a)).join(', ')
+          tomlParts.push(`args = [${argsStr}]`)
+          if (config.cwd) tomlParts.push(`cwd = ${JSON.stringify(config.cwd)}`)
+          tomlParts.push('')
+          // Env vars go in a separate subsection: [mcp_servers.name.env]
+          if (config.env && Object.keys(config.env).length > 0) {
+            tomlParts.push(`[mcp_servers.${name}.env]`)
+            for (const [k, v] of Object.entries(config.env as Record<string, string>)) {
+              tomlParts.push(`${k} = ${JSON.stringify(v)}`)
             }
-          } else if ((config.transport === 'sse' || config.transport === 'streamable-http') && config.url) {
-            tomlParts.push(`[mcp_servers.${name}]`)
-            tomlParts.push(`url = ${JSON.stringify(config.url)}`)
             tomlParts.push('')
           }
+        } else if ((config.transport === 'sse' || config.transport === 'streamable-http') && config.url) {
+          tomlParts.push(`[mcp_servers.${name}]`)
+          tomlParts.push(`url = ${JSON.stringify(config.url)}`)
+          tomlParts.push('')
         }
-        if (tomlParts.length > 0) {
-          const realConfigPath = path.join(realCodexHome, 'config.toml')
-          const existingConfig = fs.existsSync(realConfigPath)
-            ? fs.readFileSync(realConfigPath, 'utf-8')
-            : ''
-          const tempConfigPath = path.join(tempCodexHome, 'config.toml')
-          // Remove symlink created by symlinkConfigFiles before writing our own file
-          try { fs.unlinkSync(tempConfigPath) } catch { /* no symlink — ignore */ }
-          fs.writeFileSync(tempConfigPath, existingConfig + '\n' + tomlParts.join('\n'))
-          log.info('codex-cli', `Injecting ${agentMcpServerIds.length} MCP server(s) via config.toml`)
-        }
-      } catch (mcpErr) {
-        log.warn('codex-cli', `Failed to build MCP config: ${mcpErr}`)
       }
+      if (tomlParts.length > 0) {
+        const realConfigPath = path.join(realCodexHome, 'config.toml')
+        const existingConfig = fs.existsSync(realConfigPath)
+          ? fs.readFileSync(realConfigPath, 'utf-8')
+          : ''
+        const tempConfigPath = path.join(sessionCodexHome, 'config.toml')
+        // Remove symlink created by symlinkConfigFiles before writing our own file
+        try { fs.unlinkSync(tempConfigPath) } catch { /* no symlink — ignore */ }
+        fs.writeFileSync(tempConfigPath, existingConfig + '\n' + tomlParts.join('\n'))
+        log.info('codex-cli', `Injecting ${agentMcpServerIds.length} MCP server(s) via config.toml`)
+      }
+    } catch (mcpErr) {
+      log.warn('codex-cli', `Failed to build MCP config: ${mcpErr}`)
     }
-
-    env.CODEX_HOME = tempCodexHome
   }
+  env.CODEX_HOME = sessionCodexHome
 
   log.info('codex-cli', `Spawning: ${binary}`, {
     args: args.map(a => a.length > 100 ? a.slice(0, 100) + '...' : a),
-    cwd: session.cwd,
+    cwd: effectiveCwd,
     promptLen: prompt.length,
     hasSystemPrompt: !!systemPrompt,
-    tempCodexHome,
+    sessionCodexHome,
   })
 
   const proc = spawn(binary, args, {
-    cwd: session.cwd,
+    cwd: effectiveCwd,
     env,
     stdio: ['pipe', 'pipe', 'pipe'],
     timeout: processTimeoutMs,
@@ -185,9 +183,14 @@ export function streamCodexCliChat({ session, message, imagePath, systemPrompt,
         eventCount++
 
         // Track thread ID for session resume
-        if (ev.type === 'thread.started' && ev.thread_id) {
-          session.codexThreadId = ev.thread_id
-          log.info('codex-cli', `Got thread_id: ${ev.thread_id}`)
+        const threadId = typeof ev.thread_id === 'string'
+          ? ev.thread_id
+          : (typeof ev.thread?.id === 'string' ? ev.thread.id : null)
+        if (threadId) {
+          session.codexThreadId = threadId
+          if (eventCount <= 3 || ev.type === 'thread.started') {
+            log.info('codex-cli', `Got thread_id: ${threadId} (${ev.type})`)
+          }
         }
 
         // Streaming text deltas (if codex adds streaming support)
@@ -269,10 +272,6 @@ export function streamCodexCliChat({ session, message, imagePath, systemPrompt,
     proc.on('close', (code, sig) => {
       log.info('codex-cli', `Process closed: code=${code} signal=${sig} events=${eventCount} response=${fullResponse.length}chars`)
       active.delete(session.id)
-      // Clean up temp CODEX_HOME
-      if (tempCodexHome) {
-        try { fs.rmSync(tempCodexHome, { recursive: true }) } catch { /* ignore */ }
-      }
       if ((code ?? 0) !== 0 && !fullResponse.trim()) {
         const msg = stderrText.trim()
           ? `Codex CLI exited with code ${code ?? 'unknown'}${sig ? ` (${sig})` : ''}: ${stderrText.trim().slice(0, 1200)}`
@@ -285,9 +284,6 @@ export function streamCodexCliChat({ session, message, imagePath, systemPrompt,
     proc.on('error', (e) => {
       log.error('codex-cli', `Process error: ${e.message}`)
       active.delete(session.id)
-      if (tempCodexHome) {
-        try { fs.rmSync(tempCodexHome, { recursive: true }) } catch { /* ignore */ }
-      }
       write(`data: ${JSON.stringify({ t: 'err', text: e.message })}\n\n`)
       resolve(fullResponse)
     })

package/src/lib/server/chat-execution/chat-execution-session-sync.test.ts

@@ -109,6 +109,195 @@ test('executeSessionChatTurn syncs updated agent runtime fields onto its thread
   assert.equal(output.connectorContext, null)
 })
 
+test('executeSessionChatTurn persists codex thread id discovered on run-session object', () => {
+  const output = runWithTempDataDir<{
+    codexThreadId: string | null
+  }>(`
+    const storageMod = await import('@/lib/server/storage')
+    const providersMod = await import('@/lib/providers/index')
+    const execMod = await import('@/lib/server/chat-execution/chat-execution')
+    const storage = storageMod.default || storageMod['module.exports'] || storageMod
+    const executeSessionChatTurn = execMod.executeSessionChatTurn
+      || execMod.default?.executeSessionChatTurn
+      || execMod['module.exports']?.executeSessionChatTurn
+    const providers = providersMod.PROVIDERS
+      || providersMod.default?.PROVIDERS
+      || providersMod['module.exports']?.PROVIDERS
+
+    providers['test-codex-sync-provider'] = {
+      id: 'test-codex-sync-provider',
+      name: 'Codex Sync Test Provider',
+      models: ['unit'],
+      requiresApiKey: false,
+      requiresEndpoint: false,
+      handler: {
+        async streamChat(opts) {
+          opts.session.codexThreadId = 'thread_sync_123'
+          return 'ok'
+        },
+      },
+    }
+
+    const now = Date.now()
+    storage.saveAgents({
+      codexsync: {
+        id: 'codexsync',
+        name: 'Codex Sync Agent',
+        description: 'Codex thread id sync test',
+        provider: 'test-codex-sync-provider',
+        model: 'unit',
+        credentialId: null,
+        apiEndpoint: null,
+        fallbackCredentialIds: [],
+        disabled: false,
+        heartbeatEnabled: false,
+        heartbeatIntervalSec: null,
+        extensions: [],
+        createdAt: now,
+        updatedAt: now,
+      },
+    })
+
+    storage.saveSessions({
+      codex_session: {
+        id: 'codex_session',
+        name: 'Codex Session',
+        cwd: process.env.WORKSPACE_DIR,
+        user: 'default',
+        provider: 'test-codex-sync-provider',
+        model: 'unit',
+        claudeSessionId: null,
+        codexThreadId: null,
+        opencodeSessionId: null,
+        geminiSessionId: null,
+        copilotSessionId: null,
+        droidSessionId: null,
+        cursorSessionId: null,
+        qwenSessionId: null,
+        acpSessionId: null,
+        delegateResumeIds: { claudeCode: null, codex: null, opencode: null, gemini: null, copilot: null, droid: null, cursor: null, qwen: null },
+        messages: [],
+        createdAt: now,
+        lastActiveAt: now,
+        sessionType: 'human',
+        agentId: 'codexsync',
+        extensions: [],
+      },
+    })
+
+    await executeSessionChatTurn({
+      sessionId: 'codex_session',
+      message: 'hello',
+      runId: 'run-codex-sync',
+    })
+
+    const persisted = storage.loadSession('codex_session')
+    console.log(JSON.stringify({
+      codexThreadId: persisted?.codexThreadId || null,
+    }))
+  `)
+
+  assert.equal(output.codexThreadId, 'thread_sync_123')
+})
+
+test('executeSessionChatTurn persists intentional codex resume id clears from run-session object', () => {
+  const output = runWithTempDataDir<{
+    codexThreadId: string | null
+    delegateCodex: string | null
+  }>(`
+    const storageMod = await import('@/lib/server/storage')
+    const providersMod = await import('@/lib/providers/index')
+    const execMod = await import('@/lib/server/chat-execution/chat-execution')
+    const storage = storageMod.default || storageMod['module.exports'] || storageMod
+    const executeSessionChatTurn = execMod.executeSessionChatTurn
+      || execMod.default?.executeSessionChatTurn
+      || execMod['module.exports']?.executeSessionChatTurn
+    const providers = providersMod.PROVIDERS
+      || providersMod.default?.PROVIDERS
+      || providersMod['module.exports']?.PROVIDERS
+
+    providers['test-codex-clear-provider'] = {
+      id: 'test-codex-clear-provider',
+      name: 'Codex Clear Test Provider',
+      models: ['unit'],
+      requiresApiKey: false,
+      requiresEndpoint: false,
+      handler: {
+        async streamChat(opts) {
+          opts.session.codexThreadId = null
+          opts.session.delegateResumeIds = {
+            ...(opts.session.delegateResumeIds || {}),
+            codex: null,
+          }
+          return 'ok'
+        },
+      },
+    }
+
+    const now = Date.now()
+    storage.saveAgents({
+      codexclear: {
+        id: 'codexclear',
+        name: 'Codex Clear Agent',
+        description: 'Codex resume id clear test',
+        provider: 'test-codex-clear-provider',
+        model: 'unit',
+        credentialId: null,
+        apiEndpoint: null,
+        fallbackCredentialIds: [],
+        disabled: false,
+        heartbeatEnabled: false,
+        heartbeatIntervalSec: null,
+        extensions: [],
+        createdAt: now,
+        updatedAt: now,
+      },
+    })
+
+    storage.saveSessions({
+      codex_clear_session: {
+        id: 'codex_clear_session',
+        name: 'Codex Clear Session',
+        cwd: process.env.WORKSPACE_DIR,
+        user: 'default',
+        provider: 'test-codex-clear-provider',
+        model: 'unit',
+        claudeSessionId: null,
+        codexThreadId: 'thread_old_123',
+        opencodeSessionId: null,
+        geminiSessionId: null,
+        copilotSessionId: null,
+        droidSessionId: null,
+        cursorSessionId: null,
+        qwenSessionId: null,
+        acpSessionId: null,
+        delegateResumeIds: { claudeCode: null, codex: 'thread_old_123', opencode: null, gemini: null, copilot: null, droid: null, cursor: null, qwen: null },
+        messages: [],
+        createdAt: now,
+        lastActiveAt: now,
+        sessionType: 'human',
+        agentId: 'codexclear',
+        extensions: [],
+      },
+    })
+
+    await executeSessionChatTurn({
+      sessionId: 'codex_clear_session',
+      message: 'hello',
+      runId: 'run-codex-clear',
+    })
+
+    const persisted = storage.loadSession('codex_clear_session')
+    console.log(JSON.stringify({
+      codexThreadId: persisted?.codexThreadId ?? null,
+      delegateCodex: persisted?.delegateResumeIds?.codex ?? null,
+    }))
+  `)
+
+  assert.equal(output.codexThreadId, null)
+  assert.equal(output.delegateCodex, null)
+})
+
 test('executeSessionChatTurn keeps tool-only heartbeats off the visible main-thread history and clears stale connector state', () => {
   const output = runWithTempDataDir<{
     connectorContext: Record<string, unknown> | null