glad-web 1.0.40 → 1.0.41

package/lib/codex/structured-session.js

@@ -7,6 +7,12 @@ 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;
+
+function turnKey(threadId, turnId) {
+  return `${String(threadId || '')}\n${String(turnId || '')}`;
+}
 
 function normalizePermissionMode(value) {
   const mode = String(value || 'default');
@@ -57,11 +63,37 @@ function appServerSpawnOptions({ cwd, env, platform = process.platform }) {
   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 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')
@@ -233,6 +265,14 @@ class CodexStructuredSession extends EventEmitter {
     this.pendingRequests = new Map();
     this.process = null;
     this.processReady = null;
+    this.processShutdown = null;
+    this.needsThreadResume = false;
+    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 +352,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,
+      canAbort: this.presentation === 'structured' && this.status !== 'idle' && !this.aborting,
+      canCompact: this.presentation === 'structured' && this.status === 'idle' && !this.compacting
+        && !this.aborting && 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 && Boolean(this.threadId),
       canSwitchToStructured: this.presentation === 'terminal',
       pendingPermissionCount: this.pendingPermissions.size, activeSubagentCount, models: this.models };
   }
@@ -362,7 +405,27 @@ 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({
@@ -384,6 +447,8 @@ class CodexStructuredSession extends EventEmitter {
           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({
@@ -514,8 +579,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 +616,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 +642,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;
     }
@@ -952,11 +1026,32 @@ 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));
+    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) return false;
     this.hasUnreadCompletion = false;
     this.promptHistoryCache = null;
     this.append({
@@ -967,8 +1062,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 +1073,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 +1105,7 @@ 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) return false;
     await this.ensureProcess();
     this.compacting = true;
     this.setStatus('running');
@@ -1060,6 +1157,7 @@ class CodexStructuredSession extends EventEmitter {
 
   abort(reason = 'Aborted by user') {
     if (this.presentation !== 'structured' || this.status === 'idle') return false;
+    if (this.aborting) return true;
     for (const pending of this.pendingPermissions.values()) {
       const response = pending.method === 'item/permissions/requestApproval'
         ? { permissions: {}, scope: 'turn' }
@@ -1077,32 +1175,77 @@ 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;
+  }
+
+  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;
   }
 
   async 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;
     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);
       this.threadId = result.thread?.id || target;
+      this.needsThreadResume = false;
       this.hasModelOverride = resumeWithModelOverride;
       this.hasEffortOverride = resumeWithEffortOverride;
       this.model = result.model || result.thread?.model || selectedModel;
@@ -1167,7 +1310,7 @@ 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) 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 +1320,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 +1331,7 @@ 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.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 +1362,45 @@ class CodexStructuredSession extends EventEmitter {
     return this.resume();
   }
 
-  async disconnectProcess() {
-    if (!this.process) return;
+  async disconnectProcess(force = false) {
+    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')); }
     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.terminalSession?.kill();
+    this.terminalSession = null;
+    await this.disconnectProcess(true);
+    this.emit('exit');
+  }
 }
 
 module.exports = CodexStructuredSession;
 module.exports.appServerSpawnOptions = appServerSpawnOptions;
+module.exports.forceKillProcessTree = forceKillProcessTree;

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

@@ -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,7 @@
         function codexText(text) { return escapeHtml(text || '').replace(/\n/g, '<br>'); }
+        function codexReadyForInput() {
+            return codexState.presentation === 'structured' && codexState.status === 'idle' && !codexState.aborting;
+        }
         function codexJson(value) {
             if (typeof value === 'string') return value;
             try { return JSON.stringify(value || {}, null, 2); } catch (_) { return String(value || ''); }
@@ -324,7 +327,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 +446,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 +472,7 @@
             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>');
             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 +598,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,6 +613,7 @@
         }
         function respondCodexPermission(id, decision) { if (currentSocket?.readyState === 1) currentSocket.send(JSON.stringify({ type: 'codex-permission', id, decision })); }
         async function toggleCodexResumePanel() {
+            if (!codexReadyForInput()) return;
             codexResumePanelOpen = !codexResumePanelOpen;
             codexModelPanelOpen = false;
             codexForkPanelOpen = false;
@@ -615,7 +630,7 @@
             await loadCodexThreadPanel(panel, 'resume');
         }
         async function toggleCodexForkPanel() {
-            if (!(codexState.presentation === 'structured' && codexState.status === 'idle')) return;
+            if (!codexReadyForInput()) return;
             codexForkPanelOpen = !codexForkPanelOpen;
             codexModelPanelOpen = false;
             codexResumePanelOpen = false;
@@ -889,7 +904,7 @@
         }
 
         async function toggleCodexSkillPanel() {
-            if (!(codexState.presentation === 'structured' && codexState.status === 'idle')) return;
+            if (!codexReadyForInput()) return;
             codexSkillPanelOpen = !codexSkillPanelOpen;
             codexModelPanelOpen = false;
             codexResumePanelOpen = false;

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,9 +30,19 @@
         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,
+                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;
@@ -226,14 +236,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.41",
   "description": "Glad transforms terminal-based AI coding tools into a polished, mobile-friendly local Web interface.",
   "bin": {
     "glad": "bin/cli.js"