fix: recover codex-app threads after stale session errors

Author: antoniolg

src/index.js

@@ -333,6 +333,12 @@ const agentRunner = createAgentRunner({
   resolveThreadId,
   resolveCwd: (chatId, topicId) =>
     getProjectOverride(projectOverrides, chatId, topicId) || defaultProjectDir,
+  restartSessionBackedServer: async (options) => {
+    if (options.agentId !== AGENT_CODEX_APP) {
+      throw new Error(`Unsupported session-backed agent: ${options.agentId}`);
+    }
+    await codexAppServerClient.shutdown();
+  },
   runSessionBackedChatTurn: async (options) => {
     if (options.agentId !== AGENT_CODEX_APP) {
       throw new Error(`Unsupported session-backed agent: ${options.agentId}`);

src/services/agent-runner.js

@@ -21,6 +21,7 @@ function createAgentRunner(options) {
     resolveEffectiveAgentId,
     resolveThreadId,
     resolveCwd,
+    restartSessionBackedServer,
     runSessionBackedChatTurn,
     runSessionBackedOneShot,
     setSessionBackedThreadTitle,
@@ -74,6 +75,19 @@ function createAgentRunner(options) {
     return message.includes('no rollout found for thread id ');
   }
 
+  function isRecoverableSessionBackedThreadError(err) {
+    const message = String(err?.message || '').toLowerCase();
+    return (
+      isMissingSessionBackedThreadError(err)
+      || message.includes(' is archived.')
+      || message.includes('invalid cwd:')
+      || (
+        message.includes('failed to load configuration')
+        && message.includes('operation not permitted')
+      )
+    );
+  }
+
   async function clearStaleThreadBinding(threads, threadKey) {
     if (!threadKey || !threads.has(threadKey)) return false;
     threads.delete(threadKey);
@@ -650,13 +664,24 @@ function createAgentRunner(options) {
           result = await runSessionTurn(threadId);
         } catch (err) {
           if (
-            threadId
-            && isMissingSessionBackedThreadError(err)
-            && await clearStaleThreadBinding(threads, threadKey)
+            isRecoverableSessionBackedThreadError(err)
+            && (
+              !threadId
+              || await clearStaleThreadBinding(threads, threadKey)
+            )
           ) {
-            console.warn(
-              `Cleared stale session-backed thread binding for ${threadKey}; retrying with a new thread`
-            );
+            if (threadId) {
+              console.warn(
+                `Cleared stale session-backed thread binding for ${threadKey}; retrying with a new thread`
+              );
+            } else {
+              console.warn(
+                `Recovering session-backed app-server error for ${threadKey}; retrying with a new thread`
+              );
+            }
+            if (typeof restartSessionBackedServer === 'function') {
+              await restartSessionBackedServer({ agentId: agent.id });
+            }
             result = await runSessionTurn(undefined);
           } else {
             throw err;

test/services/agent-runner.test.js

@@ -448,6 +448,103 @@ test('runAgentForChat clears a stale codex-app thread binding and retries once',
   );
 });
 
+test('runAgentForChat clears codex-app binding after configuration permission errors', async () => {
+  const calls = [];
+  const restarts = [];
+  const { runner, threads, persistedThreadSnapshots } = buildRunner({
+    getGlobalAgent: () => 'codex-app',
+    resolveEffectiveAgentId: (_chatId, _topicId, overrideAgentId) =>
+      overrideAgentId || 'codex-app',
+    resolveThreadId: (_threads, chatId, topicId, agentId) => ({
+      threadKey: `${chatId}:${topicId || 'root'}:${agentId}`,
+      threadId: threads.get(`${chatId}:${topicId || 'root'}:${agentId}`),
+      migrated: false,
+    }),
+    runSessionBackedChatTurn: async (options) => {
+      calls.push(options);
+      if (calls.length === 1) {
+        throw new Error(
+          'failed to load configuration: Operation not permitted (os error 1)'
+        );
+      }
+      return {
+        text: 'respuesta recuperada',
+        threadId: 'fresh-config-thread',
+        turnId: 'turn-fresh',
+      };
+    },
+    restartSessionBackedServer: async (options) => {
+      restarts.push(options);
+    },
+  });
+
+  threads.set('31:root:codex-app', 'permission-thread');
+  const response = await runner.runAgentForChat(31, 'recupera esto', {
+    agentId: 'codex-app',
+  });
+
+  assert.equal(response, 'respuesta recuperada');
+  assert.equal(calls.length, 2);
+  assert.deepEqual(restarts, [{ agentId: 'codex-app' }]);
+  assert.equal(calls[0].threadId, 'permission-thread');
+  assert.equal(calls[1].threadId, undefined);
+  assert.equal(threads.get('31:root:codex-app'), 'fresh-config-thread');
+  assert.equal(persistedThreadSnapshots.length, 2);
+  assert.equal(
+    persistedThreadSnapshots[0].has('31:root:codex-app'),
+    false
+  );
+});
+
+test('runAgentForChat clears archived codex-app thread bindings and retries once', async () => {
+  const calls = [];
+  const restarts = [];
+  const { runner, threads, persistedThreadSnapshots } = buildRunner({
+    getGlobalAgent: () => 'codex-app',
+    resolveEffectiveAgentId: (_chatId, _topicId, overrideAgentId) =>
+      overrideAgentId || 'codex-app',
+    resolveThreadId: (_threads, chatId, topicId, agentId) => ({
+      threadKey: `${chatId}:${topicId || 'root'}:${agentId}`,
+      threadId: threads.get(`${chatId}:${topicId || 'root'}:${agentId}`),
+      migrated: false,
+    }),
+    runSessionBackedChatTurn: async (options) => {
+      calls.push(options);
+      if (calls.length === 1) {
+        throw new Error(
+          'session archived-thread is archived. Run `codex unarchive archived-thread` to unarchive it first.'
+        );
+      }
+      return {
+        text: 'respuesta tras archivar',
+        threadId: 'fresh-archived-thread',
+        turnId: 'turn-fresh',
+      };
+    },
+    restartSessionBackedServer: async (options) => {
+      restarts.push(options);
+    },
+  });
+
+  threads.set('42:6484:codex-app', 'archived-thread');
+  const response = await runner.runAgentForChat(42, 'reserva', {
+    agentId: 'codex-app',
+    topicId: 6484,
+  });
+
+  assert.equal(response, 'respuesta tras archivar');
+  assert.equal(calls.length, 2);
+  assert.deepEqual(restarts, [{ agentId: 'codex-app' }]);
+  assert.equal(calls[0].threadId, 'archived-thread');
+  assert.equal(calls[1].threadId, undefined);
+  assert.equal(threads.get('42:6484:codex-app'), 'fresh-archived-thread');
+  assert.equal(persistedThreadSnapshots.length, 2);
+  assert.equal(
+    persistedThreadSnapshots[0].has('42:6484:codex-app'),
+    false
+  );
+});
+
 test('runAgentForChat assigns a title when a new codex-app thread is created', async () => {
   const titleCalls = [];
   const { runner } = buildRunner({