glad-web 1.0.44 → 1.0.46

package/lib/session/file-attachment-store.js

@@ -0,0 +1,168 @@
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const { v4: uuidv4 } = require('uuid');
+
+const MAX_BYTES = 50 * 1024 * 1024;
+const MAX_PER_SESSION = 8;
+const MAX_CHUNKS = 128;
+const CLEANUP_DELAY_MS = 30 * 60 * 1000;
+
+function inputError(message, statusCode = 400) {
+  const error = new Error(message);
+  error.statusCode = statusCode;
+  return error;
+}
+
+function safeUploadId(value) {
+  return typeof value === 'string' && /^[a-zA-Z0-9-]{8,100}$/.test(value);
+}
+
+function safeFileName(value) {
+  let decoded = String(value || 'attachment.bin');
+  try { decoded = decodeURIComponent(decoded); } catch (_) {}
+  const base = decoded.replace(/\\/g, '/').split('/').pop() || 'attachment.bin';
+  const cleaned = base.replace(/[\u0000-\u001f\u007f<>:"|?*]/g, '_').trim().slice(0, 160);
+  return cleaned || 'attachment.bin';
+}
+
+class FileAttachmentStore {
+  constructor({ logger, root, uploadRoot } = {}) {
+    this.logger = logger || console;
+    this.root = root || path.join(os.tmpdir(), 'glad', 'session-files');
+    this.uploadRoot = uploadRoot || path.join(os.tmpdir(), 'glad', 'session-file-uploads');
+  }
+
+  assertSession(session) {
+    if (!session) throw inputError('Session not found', 404);
+    if (!session.fileAttachments || !session.fileUploads) throw inputError('File attachments are unavailable for this session');
+  }
+
+  async appendChunk(session, input = {}, bytes) {
+    this.assertSession(session);
+    if (!Buffer.isBuffer(bytes) || bytes.length === 0) throw inputError('File chunk is required');
+    const uploadId = String(input.uploadId || '');
+    const chunkIndex = Number(input.chunkIndex);
+    const chunkTotal = Number(input.chunkTotal);
+    const name = safeFileName(input.name);
+    if (!safeUploadId(uploadId)) throw inputError('Invalid file upload id');
+    if (!Number.isInteger(chunkIndex) || !Number.isInteger(chunkTotal) || chunkIndex < 0 || chunkTotal < 1 || chunkTotal > MAX_CHUNKS || chunkIndex >= chunkTotal) {
+      throw inputError('Invalid file chunk metadata');
+    }
+
+    let upload = session.fileUploads.get(uploadId);
+    if (!upload) {
+      if (chunkIndex !== 0) throw inputError('File upload must start with the first chunk');
+      const directory = path.join(this.uploadRoot, session.id);
+      await fs.promises.mkdir(directory, { recursive: true, mode: 0o700 });
+      upload = { id: uploadId, name, path: path.join(directory, `${uploadId}.part`), chunkTotal, nextChunkIndex: 0, bytes: 0 };
+      session.fileUploads.set(uploadId, upload);
+    }
+    if (upload.name !== name || upload.chunkTotal !== chunkTotal || upload.nextChunkIndex !== chunkIndex) {
+      throw inputError('File chunks arrived out of order');
+    }
+    if (upload.bytes + bytes.length > MAX_BYTES) {
+      await this.discardUpload(session, uploadId);
+      throw inputError('File must be 50 MB or smaller');
+    }
+
+    if (chunkIndex === 0) await fs.promises.writeFile(upload.path, bytes, { mode: 0o600, flag: 'wx' });
+    else await fs.promises.appendFile(upload.path, bytes, { mode: 0o600 });
+    upload.bytes += bytes.length;
+    upload.nextChunkIndex += 1;
+    if (upload.nextChunkIndex < upload.chunkTotal) {
+      return { complete: false, receivedChunks: upload.nextChunkIndex, size: upload.bytes };
+    }
+
+    const pendingAttachmentCount = Array.from(session.fileAttachments.values()).filter(item => !item.sent).length;
+    if (pendingAttachmentCount >= MAX_PER_SESSION) {
+      await this.discardUpload(session, uploadId);
+      throw inputError(`You can attach at most ${MAX_PER_SESSION} files at a time`);
+    }
+    const directory = path.join(this.root, session.id);
+    await fs.promises.mkdir(directory, { recursive: true, mode: 0o700 });
+    const attachment = {
+      id: uuidv4(),
+      name: upload.name,
+      path: path.join(directory, `${uuidv4()}-${upload.name}`),
+      size: upload.bytes,
+      createdAt: Date.now(),
+      cleanupTimer: null
+    };
+    session.fileUploads.delete(uploadId);
+    try {
+      await fs.promises.rename(upload.path, attachment.path);
+      await fs.promises.chmod(attachment.path, 0o600);
+      session.fileAttachments.set(attachment.id, attachment);
+      return { complete: true, attachment: { id: attachment.id, name: attachment.name, size: attachment.size, kind: 'file' } };
+    } catch (error) {
+      await fs.promises.rm(upload.path, { force: true });
+      throw error;
+    }
+  }
+
+  async discardUpload(session, uploadId) {
+    if (!session?.fileUploads || !safeUploadId(uploadId)) return false;
+    const upload = session.fileUploads.get(uploadId);
+    if (!upload) return false;
+    session.fileUploads.delete(uploadId);
+    await fs.promises.rm(upload.path, { force: true });
+    return true;
+  }
+
+  async discardAttachment(session, attachmentId) {
+    if (!session?.fileAttachments) return false;
+    const attachment = session.fileAttachments.get(attachmentId);
+    if (!attachment) return false;
+    clearTimeout(attachment.cleanupTimer);
+    session.fileAttachments.delete(attachmentId);
+    await fs.promises.rm(attachment.path, { force: true });
+    return true;
+  }
+
+  resolve(session, attachmentIds = []) {
+    const ids = Array.isArray(attachmentIds) ? attachmentIds : [];
+    if (!session) throw inputError('Session not found', 404);
+    if (ids.length === 0) return [];
+    this.assertSession(session);
+    if (ids.length > MAX_PER_SESSION) throw inputError(`You can attach at most ${MAX_PER_SESSION} files at a time`);
+    const uniqueIds = [...new Set(ids.map(String))];
+    if (uniqueIds.length !== ids.length) throw inputError('Duplicate file attachment');
+    return uniqueIds.map(attachmentId => {
+      const attachment = session.fileAttachments.get(attachmentId);
+      if (!attachment) throw inputError('File attachment is no longer available');
+      return attachment;
+    });
+  }
+
+  scheduleCleanup(session, attachmentIds) {
+    if (!session?.fileAttachments) return;
+    for (const attachmentId of attachmentIds) {
+      const attachment = session.fileAttachments.get(attachmentId);
+      if (!attachment) continue;
+      attachment.sent = true;
+      clearTimeout(attachment.cleanupTimer);
+      attachment.cleanupTimer = setTimeout(() => {
+        this.discardAttachment(session, attachmentId).catch(error => {
+          this.logger.debugInfo?.(`[file-attachment] cleanup failed: ${error.message}`);
+        });
+      }, CLEANUP_DELAY_MS);
+      attachment.cleanupTimer.unref?.();
+    }
+  }
+
+  clear(session) {
+    if (!session) return;
+    for (const attachment of session.fileAttachments?.values?.() || []) clearTimeout(attachment.cleanupTimer);
+    session.fileAttachments?.clear?.();
+    session.fileUploads?.clear?.();
+    fs.promises.rm(path.join(this.root, session.id), { recursive: true, force: true }).catch(error => {
+      this.logger.debugInfo?.(`[file-attachment] cleanup failed: ${error.message}`);
+    });
+    fs.promises.rm(path.join(this.uploadRoot, session.id), { recursive: true, force: true }).catch(error => {
+      this.logger.debugInfo?.(`[file-upload] cleanup failed: ${error.message}`);
+    });
+  }
+}
+
+module.exports = FileAttachmentStore;

package/lib/session/session-manager.js

@@ -11,6 +11,7 @@ const ClaudeStructuredSession = require('../claude/structured-session');
 const CodexStructuredSession = require('../codex/structured-session');
 const ClaudeTranscriptRepository = require('../claude/transcript-repository');
 const CodexImageStore = require('../codex/image-store');
+const FileAttachmentStore = require('./file-attachment-store');
 
 function previewText(text, maxChars = 320) {
   if (!text) return '';
@@ -29,8 +30,22 @@ function imageMediaType(name) {
       : extension === '.gif' ? 'image/gif' : 'image/webp';
 }
 
+function promptWithFileReferences(text, attachments) {
+  const prompt = String(text || '').trim();
+  if (!attachments.length) return prompt;
+  const references = attachments.map(item => `- ${item.name}: ${item.path}`).join('\n');
+  const note = `The user attached the following local files. Read them if relevant to the request:\n${references}`;
+  return prompt ? `${prompt}\n\n${note}` : note;
+}
+
+const STRUCTURED_SESSION_KINDS = new Set(['claude-structured', 'codex-structured']);
+
+function isStructuredSession(session) {
+  return Boolean(session && STRUCTURED_SESSION_KINDS.has(session.kind));
+}
+
 class SessionManager extends EventEmitter {
-  constructor({ baseDir, renderHistoryTools, debugHistoryEnabled = false, logger, hasConnectedSessionClient, claudeTranscriptRepository, codexImageStore, claudeForkSession } = {}) {
+  constructor({ baseDir, renderHistoryTools, debugHistoryEnabled = false, logger, hasConnectedSessionClient, claudeTranscriptRepository, codexImageStore, fileAttachmentStore, claudeForkSession } = {}) {
     super();
     this.baseDir = baseDir || process.cwd();
     this.renderHistoryTools = renderHistoryTools || new Set();
@@ -39,6 +54,7 @@ class SessionManager extends EventEmitter {
     this.hasConnectedSessionClient = hasConnectedSessionClient || (() => false);
     this.sessions = new Map();
     this.codexImages = codexImageStore || new CodexImageStore({ logger: this.logger });
+    this.fileAttachmentStore = fileAttachmentStore || new FileAttachmentStore({ logger: this.logger });
     Object.defineProperties(this, {
       codexImageRoot: {
         get: () => this.codexImages.root,
@@ -67,7 +83,7 @@ class SessionManager extends EventEmitter {
       startTime: session.startTime,
       toolKey: session.tool.key,
       workingDirectory: this.getSessionWorkingDirectory(session),
-      mode: ['claude-structured', 'codex-structured'].includes(session.kind) ? (session.presentation || 'structured') : 'terminal',
+      mode: isStructuredSession(session) ? 'structured' : 'terminal',
       hasUnreadCompletion: Boolean(session.hasUnreadCompletion),
       serverChanNotificationEnabled: Boolean(session.serverChanNotificationEnabled),
       timedInputCount: session.timedInputs
@@ -84,7 +100,7 @@ class SessionManager extends EventEmitter {
     return this.sessions.has(id);
   }
 
-  create({ toolKey, workingDirectory, name, claudeOptions }) {
+  create({ id: requestedId, toolKey, workingDirectory, name, claudeOptions, codexOptions, disposeResources }) {
     this.logger.info(`Creating session: toolKey=${toolKey || ''}, workingDirectory=${workingDirectory || '(default)'}`);
     const tool = getToolByKey(toolKey);
     if (!tool) {
@@ -98,7 +114,14 @@ class SessionManager extends EventEmitter {
       return this.createClaudeStructuredSession({ tool, workingDirectory, name, claudeOptions });
     }
     if (tool.key === 'codex') {
-      return this.createCodexStructuredSession({ tool, workingDirectory, name });
+      return this.createCodexStructuredSession({
+        id: requestedId,
+        tool,
+        workingDirectory,
+        name,
+        codexOptions,
+        disposeResources
+      });
     }
 
     const id = uuidv4();
@@ -142,6 +165,8 @@ class SessionManager extends EventEmitter {
       hasConnectedWebClient: false,
       hasUnreadCompletion: false,
       timedInputs: new Map(),
+      fileAttachments: new Map(),
+      fileUploads: new Map(),
       write: data => this.write(id, data),
       isRunning: () => this.has(id) && ptyManager.isRunning(),
       kill: () => this.kill(id)
@@ -187,6 +212,8 @@ class SessionManager extends EventEmitter {
     });
     session.imageAttachments = new Map();
     session.imageUploads = new Map();
+    session.fileAttachments = new Map();
+    session.fileUploads = new Map();
 
     this.sessions.set(id, session);
     session.on('event', event => this.emit('claude-event', { sessionId: id, event, session }));
@@ -196,7 +223,7 @@ class SessionManager extends EventEmitter {
     return session;
   }
 
-  createCodexStructuredSession({ tool, workingDirectory, name, codexOptions = {} }) {
+  createCodexStructuredSession({ id: requestedId, tool, workingDirectory, name, codexOptions = {}, disposeResources = null }) {
     const sessionDir = workingDirectory && String(workingDirectory).trim()
       ? path.resolve(this.baseDir, String(workingDirectory).trim())
       : this.baseDir;
@@ -205,13 +232,15 @@ class SessionManager extends EventEmitter {
       err.statusCode = 400;
       throw err;
     }
-    const id = uuidv4();
+    const id = requestedId || uuidv4();
     const session = new CodexStructuredSession({ id, tool, workingDir: sessionDir, name: name || tool.displayName, logger: this.logger, options: codexOptions });
     session.imageAttachments = new Map();
     session.imageUploads = new Map();
+    session.fileAttachments = new Map();
+    session.fileUploads = new Map();
+    session.disposeResources = typeof disposeResources === 'function' ? disposeResources : null;
     this.sessions.set(id, session);
     session.on('event', event => this.emit('codex-event', { sessionId: id, event, session }));
-    session.on('output', data => this.emit('output', { sessionId: id, data, session }));
     session.on('exit', () => this.handleExit(session));
     session.ensureProcess().catch(error => {
       session.append({ kind: 'event', level: 'error', text: `Unable to start Codex app-server: ${error.message}` });
@@ -224,16 +253,30 @@ class SessionManager extends EventEmitter {
     const session = this.get(id);
     if (!session) return false;
     this.markSessionInput(session, data);
-    if (['claude-structured', 'codex-structured'].includes(session.kind)) return session.write(data);
+    if (isStructuredSession(session)) return session.write(data);
     return session.ptyManager.write(data);
   }
 
-  async sendClaudeInput(id, text, attachmentIds = []) {
+  sendTerminalFileInput(id, text, fileAttachmentIds = []) {
+    const session = this.get(id);
+    if (!session || isStructuredSession(session)) return false;
+    const files = this.getFileAttachments(id, fileAttachmentIds);
+    const prompt = promptWithFileReferences(text, files);
+    if (!prompt) return false;
+    this.write(id, prompt.replace(/\n/g, '\r'));
+    const enterTimer = setTimeout(() => this.write(id, '\r'), 1000);
+    enterTimer.unref?.();
+    if (files.length) this.scheduleFileCleanup(id, files.map(item => item.id));
+    return true;
+  }
+
+  async sendClaudeInput(id, text, attachmentIds = [], fileAttachmentIds = []) {
     const session = this.get(id);
     if (!session || session.kind !== 'claude-structured') return false;
     const attachments = this.getImageAttachments(id, attachmentIds);
+    const files = this.getFileAttachments(id, fileAttachmentIds);
     const prompt = String(text || '');
-    if (!prompt.trim() && attachments.length === 0) return false;
+    if (!prompt.trim() && attachments.length === 0 && files.length === 0) return false;
     const prepared = await Promise.all(attachments.map(async attachment => ({
       id: attachment.id,
       name: attachment.name,
@@ -241,12 +284,37 @@ class SessionManager extends EventEmitter {
       mediaType: imageMediaType(attachment.name),
       data: (await fs.promises.readFile(attachment.path)).toString('base64')
     })));
-    this.markSessionInput(session, prompt || '[image attachment]');
-    const sent = session.sendUserMessage(prompt, prepared);
+    const agentPrompt = promptWithFileReferences(prompt, files);
+    this.markSessionInput(session, prompt || (files.length ? '[file attachment]' : '[image attachment]'));
+    const sent = session.sendUserMessage(prompt, prepared, {
+      agentText: agentPrompt,
+      displayAttachments: files.map(item => ({ id: item.id, name: item.name, size: item.size, kind: 'file' }))
+    });
     if (sent && attachments.length) this.scheduleImageCleanup(id, attachments.map(item => item.id));
+    if (sent && files.length) this.scheduleFileCleanup(id, files.map(item => item.id));
     return sent;
   }
 
+  appendFileChunk(id, input = {}, bytes) {
+    return this.fileAttachmentStore.appendChunk(this.get(id), input, bytes);
+  }
+
+  discardFileUpload(id, uploadId) {
+    return this.fileAttachmentStore.discardUpload(this.get(id), uploadId);
+  }
+
+  discardFileAttachment(id, attachmentId) {
+    return this.fileAttachmentStore.discardAttachment(this.get(id), attachmentId);
+  }
+
+  getFileAttachments(id, attachmentIds = []) {
+    return this.fileAttachmentStore.resolve(this.get(id), attachmentIds);
+  }
+
+  scheduleFileCleanup(id, attachmentIds) {
+    this.fileAttachmentStore.scheduleCleanup(this.get(id), attachmentIds);
+  }
+
   storeImageAttachment(id, bytes) {
     return this.codexImages.store(this.get(id), bytes);
   }
@@ -295,15 +363,21 @@ class SessionManager extends EventEmitter {
     this.scheduleImageCleanup(id, attachmentIds);
   }
 
-  async sendCodexInput(id, text, attachmentIds = [], skills = []) {
+  async sendCodexInput(id, text, attachmentIds = [], skills = [], fileAttachmentIds = []) {
     const session = this.get(id);
     if (!session || session.kind !== 'codex-structured') return false;
     const attachments = this.getCodexImageAttachments(id, attachmentIds);
+    const files = this.getFileAttachments(id, fileAttachmentIds);
     const prompt = String(text || '');
-    if (!prompt.trim() && attachments.length === 0) return false;
-    this.markSessionInput(session, prompt || '[image attachment]');
-    const sent = await session.sendUserMessage(prompt, attachments, skills);
+    if (!prompt.trim() && attachments.length === 0 && files.length === 0) return false;
+    const agentPrompt = promptWithFileReferences(prompt, files);
+    this.markSessionInput(session, prompt || (files.length ? '[file attachment]' : '[image attachment]'));
+    const sent = await session.sendUserMessage(prompt, attachments, skills, {
+      agentText: agentPrompt,
+      displayAttachments: files.map(item => ({ id: item.id, name: item.name, size: item.size, kind: 'file' }))
+    });
     if (sent && attachments.length) this.scheduleCodexImageCleanup(id, attachments.map(item => item.id));
+    if (sent && files.length) this.scheduleFileCleanup(id, files.map(item => item.id));
     return sent;
   }
 
@@ -409,8 +483,8 @@ 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' || session.resuming) {
-      const error = new Error('Codex must be idle in chat mode before forking');
+    if (session.status !== 'idle' || session.resuming) {
+      const error = new Error('Codex must be idle before forking');
       error.statusCode = 409;
       throw error;
     }
@@ -444,20 +518,11 @@ class SessionManager extends EventEmitter {
     return session.listSkills(forceReload);
   }
 
-  switchCodexPresentation(id, presentation) {
-    const session = this.get(id);
-    if (!session || session.kind !== 'codex-structured') return Promise.resolve(false);
-    return presentation === 'terminal' ? session.switchToTerminal() : session.switchToStructured();
-  }
-
   resize(id, cols, rows) {
     const session = this.get(id);
     if (!session) return false;
     if (session.kind === 'claude-structured') return true;
-    if (session.kind === 'codex-structured') {
-      if (session.presentation === 'terminal') session.ptyManager.resize(cols, rows);
-      return true;
-    }
+    if (session.kind === 'codex-structured') return true;
     if (session.renderedHistory) {
       session.renderedHistory.resize(cols, rows);
     }
@@ -468,7 +533,7 @@ class SessionManager extends EventEmitter {
   redraw(id, cols, rows) {
     const session = this.get(id);
     if (!session) return false;
-    if (['claude-structured', 'codex-structured'].includes(session.kind)) return true;
+    if (isStructuredSession(session)) return true;
     if (session.renderedHistory) {
       session.renderedHistory.resize(cols, rows);
     }
@@ -486,7 +551,7 @@ class SessionManager extends EventEmitter {
   markCompletionRead(id) {
     const session = this.get(id);
     if (!session) return null;
-    if (['claude-structured', 'codex-structured'].includes(session.kind)) {
+    if (isStructuredSession(session)) {
       session.markCompletionRead();
       this.logSessionDiagnostics('completion-read', session, {}, { compact: true });
       return session;
@@ -610,33 +675,57 @@ class SessionManager extends EventEmitter {
     return true;
   }
 
-  async kill(id) {
-    const session = this.get(id);
-    if (!session) return false;
+  quiesceSession(session) {
     clearTimeout(session.completionTimer);
     this.clearTimedInputs(session);
+  }
+
+  disposeSessionResources(session) {
+    this.quiesceSession(session);
     this.clearCodexImageUploads(session);
     this.clearCodexImageAttachments(session);
-    this.logSessionDiagnostics('session-deleted', session, {}, { compact: true });
+    this.fileAttachmentStore.clear(session);
+    if (typeof session.disposeResources === 'function') {
+      try { session.disposeResources(); } catch (error) {
+        this.logger.error?.(`Failed to clean session resources ${session.id}: ${error.message}`);
+      }
+      session.disposeResources = null;
+    }
     this.disposeSessionHistory(session);
-    if (['claude-structured', 'codex-structured'].includes(session.kind)) {
-      await session.ptyManager.kill();
-      return true;
+  }
+
+  async stopSessionRuntime(session) {
+    if (isStructuredSession(session)) {
+      await session.kill();
+      return;
     }
     session.ptyManager.kill();
-    this.sessions.delete(id);
-    this.emit('exit', { sessionId: id, session });
+  }
+
+  removeSession(session) {
+    if (this.sessions.get(session.id) !== session) return false;
+    this.disposeSessionResources(session);
+    this.sessions.delete(session.id);
+    this.emit('exit', { sessionId: session.id, session });
+    return true;
+  }
+
+  async kill(id) {
+    const session = this.get(id);
+    if (!session) return false;
+    this.logSessionDiagnostics('session-deleted', session, {}, { compact: true });
+    this.quiesceSession(session);
+    await this.stopSessionRuntime(session);
+    this.removeSession(session);
     return true;
   }
 
   killAll() {
-    for (const session of this.sessions.values()) {
-      clearTimeout(session.completionTimer);
-      this.clearTimedInputs(session);
-      this.clearCodexImageUploads(session);
-      this.clearCodexImageAttachments(session);
-      this.disposeSessionHistory(session);
-      session.ptyManager.kill();
+    for (const session of Array.from(this.sessions.values())) {
+      this.disposeSessionResources(session);
+      void this.stopSessionRuntime(session).catch(error => {
+        this.logger.error?.(`Failed to stop session ${session.id}: ${error.message}`);
+      });
     }
     this.sessions.clear();
   }
@@ -644,7 +733,7 @@ class SessionManager extends EventEmitter {
   getHistory(id) {
     const session = this.get(id);
     if (!session) return null;
-    if (['claude-structured', 'codex-structured'].includes(session.kind)) return session.getHistory();
+    if (isStructuredSession(session)) return session.getHistory();
     const historySource = session.renderedHistory || session.textHistory;
     return {
       success: true,
@@ -659,7 +748,7 @@ class SessionManager extends EventEmitter {
   getCatchupOutput(id) {
     const session = this.get(id);
     if (!session) return null;
-    if (['claude-structured', 'codex-structured'].includes(session.kind)) return session.getCatchupOutput();
+    if (isStructuredSession(session)) return session.getCatchupOutput();
 
     const bufferHistory = session.buffer.getAfter(0);
     if (bufferHistory.length > 0) {
@@ -798,21 +887,15 @@ class SessionManager extends EventEmitter {
   }
 
   handleExit(session) {
-    if (!this.sessions.has(session.id)) return;
+    if (this.sessions.get(session.id) !== session) return;
     this.logger.info(`Session ${session.id} (${session.name}) exited.`);
-    clearTimeout(session.completionTimer);
-    this.clearTimedInputs(session);
-    this.clearCodexImageUploads(session);
-    this.clearCodexImageAttachments(session);
-    this.disposeSessionHistory(session);
-    this.sessions.delete(session.id);
-    this.emit('exit', { sessionId: session.id, session });
+    this.removeSession(session);
   }
 
   markSessionInput(session, data) {
     if (typeof data !== 'string' || data.length === 0) return;
     session.inputSeq = (session.inputSeq || 0) + 1;
-    if (['claude-structured', 'codex-structured'].includes(session.kind)) {
+    if (isStructuredSession(session)) {
       session.hasUnreadCompletion = false;
       this.logSessionDiagnostics('session-input', session, {
         inputSeq: session.inputSeq,
@@ -831,7 +914,7 @@ class SessionManager extends EventEmitter {
   }
 
   disposeSessionHistory(session) {
-    if (['claude-structured', 'codex-structured'].includes(session.kind)) return;
+    if (isStructuredSession(session)) return;
     if (session.renderedHistory) {
       session.renderedHistory.dispose();
       session.renderedHistory = null;
@@ -855,7 +938,7 @@ class SessionManager extends EventEmitter {
   }
 
   getSessionDiagnostics(session, extra = {}) {
-    if (['claude-structured', 'codex-structured'].includes(session.kind)) {
+    if (isStructuredSession(session)) {
       return {
         sessionId: session.id,
         sessionName: session.name,
@@ -884,7 +967,7 @@ class SessionManager extends EventEmitter {
   }
 
   getCompactSessionDiagnostics(session, extra = {}) {
-    if (['claude-structured', 'codex-structured'].includes(session.kind)) {
+    if (isStructuredSession(session)) {
       return this.getSessionDiagnostics(session, extra);
     }
     const buffer = session.buffer.getDebugSnapshot();