glad-web 1.0.40 → 1.0.43

package/lib/codex/structured-session.js

@@ -1,12 +1,23 @@
 const { EventEmitter } = require('events');
 const { spawn } = require('child_process');
-const readline = require('readline');
+const net = require('net');
 const crypto = require('crypto');
+const WebSocket = require('ws');
 const PTYManager = require('../session/pty-manager');
 
 const PERMISSION_MODES = new Set(['untrusted', 'on-request', 'never']);
 const SANDBOX_MODES = new Set(['read-only', 'workspace-write', 'danger-full-access']);
 const FALLBACK_EFFORTS = ['minimal', 'low', 'medium', 'high', 'xhigh', 'ultra'];
+const DEFAULT_ABORT_GRACE_MS = 5000;
+const PROCESS_SHUTDOWN_TIMEOUT_MS = 2000;
+const DEFAULT_REQUEST_TIMEOUT_MS = 30000;
+const RESUME_REQUEST_TIMEOUT_MS = 60000;
+const RESUME_HISTORY_TURN_LIMIT = 50;
+const APP_SERVER_CONNECT_TIMEOUT_MS = 10000;
+
+function turnKey(threadId, turnId) {
+  return `${String(threadId || '')}\n${String(turnId || '')}`;
+}
 
 function normalizePermissionMode(value) {
   const mode = String(value || 'default');
@@ -50,18 +61,88 @@ function toTimestampMs(value) {
 }
 
 function appServerSpawnOptions({ cwd, env, platform = process.platform }) {
-  const options = { cwd, env, stdio: ['pipe', 'pipe', 'pipe'] };
+  const options = { cwd, env, stdio: ['ignore', 'pipe', 'pipe'] };
 
   // Globally installed npm CLIs expose a .cmd shim on Windows. child_process.spawn
   // does not resolve that shim without a shell, causing `spawn codex ENOENT`.
   if (platform === 'win32') {
     options.shell = true;
     options.windowsHide = true;
+  } else {
+    // Keep the npm wrapper, native Codex binary, and MCP children in one group
+    // so a forced abort can stop the complete app-server process tree.
+    options.detached = true;
   }
 
   return options;
 }
 
+function reserveLoopbackPort() {
+  return new Promise((resolve, reject) => {
+    const server = net.createServer();
+    server.unref();
+    server.once('error', reject);
+    server.listen(0, '127.0.0.1', () => {
+      const address = server.address();
+      const port = typeof address === 'object' && address ? address.port : 0;
+      server.close(error => {
+        if (error) reject(error);
+        else if (!port) reject(new Error('Unable to reserve a loopback port for Codex app-server'));
+        else resolve(port);
+      });
+    });
+  });
+}
+
+async function connectAppServerWebSocket(url, timeoutMs = APP_SERVER_CONNECT_TIMEOUT_MS) {
+  const deadline = Date.now() + timeoutMs;
+  let lastError = new Error('Codex app-server WebSocket did not become ready');
+  while (Date.now() < deadline) {
+    try {
+      return await new Promise((resolve, reject) => {
+        const socket = new WebSocket(url);
+        const onOpen = () => {
+          socket.off('error', onError);
+          resolve(socket);
+        };
+        const onError = error => {
+          socket.off('open', onOpen);
+          socket.terminate();
+          reject(error);
+        };
+        socket.once('open', onOpen);
+        socket.once('error', onError);
+      });
+    } catch (error) {
+      lastError = error;
+      await new Promise(resolve => setTimeout(resolve, 50));
+    }
+  }
+  throw lastError;
+}
+
+function forceKillProcessTree(child, options = {}) {
+  const platform = options.platform || process.platform;
+  const killGroup = options.killGroup || process.kill;
+  const spawnProcess = options.spawnProcess || spawn;
+  if (!child?.pid) return false;
+  if (platform !== 'win32') {
+    try {
+      killGroup(-child.pid, 'SIGKILL');
+      return true;
+    } catch (_error) {
+      try { return child.kill('SIGKILL'); } catch (_) { return false; }
+    }
+  }
+  const killer = spawnProcess('taskkill', ['/pid', String(child.pid), '/t', '/f'], {
+    stdio: 'ignore', windowsHide: true
+  });
+  killer.once('error', () => {
+    try { child.kill('SIGKILL'); } catch (_) { /* process already exited */ }
+  });
+  return true;
+}
+
 function textFromInputItems(content) {
   return (Array.isArray(content) ? content : [])
     .filter(item => item && item.type === 'text')
@@ -232,7 +313,19 @@ class CodexStructuredSession extends EventEmitter {
     this.requestId = 0;
     this.pendingRequests = new Map();
     this.process = null;
+    this.rpcSocket = null;
     this.processReady = null;
+    this.processShutdown = null;
+    this.needsThreadResume = false;
+    this.resuming = false;
+    this.resumePromise = null;
+    this.resumeTarget = null;
+    this.aborting = false;
+    this.abortTargets = new Map();
+    this.abortTimer = null;
+    this.abortGraceMs = Number(options.abortGraceMs) > 0
+      ? Number(options.abortGraceMs) : DEFAULT_ABORT_GRACE_MS;
+    this.forceKillProcessTree = options.forceKillProcessTree || forceKillProcessTree;
     this.terminalSession = null;
     this.terminalOutput = '';
     this.hasUnreadCompletion = false;
@@ -312,10 +405,13 @@ class CodexStructuredSession extends EventEmitter {
       effectivePermissionMode: this.effectivePermissionMode, effectiveSandboxMode: this.effectiveSandboxMode,
       model: this.model, effort: this.effort,
       status: this.status, threadId: this.threadId, presentation: this.presentation,
-      canAbort: this.presentation === 'structured' && this.status !== 'idle',
-      canCompact: this.presentation === 'structured' && this.status === 'idle' && !this.compacting && Boolean(this.threadId),
+      aborting: this.aborting, resuming: this.resuming,
+      canAbort: this.presentation === 'structured' && (this.status !== 'idle' || this.resuming) && !this.aborting,
+      canCompact: this.presentation === 'structured' && this.status === 'idle' && !this.compacting
+        && !this.aborting && !this.resuming && Boolean(this.threadId),
       compacting: this.compacting,
-      canSwitchToTerminal: this.presentation === 'structured' && this.status === 'idle' && Boolean(this.threadId),
+      canSwitchToTerminal: this.presentation === 'structured' && this.status === 'idle'
+        && !this.aborting && !this.resuming && Boolean(this.threadId),
       canSwitchToStructured: this.presentation === 'terminal',
       pendingPermissionCount: this.pendingPermissions.size, activeSubagentCount, models: this.models };
   }
@@ -362,72 +458,176 @@ class CodexStructuredSession extends EventEmitter {
     return completed;
   }
 
+  clearAbortState(emit = true) {
+    const changed = this.aborting;
+    if (this.abortTimer) clearTimeout(this.abortTimer);
+    this.abortTimer = null;
+    this.abortTargets.clear();
+    this.aborting = false;
+    if (emit && changed) this.emitControlState();
+  }
+
+  finishAbortIfComplete() {
+    if (!this.aborting || this.abortTargets.size) return false;
+    this.clearAbortState(false);
+    const hasActiveTurn = this.currentTurnId
+      || Array.from(this.threadTurns.values()).some(turn => turn?.status === 'running');
+    if (!hasActiveTurn && this.status !== 'idle') this.setStatus('idle');
+    else this.emitControlState();
+    return true;
+  }
+
   async ensureProcess() {
+    if (this.processShutdown) await this.processShutdown;
     if (this.processReady) return this.processReady;
-    this.processReady = new Promise((resolve, reject) => {
-      const child = spawn(this.tool.command, ['app-server', '--listen', 'stdio://'], appServerSpawnOptions({
-        cwd: this.workingDir,
-        env: { ...process.env }
-      }));
-      this.process = child;
-      const fail = error => {
-        this.processReady = null;
-        this.process = null;
-        reject(error instanceof Error ? error : new Error(String(error)));
-      };
-      child.once('error', fail);
-      child.once('exit', code => {
-        if (this.process === child) {
+    let startup;
+    startup = (async () => {
+      const port = await reserveLoopbackPort();
+      return new Promise((resolve, reject) => {
+        const listenUrl = `ws://127.0.0.1:${port}`;
+        // ARM64 Docker 中的大响应可能让非阻塞 stdio pipe 返回 EAGAIN。
+        // loopback WebSocket 保持连接只在容器内部可见，同时避开该传输缺陷。
+        const child = spawn(this.tool.command, ['app-server', '--listen', listenUrl], appServerSpawnOptions({
+          cwd: this.workingDir,
+          env: { ...process.env }
+        }));
+        this.process = child;
+        const fail = error => {
+          if (this.process === child) void this.disconnectProcess(true, error);
+          if (this.processReady === startup) this.processReady = null;
+          reject(error instanceof Error ? error : new Error(String(error)));
+        };
+        const transportFailed = error => {
+          if (this.process !== child) return;
+          const failure = error instanceof Error ? error : new Error(String(error || 'Codex app-server transport closed'));
+          this.logger.debugInfo?.(`[codex-app-server] transport failed: ${failure.message}`);
+          this.needsThreadResume = Boolean(this.threadId || this.resumeTarget);
+          if (this.running && this.presentation === 'structured') {
+            const activeTurn = Boolean(this.currentTurnId || this.status === 'running' || this.status === 'waiting_approval');
+            this.clearAbortState(false);
+            this.compacting = false;
+            this.append({ kind: 'event', level: 'error', text: `Codex app-server connection failed: ${failure.message}` });
+            this.emitEvent({ type: 'runtime-disconnected', activeTurn, turnId: this.currentTurnId || null });
+            if (this.status !== 'idle') this.setStatus('idle');
+            else this.emitControlState();
+          }
+          void this.disconnectProcess(true, failure);
+        };
+        child.once('error', transportFailed);
+        child.once('exit', code => {
+          if (this.process !== child) return;
           this.process = null;
           this.processReady = null;
-          for (const request of this.pendingRequests.values()) request.reject(new Error(`Codex app-server exited (${code})`));
+          const socket = this.rpcSocket;
+          this.rpcSocket = null;
+          socket?.terminate();
+          for (const request of this.pendingRequests.values()) {
+            clearTimeout(request.timer);
+            request.reject(new Error(`Codex app-server exited (${code})`));
+          }
           this.pendingRequests.clear();
           if (this.running && this.presentation === 'structured') {
             const activeTurn = Boolean(this.currentTurnId || this.status === 'running' || this.status === 'waiting_approval');
+            this.needsThreadResume = Boolean(this.threadId);
+            this.clearAbortState(false);
             this.compacting = false;
             this.append({ kind: 'event', level: 'error', text: 'Codex app-server exited.' });
-            this.emitEvent({
-              type: 'runtime-disconnected',
-              activeTurn,
-              turnId: this.currentTurnId || null
-            });
+            this.emitEvent({ type: 'runtime-disconnected', activeTurn, turnId: this.currentTurnId || null });
             this.setStatus('idle');
           }
-        }
-      });
-      child.stderr.on('data', data => this.logger.debugInfo?.(`[codex-app-server] ${String(data).trim()}`));
-      const lines = readline.createInterface({ input: child.stdout });
-      lines.on('line', line => this.handleRpcLine(line));
-      this.request('initialize', { clientInfo: { name: 'glad-web', title: 'Glad', version: '1.0' }, capabilities: { experimentalApi: true } })
-        .then(async () => {
+        });
+        const logOutput = data => this.logger.debugInfo?.(`[codex-app-server] ${String(data).trim()}`);
+        child.stdout.on('data', logOutput);
+        child.stderr.on('data', logOutput);
+        connectAppServerWebSocket(listenUrl).then(socket => {
+          if (this.process !== child) {
+            socket.terminate();
+            throw new Error('Codex app-server stopped while connecting');
+          }
+          this.rpcSocket = socket;
+          socket.on('message', data => this.handleRpcLine(String(data)));
+          socket.once('error', transportFailed);
+          socket.once('close', (code, reason) => {
+            transportFailed(new Error(`Codex app-server WebSocket closed (${code}${reason?.length ? `: ${String(reason)}` : ''})`));
+          });
+          return this.request('initialize', {
+            clientInfo: { name: 'glad-web', title: 'Glad', version: '1.0' },
+            capabilities: { experimentalApi: true }
+          }, { fatalOnTimeout: true });
+        }).then(async () => {
+          this.notify('initialized', {});
           try { await this.refreshConfigDefaults(); } catch (error) { this.logger.debugInfo?.(`[codex-app-server] config/read failed: ${error.message}`); }
           try { await this.refreshModels(); } catch (error) { this.logger.debugInfo?.(`[codex-app-server] model/list failed: ${error.message}`); }
           resolve();
         }).catch(fail);
-    });
-    return this.processReady;
+      });
+    })();
+    this.processReady = startup;
+    try {
+      return await startup;
+    } catch (error) {
+      if (this.processReady === startup) this.processReady = null;
+      throw error;
+    }
   }
 
-  request(method, params) {
-    if (!this.process || !this.process.stdin?.writable) return Promise.reject(new Error('Codex app-server is not connected'));
+  request(method, params, options = {}) {
+    if (!this.process || this.rpcSocket?.readyState !== WebSocket.OPEN) {
+      return Promise.reject(new Error('Codex app-server is not connected'));
+    }
+    const child = this.process;
+    const socket = this.rpcSocket;
+    const timeoutMs = Number(options.timeoutMs) > 0 ? Number(options.timeoutMs) : DEFAULT_REQUEST_TIMEOUT_MS;
+    const fatalOnTimeout = Boolean(options.fatalOnTimeout);
     const id = ++this.requestId;
     return new Promise((resolve, reject) => {
-      const timer = setTimeout(() => { this.pendingRequests.delete(id); reject(new Error(`${method} timed out`)); }, 30000);
+      const fail = error => {
+        const pending = this.pendingRequests.get(id);
+        if (!pending) return;
+        clearTimeout(pending.timer);
+        this.pendingRequests.delete(id);
+        reject(error);
+      };
+      const timer = setTimeout(() => {
+        const error = new Error(`${method} timed out after ${Math.max(1, Math.round(timeoutMs / 1000))} seconds`);
+        fail(error);
+        // 生命周期请求超时后连接状态未知，必须启动新的 app-server。
+        if (fatalOnTimeout && this.process === child) void this.disconnectProcess(true, error);
+      }, timeoutMs);
       this.pendingRequests.set(id, { resolve, reject, timer });
-      this.process.stdin.write(JSON.stringify({ jsonrpc: '2.0', id, method, params }) + '\n');
+      try {
+        socket.send(JSON.stringify({ jsonrpc: '2.0', id, method, params }), error => {
+          if (!error) return;
+          fail(error);
+          if (this.process === child) void this.disconnectProcess(true, error);
+        });
+      } catch (error) {
+        fail(error);
+        if (this.process === child) void this.disconnectProcess(true, error);
+      }
     });
   }
 
   notify(method, params) {
-    if (!this.process || !this.process.stdin?.writable) return false;
-    this.process.stdin.write(JSON.stringify({ jsonrpc: '2.0', method, params }) + '\n');
-    return true;
+    return this.sendRpcMessage({ jsonrpc: '2.0', method, params });
   }
 
   respond(id, result) {
-    if (!this.process || !this.process.stdin?.writable) return false;
-    this.process.stdin.write(JSON.stringify({ jsonrpc: '2.0', id, result }) + '\n');
-    return true;
+    return this.sendRpcMessage({ jsonrpc: '2.0', id, result });
+  }
+
+  sendRpcMessage(message) {
+    if (!this.process || this.rpcSocket?.readyState !== WebSocket.OPEN) return false;
+    const child = this.process;
+    try {
+      this.rpcSocket.send(JSON.stringify(message), error => {
+        if (error && this.process === child) void this.disconnectProcess(true, error);
+      });
+      return true;
+    } catch (error) {
+      if (this.process === child) void this.disconnectProcess(true, error);
+      return false;
+    }
   }
 
   handleRpcLine(line) {
@@ -514,8 +714,16 @@ class CodexStructuredSession extends EventEmitter {
       const durationMs = Number(params.turn?.durationMs || 0)
         || (startedAtMs ? Math.max(0, completedAtMs - startedAtMs) : null);
       const context = this.turnContexts.get(String(completedTurnId || ''));
-      this.append({ kind: 'turn-end', threadId, turnId: completedTurnId, status: turnStatus,
-        durationMs, createdAt: completedAtMs, ...(context ? { context } : {}) });
+      const existingTurnEnd = this.messages.find(item => item.kind === 'turn-end'
+        && item.threadId === threadId && item.turnId === completedTurnId);
+      if (existingTurnEnd) {
+        this.patch(existingTurnEnd.id, { status: turnStatus, durationMs,
+          createdAt: completedAtMs, ...(context ? { context } : {}) });
+      } else {
+        this.append({ kind: 'turn-end', threadId, turnId: completedTurnId, status: turnStatus,
+          durationMs, createdAt: completedAtMs, ...(context ? { context } : {}) });
+      }
+      this.abortTargets.delete(turnKey(threadId, completedTurnId));
       const observedNow = Date.now();
       const observedCompletedAtMs = Math.abs(observedNow - completedAtMs) < 5000
         ? Math.max(completedAtMs, observedNow) : completedAtMs;
@@ -543,11 +751,12 @@ class CodexStructuredSession extends EventEmitter {
         if (params.turn?.status === 'failed' || params.turn?.error) {
           this.append({ kind: 'event', level: 'error', text: params.turn?.error?.message || 'Codex turn failed.' });
         }
-        this.setStatus('idle');
+        this.setStatus(this.aborting && this.abortTargets.size ? 'running' : 'idle');
         this.hasUnreadCompletion = true;
       } else {
         this.emitControlState();
       }
+      this.finishAbortIfComplete();
       return;
     }
     if (method === 'thread/compacted') {
@@ -568,7 +777,7 @@ class CodexStructuredSession extends EventEmitter {
       const status = params.status?.type || params.status;
       if (!threadId || threadId === this.threadId) {
         if (status === 'idle' && !this.currentTurnId) { this.compacting = false; this.setStatus('idle'); }
-        if (status === 'active') this.setStatus('running');
+        if (status === 'active' && !this.aborting) this.setStatus('running');
       }
       return;
     }
@@ -760,6 +969,37 @@ class CodexStructuredSession extends EventEmitter {
     return config;
   }
 
+  async readRecentThread(thread, limit = RESUME_HISTORY_TURN_LIMIT, options = {}) {
+    const summary = thread && typeof thread === 'object' ? thread : {};
+    const embeddedTurns = Array.isArray(summary.turns) ? summary.turns.slice(-limit) : [];
+    try {
+      const newestFirst = [];
+      let cursor = null;
+      do {
+        const result = await this.request('thread/turns/list', {
+          threadId: summary.id,
+          cursor,
+          limit: Math.min(100, limit - newestFirst.length),
+          sortDirection: 'desc',
+          itemsView: 'full'
+        }, options);
+        newestFirst.push(...(Array.isArray(result?.data) ? result.data : []));
+        cursor = result?.nextCursor || null;
+      } while (cursor && newestFirst.length < limit);
+      return {
+        ...summary,
+        // app-server 默认从新到旧返回，页面仍按时间顺序展示。
+        turns: newestFirst.slice().reverse(),
+        historyNextCursor: cursor
+      };
+    } catch (error) {
+      this.logger.debugInfo?.(`[codex-app-server] paginated history unavailable for ${summary.id || 'unknown'}: ${error.message}`);
+      const unsupported = /method.*not found|unsupported|experimental/i.test(String(error.message || ''));
+      if (options.fatalOnTimeout && !unsupported) throw error;
+      return { ...summary, turns: embeddedTurns, historyNextCursor: null };
+    }
+  }
+
   async listResumeThreads() {
     await this.ensureProcess();
     const result = await this.request('thread/list', {
@@ -775,8 +1015,8 @@ class CodexStructuredSession extends EventEmitter {
     for (const item of threads) {
       let questions = [];
       try {
-        const history = await this.request('thread/read', { threadId: item.id, includeTurns: true });
-        questions = recentUserQuestions(history?.thread);
+        const history = await this.readRecentThread(item, 8);
+        questions = recentUserQuestions(history);
       } catch (error) {
         this.logger.debugInfo?.(`[codex-app-server] unable to read resume preview for ${item.id}: ${error.message}`);
       }
@@ -818,20 +1058,24 @@ class CodexStructuredSession extends EventEmitter {
         const threads = (result?.data || []).filter(item => !item.parentThreadId);
         const histories = await Promise.all(threads.map(async item => {
           try {
-            const history = await this.request('thread/read', { threadId: item.id, includeTurns: true });
+            const history = await this.readRecentThread(item, 200);
             const fallbackTimestamp = toTimestampMs(item.updatedAt || item.createdAt);
-            return userPromptsFromThread(history?.thread || { id: item.id, turns: [] }, fallbackTimestamp)
-              .map(prompt => ({ ...prompt, threadId: prompt.threadId || item.id }));
+            return {
+              prompts: userPromptsFromThread(history || { id: item.id, turns: [] }, fallbackTimestamp)
+                .map(prompt => ({ ...prompt, threadId: prompt.threadId || item.id })),
+              capped: Boolean(history.historyNextCursor)
+            };
           } catch (error) {
             this.logger.debugInfo?.(`[codex-app-server] unable to read prompt history for ${item.id}: ${error.message}`);
-            return [];
+            return { prompts: [], capped: false };
           }
         }));
-        prompts.push(...histories.flat());
+        prompts.push(...histories.flatMap(history => history.prompts));
+        if (histories.some(history => history.capped)) capped = true;
         cursor = result?.nextCursor || null;
         pageCount += 1;
         if (prompts.length >= 200 || pageCount >= 5) {
-          capped = Boolean(cursor) || prompts.length > 200;
+          capped = capped || Boolean(cursor) || prompts.length > 200;
           break;
         }
       } while (cursor);
@@ -952,11 +1196,35 @@ class CodexStructuredSession extends EventEmitter {
     return this.getControlState();
   }
 
+  async resumeThreadAfterProcessRestart() {
+    if (!this.threadId || !this.needsThreadResume) return false;
+    const result = await this.request('thread/resume', this.threadResumeParams(this.threadId), {
+      timeoutMs: RESUME_REQUEST_TIMEOUT_MS,
+      fatalOnTimeout: true
+    });
+    this.needsThreadResume = false;
+    this.model = result.model || result.thread?.model || this.model;
+    this.effort = result.reasoningEffort || result.thread?.reasoningEffort || this.effort;
+    this.effectivePermissionMode = result.approvalPolicy || this.effectivePermissionMode;
+    this.effectiveSandboxMode = sandboxModeFromPolicy(result.sandbox) || this.effectiveSandboxMode;
+    return true;
+  }
+
+  threadResumeParams(threadId) {
+    const params = { threadId, cwd: this.workingDir };
+    if (this.permissionMode) params.approvalPolicy = this.permissionMode;
+    if (this.sandboxMode) params.sandbox = this.sandboxMode;
+    if (this.hasModelOverride && this.model) params.model = this.model;
+    if (this.hasEffortOverride && this.effort) params.config = { model_reasoning_effort: this.effort };
+    return params;
+  }
+
   async sendUserMessage(text, attachments = [], skills = []) {
     const prompt = String(text || '').trim();
     const images = (Array.isArray(attachments) ? attachments : [])
       .filter(item => item && typeof item.path === 'string' && item.path);
-    if ((!prompt && images.length === 0) || this.presentation !== 'structured' || this.status !== 'idle') return false;
+    if ((!prompt && images.length === 0) || this.presentation !== 'structured'
+      || this.status !== 'idle' || this.aborting || this.resuming) return false;
     this.hasUnreadCompletion = false;
     this.promptHistoryCache = null;
     this.append({
@@ -967,8 +1235,10 @@ class CodexStructuredSession extends EventEmitter {
         name: String(item?.name || ''), path: String(item?.path || '')
       })).filter(item => item.name && item.path)
     });
+    this.setStatus('running');
     try {
       await this.ensureProcess();
+      await this.resumeThreadAfterProcessRestart();
       if (!this.threadId) {
         const params = { cwd: this.workingDir };
         if (this.hasModelOverride) params.model = this.model;
@@ -976,13 +1246,13 @@ class CodexStructuredSession extends EventEmitter {
         if (this.sandboxMode) params.sandbox = this.sandboxMode;
         const started = await this.request('thread/start', params);
         this.threadId = started.thread?.id;
+        this.needsThreadResume = false;
         this.model = started.model || this.model;
         this.effort = started.reasoningEffort || this.effort;
         this.effectivePermissionMode = started.approvalPolicy || this.effectivePermissionMode;
         this.effectiveSandboxMode = sandboxModeFromPolicy(started.sandbox) || this.effectiveSandboxMode;
         this.emitEvent({ type: 'state', state: this.getControlState() });
       }
-      this.setStatus('running');
       const input = [];
       input.push(...await this.resolveSkillInputs(skills));
       if (prompt) input.push({ type: 'text', text: prompt });
@@ -1008,7 +1278,8 @@ class CodexStructuredSession extends EventEmitter {
   }
 
   async compactContext() {
-    if (!this.threadId || this.presentation !== 'structured' || this.status !== 'idle') return false;
+    if (!this.threadId || this.presentation !== 'structured' || this.status !== 'idle'
+      || this.aborting || this.resuming) return false;
     await this.ensureProcess();
     this.compacting = true;
     this.setStatus('running');
@@ -1059,7 +1330,17 @@ class CodexStructuredSession extends EventEmitter {
   }
 
   abort(reason = 'Aborted by user') {
-    if (this.presentation !== 'structured' || this.status === 'idle') return false;
+    if (this.presentation !== 'structured' || (this.status === 'idle' && !this.resuming)) return false;
+    if (this.aborting) return true;
+    if (this.resuming) {
+      this.aborting = true;
+      this.needsThreadResume = Boolean(this.threadId || this.resumeTarget);
+      this.emitControlState();
+      this.append({ kind: 'event', level: 'info', text: reason });
+      const error = new Error('Codex resume aborted by user');
+      void this.disconnectProcess(true, error);
+      return true;
+    }
     for (const pending of this.pendingPermissions.values()) {
       const response = pending.method === 'item/permissions/requestApproval'
         ? { permissions: {}, scope: 'turn' }
@@ -1077,40 +1358,108 @@ class CodexStructuredSession extends EventEmitter {
       && !targets.some(target => target.threadId === this.threadId && target.turnId === this.currentTurnId)) {
       targets.push({ threadId: this.threadId, turnId: this.currentTurnId });
     }
+    this.aborting = true;
+    this.abortTargets = new Map(targets.map(target => [turnKey(target.threadId, target.turnId), target]));
+    this.emitControlState();
     for (const target of targets) {
       this.request('turn/interrupt', target).catch(error => {
         this.logger.debugInfo?.(`[codex-app-server] turn/interrupt failed for ${target.threadId}/${target.turnId}: ${error.message}`);
       });
     }
     this.append({ kind: 'event', level: 'info', text: reason });
+    this.abortTimer = setTimeout(() => this.forceAbortAfterTimeout(), this.abortGraceMs);
+    this.abortTimer.unref?.();
     return true;
   }
 
-  async resume(threadId = null) {
+  forceAbortAfterTimeout() {
+    if (!this.aborting) return false;
+    const targets = Array.from(this.abortTargets.values());
+    const completedAtMs = Date.now();
+    const timeoutSeconds = Math.max(1, Math.round(this.abortGraceMs / 1000));
+    this.append({ kind: 'event', level: 'warning',
+      text: `Codex did not stop within ${timeoutSeconds} seconds. Stopping its app-server.` });
+
+    for (const target of targets) {
+      const tracked = this.threadTurns.get(target.threadId);
+      const startedAtMs = Number(tracked?.startedAt || 0)
+        || (target.threadId === this.threadId ? Number(this.currentTurnStartedAt || 0) : 0);
+      const existingTurnEnd = this.messages.find(item => item.kind === 'turn-end'
+        && item.threadId === target.threadId && item.turnId === target.turnId);
+      if (!existingTurnEnd) {
+        this.append({ kind: 'turn-end', threadId: target.threadId, turnId: target.turnId,
+          status: 'cancelled', durationMs: startedAtMs ? Math.max(0, completedAtMs - startedAtMs) : null,
+          createdAt: completedAtMs });
+      }
+    }
+    for (const item of this.messages.filter(message => message.kind === 'tool'
+      && ['running', 'inProgress'].includes(message.toolStatus))) {
+      const startedAtMs = Number(item.startedAtMs || item.createdAt || 0);
+      this.patch(item.id, { toolStatus: 'cancelled', completedAtMs,
+        ...(startedAtMs ? { durationMs: Math.max(1, completedAtMs - startedAtMs) } : {}) });
+    }
+
+    this.needsThreadResume = Boolean(this.threadId);
+    this.currentTurnId = null;
+    this.currentTurnStartedAt = null;
+    this.threadTurns.clear();
+    this.pendingPermissions.clear();
+    this.compacting = false;
+    this.hasUnreadCompletion = true;
+    this.clearAbortState(false);
+    void this.disconnectProcess(true);
+    if (this.status !== 'idle') this.setStatus('idle');
+    else this.emitControlState();
+    this.append({ kind: 'event', level: 'info',
+      text: 'Codex app-server stopped. It will restart before the next message.' });
+    return true;
+  }
+
+  resume(threadId = null) {
     const target = String(threadId || this.threadId || '').trim();
-    if (!target || this.presentation !== 'structured' || this.status !== 'idle') return false;
+    if (!target || this.presentation !== 'structured' || this.status !== 'idle' || this.aborting) return false;
+    if (this.resumePromise) return target === this.resumeTarget ? this.resumePromise : false;
+    this.resuming = true;
+    this.resumeTarget = target;
+    this.emitControlState();
+    let tracked;
+    tracked = this.performResume(target).finally(() => {
+      if (this.resumePromise !== tracked) return;
+      this.resumePromise = null;
+      this.resumeTarget = null;
+      this.resuming = false;
+      this.clearAbortState(false);
+      this.emitControlState();
+    });
+    this.resumePromise = tracked;
+    return tracked;
+  }
+
+  async performResume(target) {
     await this.ensureProcess();
     const selectedModel = this.model;
     const selectedEffort = this.effort;
     const resumeWithModelOverride = Boolean(this.hasModelOverride && selectedModel);
     const resumeWithEffortOverride = Boolean(this.hasEffortOverride && selectedEffort);
-    const params = { threadId: target, cwd: this.workingDir };
-    if (this.permissionMode) params.approvalPolicy = this.permissionMode;
-    if (this.sandboxMode) params.sandbox = this.sandboxMode;
-    if (resumeWithModelOverride) params.model = selectedModel;
-    if (resumeWithEffortOverride) params.config = { model_reasoning_effort: selectedEffort };
+    const params = this.threadResumeParams(target);
     this.deferredWarnings = [];
     try {
-      const result = await this.request('thread/resume', params);
+      const result = await this.request('thread/resume', params, {
+        timeoutMs: RESUME_REQUEST_TIMEOUT_MS,
+        fatalOnTimeout: true
+      });
       this.threadId = result.thread?.id || target;
+      this.needsThreadResume = false;
       this.hasModelOverride = resumeWithModelOverride;
       this.hasEffortOverride = resumeWithEffortOverride;
       this.model = result.model || result.thread?.model || selectedModel;
       this.effort = result.reasoningEffort || result.thread?.reasoningEffort || selectedEffort;
       this.effectivePermissionMode = result.approvalPolicy || this.effectivePermissionMode;
       this.effectiveSandboxMode = sandboxModeFromPolicy(result.sandbox) || this.effectiveSandboxMode;
-      const history = await this.request('thread/read', { threadId: this.threadId, includeTurns: true });
-      this.restoreThreadHistory(history?.thread, `Resumed Codex thread ${this.threadId}`, {
+      const history = await this.readRecentThread({ ...(result.thread || {}), id: this.threadId },
+        RESUME_HISTORY_TURN_LIMIT, { timeoutMs: RESUME_REQUEST_TIMEOUT_MS, fatalOnTimeout: true });
+      const historyNote = history.historyNextCursor ? ' · showing the latest 50 turns' : '';
+      this.restoreThreadHistory(history, `Resumed Codex thread ${this.threadId}${historyNote}`, {
         preserveModel: resumeWithModelOverride,
         preserveEffort: resumeWithEffortOverride
       });
@@ -1120,9 +1469,14 @@ class CodexStructuredSession extends EventEmitter {
       this.promptHistoryCache = null;
       return true;
     } catch (error) {
+      const aborted = this.aborting || /resume aborted/i.test(error.message);
       const warnings = this.deferredWarnings || [];
       this.deferredWarnings = null;
       for (const warning of warnings) this.append(warning);
+      this.needsThreadResume = Boolean(this.threadId || target);
+      await this.disconnectProcess(true, error);
+      this.append({ kind: 'event', level: aborted ? 'info' : 'error',
+        text: aborted ? 'Codex conversation recovery stopped.' : `Unable to resume Codex conversation: ${error.message}` });
       throw error;
     }
   }
@@ -1138,24 +1492,24 @@ class CodexStructuredSession extends EventEmitter {
     this.providerItemContexts.clear();
     try {
       for (const turn of thread?.turns || []) {
-      const status = turn.status === 'failed' ? 'failed' : turn.status === 'interrupted' ? 'cancelled' : 'completed';
-      const startedAt = Number(turn.startedAt || turn.createdAt || 0);
-      const completedAt = Number(turn.completedAt || turn.updatedAt || 0);
-      const toMilliseconds = value => value > 0 && value < 100000000000 ? value * 1000 : value;
-      const startedAtMs = toMilliseconds(startedAt);
-      const completedAtMs = toMilliseconds(completedAt);
-      this.append({ kind: 'turn-start', turnId: turn.id, ...(startedAtMs ? { createdAt: startedAtMs } : {}) });
-      for (const item of turn.items || []) {
-        this.applyProviderItem({ ...item, turnId: turn.id }, status === 'failed' ? 'failed' : 'completed', {
-          threadId: this.threadId,
-          startedAtMs,
-          completedAtMs
-        });
-      }
-      const durationMs = Number(turn.durationMs || turn.duration_ms || 0)
-        || (startedAtMs && completedAtMs && completedAtMs >= startedAtMs ? completedAtMs - startedAtMs : null);
-      this.append({ kind: 'turn-end', turnId: turn.id, status, durationMs,
-        ...(completedAtMs ? { createdAt: completedAtMs } : {}) });
+        const status = turn.status === 'failed' ? 'failed' : turn.status === 'interrupted' ? 'cancelled' : 'completed';
+        const startedAt = Number(turn.startedAt || turn.createdAt || 0);
+        const completedAt = Number(turn.completedAt || turn.updatedAt || 0);
+        const toMilliseconds = value => value > 0 && value < 100000000000 ? value * 1000 : value;
+        const startedAtMs = toMilliseconds(startedAt);
+        const completedAtMs = toMilliseconds(completedAt);
+        this.append({ kind: 'turn-start', turnId: turn.id, ...(startedAtMs ? { createdAt: startedAtMs } : {}) });
+        for (const item of turn.items || []) {
+          this.applyProviderItem({ ...item, turnId: turn.id }, status === 'failed' ? 'failed' : 'completed', {
+            threadId: this.threadId,
+            startedAtMs,
+            completedAtMs
+          });
+        }
+        const durationMs = Number(turn.durationMs || turn.duration_ms || 0)
+          || (startedAtMs && completedAtMs && completedAtMs >= startedAtMs ? completedAtMs - startedAtMs : null);
+        this.append({ kind: 'turn-end', turnId: turn.id, status, durationMs,
+          ...(completedAtMs ? { createdAt: completedAtMs } : {}) });
       }
       if (eventText) this.append({ kind: 'event', level: 'info', text: eventText });
     } finally {
@@ -1167,7 +1521,8 @@ class CodexStructuredSession extends EventEmitter {
 
   async forkFrom(threadId) {
     const sourceThreadId = String(threadId || '').trim();
-    if (!sourceThreadId || this.presentation !== 'structured' || this.status !== 'idle') return false;
+    if (!sourceThreadId || this.presentation !== 'structured' || this.status !== 'idle'
+      || this.aborting || this.resuming) return false;
     await this.ensureProcess();
     const params = { threadId: sourceThreadId, cwd: this.workingDir, ephemeral: false, threadSource: null };
     if (this.hasModelOverride) params.model = this.model;
@@ -1177,6 +1532,7 @@ class CodexStructuredSession extends EventEmitter {
     const forkedThread = result?.thread;
     if (!forkedThread?.id) throw new Error('Codex did not return a forked thread');
     this.threadId = forkedThread.id;
+    this.needsThreadResume = false;
     this.model = result.model || forkedThread.model || this.model;
     this.effort = result.reasoningEffort || forkedThread.reasoningEffort || forkedThread.reasoning_effort || this.effort;
     this.effectivePermissionMode = result.approvalPolicy || this.effectivePermissionMode;
@@ -1187,7 +1543,8 @@ class CodexStructuredSession extends EventEmitter {
   }
 
   async switchToTerminal() {
-    if (this.presentation !== 'structured' || this.status !== 'idle' || !this.threadId) throw new Error('Codex must be idle before switching to Terminal.');
+    if (this.presentation !== 'structured' || this.status !== 'idle' || this.aborting
+      || this.resuming || !this.threadId) throw new Error('Codex must be idle before switching to Terminal.');
     await this.disconnectProcess();
     this.terminalOutput = '';
     const terminal = new PTYManager(this.tool, this.workingDir, { append() {} }, { silent: true });
@@ -1218,19 +1575,53 @@ class CodexStructuredSession extends EventEmitter {
     return this.resume();
   }
 
-  async disconnectProcess() {
-    if (!this.process) return;
+  async disconnectProcess(force = false, reason = null) {
+    if (!this.process) return this.processShutdown || undefined;
     const child = this.process;
     this.process = null;
     this.processReady = null;
-    for (const request of this.pendingRequests.values()) { clearTimeout(request.timer); request.reject(new Error('Codex app-server disconnected')); }
+    const socket = this.rpcSocket;
+    this.rpcSocket = null;
+    socket?.terminate();
+    const disconnectError = reason instanceof Error ? reason : new Error('Codex app-server disconnected');
+    for (const request of this.pendingRequests.values()) { clearTimeout(request.timer); request.reject(disconnectError); }
     this.pendingRequests.clear();
-    child.kill();
+    const shutdown = typeof child.once === 'function'
+      ? new Promise(resolve => {
+        let timer;
+        const finish = () => { clearTimeout(timer); resolve(); };
+        child.once('exit', finish);
+        timer = setTimeout(() => {
+          this.logger.debugInfo?.('[codex-app-server] process did not exit within 2 seconds');
+          finish();
+        }, PROCESS_SHUTDOWN_TIMEOUT_MS);
+      })
+      : Promise.resolve();
+    this.processShutdown = shutdown;
+    if (force) this.forceKillProcessTree(child);
+    else child.kill();
+    try {
+      await shutdown;
+    } finally {
+      if (this.processShutdown === shutdown) this.processShutdown = null;
+    }
   }
 
   markCompletionRead() { this.hasUnreadCompletion = false; this.completionReadInputSeq = this.inputSeq; }
-  kill() { this.running = false; this.terminalSession?.kill(); this.terminalSession = null; void this.disconnectProcess(); this.emit('exit'); }
+  async kill() {
+    this.running = false;
+    this.clearAbortState(false);
+    this.resuming = false;
+    this.resumeTarget = null;
+    this.terminalSession?.kill();
+    this.terminalSession = null;
+    await this.disconnectProcess(true);
+    this.emit('exit');
+  }
 }
 
 module.exports = CodexStructuredSession;
 module.exports.appServerSpawnOptions = appServerSpawnOptions;
+module.exports.forceKillProcessTree = forceKillProcessTree;
+module.exports.reserveLoopbackPort = reserveLoopbackPort;
+module.exports.connectAppServerWebSocket = connectAppServerWebSocket;

package/lib/commands/web.js

@@ -276,8 +276,8 @@ async function webCommand(options) {
   });
 
   // API: Delete/Kill session
-  app.delete('/api/sessions/:id', (req, res) => {
-    sessionManager.kill(req.params.id);
+  app.delete('/api/sessions/:id', async (req, res) => {
+    await sessionManager.kill(req.params.id);
     res.json({ success: true });
   });
 

package/lib/session/session-manager.js

@@ -409,7 +409,7 @@ class SessionManager extends EventEmitter {
   async forkCodex(id, threadId) {
     const session = this.get(id);
     if (!session || session.kind !== 'codex-structured') return null;
-    if (session.presentation !== 'structured' || session.status !== 'idle') {
+    if (session.presentation !== 'structured' || session.status !== 'idle' || session.resuming) {
       const error = new Error('Codex must be idle in chat mode before forking');
       error.statusCode = 409;
       throw error;
@@ -610,7 +610,7 @@ class SessionManager extends EventEmitter {
     return true;
   }
 
-  kill(id) {
+  async kill(id) {
     const session = this.get(id);
     if (!session) return false;
     clearTimeout(session.completionTimer);
@@ -620,7 +620,7 @@ class SessionManager extends EventEmitter {
     this.logSessionDiagnostics('session-deleted', session, {}, { compact: true });
     this.disposeSessionHistory(session);
     if (['claude-structured', 'codex-structured'].includes(session.kind)) {
-      session.ptyManager.kill();
+      await session.ptyManager.kill();
       return true;
     }
     session.ptyManager.kill();

package/lib/usage/ccusage-runner.js

@@ -1,4 +1,5 @@
 const { spawn } = require('child_process');
+const { chmodSync, statSync } = require('fs');
 
 const MAX_OUTPUT_BYTES = 64 * 1024 * 1024;
 const DEFAULT_TIMEOUT_MS = 45000;
@@ -25,6 +26,22 @@ function resolveCcusageBinary(platform = process.platform, arch = process.arch)
   }
 }
 
+function ensureCcusageBinaryExecutable(binaryPath, options = {}) {
+  const platform = options.platform || process.platform;
+  if (platform === 'win32') return binaryPath;
+
+  const statPath = options.statPath || statSync;
+  const chmodPath = options.chmodPath || chmodSync;
+  try {
+    // ccusage's platform packages can be installed without execute bits. Its JS
+    // wrapper repairs them too, but this runner intentionally spawns the native binary.
+    if ((statPath(binaryPath).mode & 0o111) === 0) chmodPath(binaryPath, 0o755);
+    return binaryPath;
+  } catch (error) {
+    throw new Error(`ccusage native binary is not executable: ${error.message}`);
+  }
+}
+
 function reportArgs(timezone) {
   return [
     'daily',
@@ -38,7 +55,8 @@ function reportArgs(timezone) {
 
 class CcusageRunner {
   constructor(options = {}) {
-    this.binaryPath = options.binaryPath || resolveCcusageBinary();
+    this.binaryPath = options.binaryPath
+      || ensureCcusageBinaryExecutable(resolveCcusageBinary());
     this.timeoutMs = options.timeoutMs || DEFAULT_TIMEOUT_MS;
     this.spawnProcess = options.spawnProcess || spawn;
   }
@@ -102,4 +120,9 @@ class CcusageRunner {
   }
 }
 
-module.exports = { CcusageRunner, reportArgs, resolveCcusageBinary };
+module.exports = {
+  CcusageRunner,
+  ensureCcusageBinaryExecutable,
+  reportArgs,
+  resolveCcusageBinary
+};

package/lib/web/codex.js

@@ -1,4 +1,8 @@
         function codexText(text) { return escapeHtml(text || '').replace(/\n/g, '<br>'); }
+        function codexReadyForInput() {
+            return codexState.presentation === 'structured' && codexState.status === 'idle'
+                && !codexState.aborting && !codexState.resuming && !codexResumeInFlight;
+        }
         function codexJson(value) {
             if (typeof value === 'string') return value;
             try { return JSON.stringify(value || {}, null, 2); } catch (_) { return String(value || ''); }
@@ -324,7 +328,7 @@
                 i += 1;
             }
             for (const request of codexPendingPermissions) if (!usedPermissions.has(request.id)) parts.push(renderCodexPermission(request));
-            const skillBubble = selectedCodexSkill && codexState.status === 'idle'
+            const skillBubble = selectedCodexSkill && codexReadyForInput()
                 ? `<div class="codex-skill-bubble" role="status" aria-label="Selected skill: ${escapeHtml(selectedCodexSkill.name)}"><span class="codex-skill-bubble-name">Skill · ${escapeHtml(selectedCodexSkill.name)}</span><button type="button" class="codex-skill-bubble-close" onclick="clearCodexSkillSelection()" title="Remove selected skill" aria-label="Remove selected skill">×</button></div>`
                 : '';
             const working = `<div class="codex-working-indicator" role="status" aria-label="Codex is working" title="Codex is working"${codexState.status === 'running' ? '' : ' style="display:none"'}></div>`;
@@ -443,13 +447,18 @@
             const modelButton = document.getElementById('codex-model-btn');
             if (modelButton) modelButton.textContent = 'Model';
             const abort = document.getElementById('codex-abort-btn');
-            if (abort) abort.disabled = !codexState.canAbort;
+            if (abort) {
+                abort.disabled = !codexState.canAbort;
+                abort.textContent = codexState.aborting ? 'Aborting…' : 'Abort';
+            }
             const compact = document.getElementById('codex-compact-btn');
             if (compact) { compact.disabled = !codexState.canCompact; compact.textContent = codexState.compacting ? 'Compacting' : 'Compact'; }
             const skills = document.getElementById('codex-skills-btn');
-            if (skills) { skills.disabled = !(codexState.presentation === 'structured' && codexState.status === 'idle'); skills.classList.toggle('primary', Boolean(selectedCodexSkill)); }
+            if (skills) { skills.disabled = !codexReadyForInput(); skills.classList.toggle('primary', Boolean(selectedCodexSkill)); }
+            const resume = document.getElementById('codex-resume-btn');
+            if (resume) resume.disabled = !codexReadyForInput();
             const fork = document.getElementById('codex-fork-btn');
-            if (fork) fork.disabled = !(codexState.presentation === 'structured' && codexState.status === 'idle');
+            if (fork) fork.disabled = !codexReadyForInput();
             const terminal = document.getElementById('codex-terminal-switch');
             if (terminal) { terminal.textContent = codexState.presentation === 'terminal' ? 'CHAT' : 'TERM'; terminal.disabled = codexState.presentation === 'structured' && !codexState.canSwitchToTerminal; terminal.title = codexState.presentation === 'terminal' ? 'Return to Codex chat' : 'Switch to Codex terminal'; }
             renderCodexStateBar();
@@ -464,6 +473,8 @@
             const pending = Number(codexState.pendingPermissionCount || codexPendingPermissions.filter(item => item.status === 'pending').length) || 0;
             const subagents = Number(codexState.activeSubagentCount || 0) || 0;
             const parts = [];
+            if (codexState.aborting) parts.push('<span class="claude-state-pill warn">Stopping Codex…</span>');
+            else if (codexState.resuming || codexResumeInFlight) parts.push('<span class="claude-state-pill">Resuming conversation…</span>');
             if (pending || codexState.status === 'waiting_approval') parts.push(`<button type="button" class="claude-state-pill warn codex-approval-jump" onclick="jumpToCodexApproval()" title="Jump to pending approval" aria-label="Jump to pending approval">${pending || 1} approval${pending === 1 ? '' : 's'}<span aria-hidden="true">↓</span></button>`);
             if (subagents) parts.push(`<span class="claude-state-pill">${subagents} subagent${subagents === 1 ? '' : 's'} running</span>`);
             el.innerHTML = parts.join('');
@@ -589,7 +600,12 @@
             applyCodexState({ permissionMode, sandboxMode });
             sendCodexSettings({ permissionMode, sandboxMode });
         }
-        function abortCodexSession() { if (currentSocket?.readyState === 1) currentSocket.send(JSON.stringify({ type: 'codex-abort' })); }
+        function abortCodexSession() {
+            if (!codexState.canAbort || codexState.aborting || currentSocket?.readyState !== 1) return false;
+            currentSocket.send(JSON.stringify({ type: 'codex-abort' }));
+            applyCodexState({ aborting: true, canAbort: false });
+            return true;
+        }
         function requestCodexStatus() { if (currentSocket?.readyState === 1) currentSocket.send(JSON.stringify({ type: 'codex-status' })); }
         function compactCodexContext() {
             if (!codexState.canCompact || currentSocket?.readyState !== 1) return false;
@@ -599,7 +615,11 @@
         }
         function respondCodexPermission(id, decision) { if (currentSocket?.readyState === 1) currentSocket.send(JSON.stringify({ type: 'codex-permission', id, decision })); }
         async function toggleCodexResumePanel() {
-            codexResumePanelOpen = !codexResumePanelOpen;
+            if (!codexReadyForInput()) return;
+            const panel = document.getElementById('codex-resume-panel');
+            const retryAfterFailure = panel.dataset.resumeError === 'true';
+            codexResumePanelOpen = retryAfterFailure ? true : !codexResumePanelOpen;
+            delete panel.dataset.resumeError;
             codexModelPanelOpen = false;
             codexForkPanelOpen = false;
             codexPromptPanelOpen = false;
@@ -608,14 +628,13 @@
             document.getElementById('codex-fork-panel').classList.remove('active');
             document.getElementById('codex-prompt-panel').classList.remove('active');
             document.getElementById('codex-skill-panel').classList.remove('active');
-            const panel = document.getElementById('codex-resume-panel');
             panel.classList.toggle('active', codexResumePanelOpen);
             updateTerminalControlsHeight();
             if (!codexResumePanelOpen) return;
             await loadCodexThreadPanel(panel, 'resume');
         }
         async function toggleCodexForkPanel() {
-            if (!(codexState.presentation === 'structured' && codexState.status === 'idle')) return;
+            if (!codexReadyForInput()) return;
             codexForkPanelOpen = !codexForkPanelOpen;
             codexModelPanelOpen = false;
             codexResumePanelOpen = false;
@@ -632,6 +651,7 @@
             await loadCodexThreadPanel(panel, 'fork');
         }
         async function loadCodexThreadPanel(panel, action) {
+            delete panel.dataset.resumeError;
             panel.innerHTML = '<div class="claude-resume-meta" style="padding:12px;">Loading sessions...</div>';
             try {
                 const res = await fetchWithTimeout(`/api/sessions/${activeSessionId}/codex-resume-threads`, {}, 30000);
@@ -889,7 +909,7 @@
         }
 
         async function toggleCodexSkillPanel() {
-            if (!(codexState.presentation === 'structured' && codexState.status === 'idle')) return;
+            if (!codexReadyForInput()) return;
             codexSkillPanelOpen = !codexSkillPanelOpen;
             codexModelPanelOpen = false;
             codexResumePanelOpen = false;
@@ -941,11 +961,37 @@
             applyCodexState({});
         }
         async function selectCodexResumeThread(threadId) {
-            const res = await fetchWithTimeout(`/api/sessions/${activeSessionId}/codex-resume`, { method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify({ threadId }) }, 30000);
-            if (!res.ok) { alert((await res.json()).error || 'Unable to resume Codex thread'); return; }
-            codexResumePanelOpen = false;
-            document.getElementById('codex-resume-panel').classList.remove('active');
+            if (codexResumeInFlight || codexState.resuming) return;
+            codexResumeInFlight = true;
+            const panel = document.getElementById('codex-resume-panel');
+            panel.innerHTML = '<div class="claude-resume-meta" style="padding:12px;">Resuming conversation…</div>';
+            applyCodexState({ resuming: true, canAbort: true });
             updateTerminalControlsHeight();
+            let failure = '';
+            try {
+                const res = await fetchWithTimeout(`/api/sessions/${activeSessionId}/codex-resume`, {
+                    method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify({ threadId })
+                }, 70000);
+                const data = await res.json();
+                if (!res.ok || !data.success) throw new Error(data.error || 'Unable to resume Codex thread');
+                codexResumePanelOpen = false;
+                panel.classList.remove('active');
+            } catch (error) {
+                failure = /resume aborted/i.test(error.message || '')
+                    ? 'Conversation recovery stopped.'
+                    : (error.message || 'Unable to resume Codex thread');
+            } finally {
+                codexResumeInFlight = false;
+                // 本地 in-flight 也参与控件状态，清除后必须主动重绘。
+                applyCodexState({ resuming: false, canAbort: false });
+                if (failure) {
+                    codexResumePanelOpen = true;
+                    panel.classList.add('active');
+                    panel.dataset.resumeError = 'true';
+                    panel.innerHTML = `<div class="claude-resume-meta" style="padding:12px;color:#ff6b61;">${escapeHtml(failure)}</div>`;
+                }
+                updateTerminalControlsHeight();
+            }
         }
         async function selectCodexForkThread(threadId) {
             const panel = document.getElementById('codex-fork-panel');

package/lib/web/composer.js

@@ -206,6 +206,7 @@
                 return;
             }
             if ((val || readyImageAttachments.length) && isCodexSession() && codexState.presentation === 'structured') {
+                if (!codexReadyForInput()) return;
                 if (currentSocket && currentSocket.readyState === 1) {
                     currentSocket.send(JSON.stringify({
                         type: 'codex-input',

package/lib/web/core.js

@@ -30,12 +30,23 @@
         let claudeResumeItemsLoaded = false;
         let claudeRenderFrame = null;
         let claudeApprovalJumpIndex = 0;
+        function createDefaultCodexState() {
+            return {
+                permissionMode: 'default', sandboxMode: 'default',
+                effectivePermissionMode: null, effectiveSandboxMode: null,
+                model: null, effort: null, status: 'idle', threadId: null,
+                presentation: 'structured', models: [], aborting: false, resuming: false,
+                canAbort: false, canCompact: false, compacting: false,
+                canSwitchToTerminal: false, canSwitchToStructured: false
+            };
+        }
         let codexMessages = [];
         let codexPendingPermissions = [];
-        let codexState = { permissionMode: 'default', sandboxMode: 'default', effectivePermissionMode: null, effectiveSandboxMode: null, model: null, effort: null, status: 'idle', threadId: null, presentation: 'structured', models: [], canAbort: false, canCompact: false, compacting: false, canSwitchToTerminal: false, canSwitchToStructured: false };
+        let codexState = createDefaultCodexState();
         let codexModelPanelOpen = false;
         let codexModelCandidate = null;
         let codexResumePanelOpen = false;
+        let codexResumeInFlight = false;
         let codexForkPanelOpen = false;
         let codexPromptPanelOpen = false;
         let codexPromptItems = [];
@@ -226,14 +237,14 @@
                         : '';
                     html += `<div class="session-card">
                         <div class="session-info">
-                            <h3>${escapeHtml(s.name)}${s.hasUnreadCompletion ? '<span class="completion-dot" title="Completed"></span>' : ''}${timerBadge} <button class="icon-btn" onclick="renameSession('${s.id}', decodePathValue('${encodedName}'), event)"><svg width="14" height="14" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><path d="M11 4H4a2 2 0 0 0-2 2v14a2 2 0 0 0 2 2h14a2 2 0 0 0 2-2v-7"></path><path d="M18.5 2.5a2.121 2.121 0 0 1 3 3L12 15l-4 1 1-4 9.5-9.5z"></path></svg></button></h3>
+                            <h3>${escapeHtml(s.name)}${s.hasUnreadCompletion ? '<span class="completion-dot" title="Completed"></span>' : ''}${timerBadge} <button type="button" class="icon-btn session-edit-btn" title="Rename session" aria-label="Rename session" onclick="renameSession('${s.id}', decodePathValue('${encodedName}'), event)"><svg width="14" height="14" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><path d="M11 4H4a2 2 0 0 0-2 2v14a2 2 0 0 0 2 2h14a2 2 0 0 0 2-2v-7"></path><path d="M18.5 2.5a2.121 2.121 0 0 1 3 3L12 15l-4 1 1-4 9.5-9.5z"></path></svg></button></h3>
                             <p>${escapeHtml(s.tool)}</p>
                             <p>${new Date(s.startTime).toLocaleTimeString()}</p>
                         </div>
                         <div class="session-actions">
                             ${renderServerChanSessionAction(s)}
                             <button class="btn-join" onclick="joinSession('${s.id}', decodePathValue('${encodedName}'), '${escapeHtml(s.toolKey || '')}')">Connect</button>
-                            <button class="icon-btn btn-delete" onclick="deleteSession('${s.id}', event)"><svg width="20" height="20" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><polyline points="3 6 5 6 21 6"></polyline><path d="M19 6v14a2 2 0 0 1-2 2H7a2 2 0 0 1-2-2V6m3 0V4a2 2 0 0 1 2-2h4a2 2 0 0 1 2 2v2"></path></svg></button>
+                            <button type="button" class="icon-btn btn-delete session-delete-btn" title="Delete session" aria-label="Delete session" onclick="deleteSession('${s.id}', event)"><svg width="20" height="20" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><polyline points="3 6 5 6 21 6"></polyline><path d="M19 6v14a2 2 0 0 1-2 2H7a2 2 0 0 1-2-2V6m3 0V4a2 2 0 0 1 2-2h4a2 2 0 0 1 2 2v2"></path></svg></button>
                         </div>
                         <div class="session-dir-row">
                             <button class="copy-dir-btn" title="Copy directory" onclick="copySessionDirectory(decodePathValue('${encodedDir}'), event)">

package/lib/web/session.js

@@ -155,7 +155,7 @@
             document.getElementById('codex-prompt-panel').classList.remove('active');
             document.getElementById('codex-skill-panel').classList.remove('active');
             document.getElementById('codex-control-rail').scrollLeft = 0;
-            codexState = { permissionMode: 'default', sandboxMode: 'default', effectivePermissionMode: null, effectiveSandboxMode: null, model: null, effort: null, status: 'idle', threadId: null, presentation: 'structured', models: [], canAbort: false, canCompact: false, compacting: false, canSwitchToTerminal: false, canSwitchToStructured: false };
+            codexState = createDefaultCodexState();
             setClaudeModeEnabled(false);
             applyCodexState(codexState);
             installCodexLazyDetailHandler();

package/lib/web/styles.css

@@ -11,8 +11,7 @@
         .header-action-btn.icon-only { width: 36px; padding: 0; }
         .header-action-btn:active { background: #0062cc; transform: scale(.97); }
         .btn-retry { background: #333; color: #fff; border: none; padding: 8px 16px; border-radius: 20px; margin-top: 10px; cursor: pointer; }
-        .session-card { background: var(--card-bg); border-radius: 12px; padding: 12px 16px 8px; margin-bottom: 12px; display: grid; grid-template-columns: minmax(0, 1fr) auto; column-gap: 10px; row-gap: 0; align-items: center; transition: transform 0.1s; position: relative; }
-        .session-card:active { transform: scale(0.98); }
+        .session-card { background: var(--card-bg); border-radius: 12px; padding: 12px 16px 8px; margin-bottom: 12px; display: grid; grid-template-columns: minmax(0, 1fr) auto; column-gap: 10px; row-gap: 0; align-items: center; position: relative; }
         .completion-dot { width: 9px; height: 9px; border-radius: 50%; background: #ff3b30; flex-shrink: 0; }
         .session-info { flex: 1; min-width: 0; }
         .session-info h3 { margin: 0 0 4px 0; font-size: 17px; display: flex; align-items: center; gap: 8px; }
@@ -29,6 +28,11 @@
         .btn-join { background: rgba(255,255,255,0.1); border: none; color: var(--primary); padding: 8px 14px; border-radius: 18px; font-weight: 600; font-size: 14px; cursor: pointer; }
         .icon-btn { color: var(--text-dim); background: none; border: none; padding: 4px; display: flex; align-items: center; justify-content: center; cursor: pointer; }
         .icon-btn:active { color: var(--text); }
+        .session-edit-btn, .session-delete-btn { position: relative; }
+        .session-edit-btn::before, .session-delete-btn::before { content: ""; position: absolute; }
+        .session-edit-btn::before { inset: -9px; }
+        .session-delete-btn::before { inset: -8px; }
+        .session-edit-btn svg, .session-delete-btn svg { pointer-events: none; }
         .btn-delete { color: #ff3b30; }
         #modal-overlay { position: fixed; top: 0; left: 0; right: 0; bottom: 0; background: rgba(0,0,0,0.8); z-index: 10000; display: none; align-items: center; justify-content: center; padding: 20px; }
         #tool-modal { background: var(--card-bg); width: 100%; max-width: 400px; border-radius: 16px; padding: 20px; box-shadow: 0 20px 40px rgba(0,0,0,0.4); }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "glad-web",
-  "version": "1.0.40",
+  "version": "1.0.43",
   "description": "Glad transforms terminal-based AI coding tools into a polished, mobile-friendly local Web interface.",
   "bin": {
     "glad": "bin/cli.js"