glad-web 1.0.29 → 1.0.31

package/lib/claude/transcript-repository.js

@@ -0,0 +1,216 @@
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const { v4: uuidv4 } = require('uuid');
+
+function previewText(text, maxChars) {
+  const normalized = String(text || '').replace(/\s+/g, ' ').trim();
+  return normalized.length > maxChars ? `${normalized.slice(0, maxChars)}...` : normalized;
+}
+
+function isLocalCommandTranscript(text) {
+  const value = String(text || '').trim();
+  return value.startsWith('<command-name>/') || value.startsWith('<local-command-caveat>');
+}
+
+class ClaudeTranscriptRepository {
+  constructor({ baseDir, logger } = {}) {
+    this.baseDir = baseDir || process.cwd();
+    this.logger = logger || console;
+  }
+
+  list(workingDirectory) {
+    const projectDir = this.getProjectDirectory(workingDirectory);
+    if (!fs.existsSync(projectDir)) return [];
+    const files = fs.readdirSync(projectDir)
+      .filter(file => /^[0-9a-f-]{36}\.jsonl$/i.test(file))
+      .map(file => {
+        const fullPath = path.join(projectDir, file);
+        const stat = fs.statSync(fullPath);
+        return {
+          id: file.replace(/\.jsonl$/i, ''),
+          path: fullPath,
+          mtimeMs: stat.mtimeMs,
+          size: stat.size
+        };
+      })
+      .sort((a, b) => b.mtimeMs - a.mtimeMs)
+      .slice(0, 40);
+
+    return files.map(file => this.describe(file));
+  }
+
+  readMessages(workingDirectory, resumeSessionId) {
+    const id = String(resumeSessionId || '').trim();
+    if (!/^[0-9a-f-]{36}$/i.test(id)) return [];
+    const filePath = path.join(this.getProjectDirectory(workingDirectory), `${id}.jsonl`);
+    if (!fs.existsSync(filePath)) return [];
+
+    const messages = [];
+    try {
+      const lines = fs.readFileSync(filePath, 'utf8').split('\n').filter(Boolean);
+      for (const line of lines) {
+        const record = this.parseLine(line);
+        if (!record || record.isSidechain) continue;
+        messages.push(...this.mapRecord(record));
+      }
+    } catch (error) {
+      this.logger.debugInfo?.(`[claude-resume] Failed to backfill ${filePath}: ${error.message}`);
+      return [];
+    }
+
+    const maxMessages = 1000;
+    const visible = messages.filter(Boolean).slice(-maxMessages);
+    if (messages.length > maxMessages) {
+      visible.unshift({
+        id: uuidv4(),
+        kind: 'event',
+        level: 'info',
+        text: `Showing the latest ${maxMessages} resumed transcript items.`,
+        createdAt: Date.now()
+      });
+    }
+    return visible;
+  }
+
+  getProjectDirectory(workingDirectory) {
+    const cwd = path.resolve(workingDirectory || this.baseDir);
+    const encoded = cwd.replace(/[^a-zA-Z0-9]/g, '-');
+    return path.join(os.homedir(), '.claude', 'projects', encoded);
+  }
+
+  describe(file) {
+    let cwd = '';
+    let firstText = '';
+    let lastText = '';
+    const userQuestions = [];
+    try {
+      const lines = fs.readFileSync(file.path, 'utf8').split('\n').filter(Boolean);
+      for (const line of lines) {
+        const parsed = this.parseLine(line);
+        if (!parsed) continue;
+        if (!cwd && typeof parsed.cwd === 'string') cwd = parsed.cwd;
+        const userText = this.extractUserText(parsed);
+        if (userText && userQuestions.at(-1) !== userText) userQuestions.push(userText);
+        const text = this.extractText(parsed);
+        if (!text) continue;
+        if (!firstText) firstText = text;
+        lastText = text;
+      }
+    } catch (error) {
+      this.logger.debugInfo?.(`[claude-resume] Failed to read ${file.path}: ${error.message}`);
+    }
+    return {
+      id: file.id,
+      cwd,
+      updatedAt: file.mtimeMs,
+      size: file.size,
+      questions: userQuestions.slice(-2).reverse().map(text => previewText(text, 120)),
+      firstText: firstText ? previewText(firstText, 120) : '',
+      lastText: lastText ? previewText(lastText, 160) : ''
+    };
+  }
+
+  mapRecord(record) {
+    const createdAt = Number.isFinite(Date.parse(record.timestamp)) ? Date.parse(record.timestamp) : Date.now();
+    const message = record.message || {};
+    const content = message.content;
+    if (record.type === 'user') {
+      if (typeof content === 'string') {
+        const text = content.trim();
+        return text && !isLocalCommandTranscript(text) ? [{ id: uuidv4(), kind: 'user', text, createdAt }] : [];
+      }
+      if (Array.isArray(content)) {
+        return content.flatMap(item => {
+          if (!item || typeof item !== 'object') return [];
+          if (item.type === 'tool_result') {
+            const text = this.textFromContent(item.content).trim();
+            return text ? [{
+              id: uuidv4(), kind: 'tool-result', toolUseId: item.tool_use_id,
+              text, isError: Boolean(item.is_error), createdAt
+            }] : [];
+          }
+          if (item.type === 'text' && typeof item.text === 'string' && item.text.trim()) {
+            const text = item.text.trim();
+            return isLocalCommandTranscript(text) ? [] : [{ id: uuidv4(), kind: 'user', text, createdAt }];
+          }
+          return [];
+        });
+      }
+    }
+
+    if (record.type === 'assistant' && Array.isArray(content)) {
+      const mapped = [];
+      const text = this.textFromContent(content).trim();
+      if (text) mapped.push({ id: uuidv4(), kind: 'assistant', text, createdAt });
+      for (const item of content) {
+        if (!item || item.type !== 'tool_use') continue;
+        mapped.push({
+          id: uuidv4(), kind: 'tool', name: item.name || 'tool',
+          summary: this.summarizeToolInput(item.input), input: item.input,
+          toolUseId: item.id, createdAt
+        });
+      }
+      return mapped;
+    }
+
+    if (record.type === 'summary' && typeof record.summary === 'string' && record.summary.trim()) {
+      return [{ id: uuidv4(), kind: 'event', level: 'info', text: `Summary: ${record.summary.trim()}`, createdAt }];
+    }
+    return [];
+  }
+
+  textFromContent(content) {
+    if (typeof content === 'string') return content;
+    if (!Array.isArray(content)) return '';
+    return content.map(item => {
+      if (!item || typeof item !== 'object') return '';
+      if (item.type === 'text' && typeof item.text === 'string') return item.text;
+      if (item.type === 'tool_result') return this.textFromContent(item.content);
+      return '';
+    }).filter(Boolean).join('\n');
+  }
+
+  summarizeToolInput(input) {
+    if (!input || typeof input !== 'object') return '';
+    if (typeof input.command === 'string') return input.command;
+    if (typeof input.file_path === 'string') return input.file_path;
+    if (typeof input.path === 'string') return input.path;
+    const serialized = JSON.stringify(input);
+    return serialized.length > 240 ? `${serialized.slice(0, 240)}...` : serialized;
+  }
+
+  parseLine(line) {
+    try {
+      return JSON.parse(line);
+    } catch (_) {
+      return null;
+    }
+  }
+
+  extractText(record) {
+    const content = record?.message?.content;
+    if (typeof content === 'string') return content.trim();
+    if (!Array.isArray(content)) return '';
+    return content.map(item => {
+      if (!item || typeof item !== 'object') return '';
+      if (item.type === 'text' && typeof item.text === 'string') return item.text;
+      if (item.type === 'tool_use') return `[tool] ${item.name || 'tool'}`;
+      return '';
+    }).filter(Boolean).join('\n').trim();
+  }
+
+  extractUserText(record) {
+    if (record?.type !== 'user') return '';
+    const content = record?.message?.content;
+    if (typeof content === 'string') {
+      const text = content.trim();
+      return isLocalCommandTranscript(text) ? '' : text;
+    }
+    if (!Array.isArray(content)) return '';
+    return content.map(item => item?.type === 'text' && typeof item.text === 'string' && !isLocalCommandTranscript(item.text) ? item.text : '')
+      .filter(Boolean).join('\n').trim();
+  }
+}
+
+module.exports = ClaudeTranscriptRepository;

package/lib/codex/image-store.js

@@ -0,0 +1,175 @@
+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 = 5;
+const CLEANUP_DELAY_MS = 5 * 60 * 1000;
+const MAX_CHUNKS = 128;
+
+function imageExtension(buffer) {
+  if (buffer.length >= 8 && buffer.subarray(0, 8).equals(Buffer.from([0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a]))) return 'png';
+  if (buffer.length >= 3 && buffer[0] === 0xff && buffer[1] === 0xd8 && buffer[2] === 0xff) return 'jpg';
+  if (buffer.length >= 6 && ['GIF87a', 'GIF89a'].includes(buffer.subarray(0, 6).toString('ascii'))) return 'gif';
+  if (buffer.length >= 12 && buffer.subarray(0, 4).toString('ascii') === 'RIFF' && buffer.subarray(8, 12).toString('ascii') === 'WEBP') return 'webp';
+  return null;
+}
+
+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);
+}
+
+class CodexImageStore {
+  constructor({ logger, root, uploadRoot } = {}) {
+    this.logger = logger || console;
+    this.root = root || path.join(os.tmpdir(), 'glad', 'codex-images');
+    this.uploadRoot = uploadRoot || path.join(os.tmpdir(), 'glad', 'codex-image-uploads');
+  }
+
+  assertSession(session) {
+    if (!session) throw inputError('Session not found', 404);
+    const structured = session.kind === 'claude-structured'
+      || (session.kind === 'codex-structured' && session.presentation === 'structured');
+    if (!structured) {
+      throw inputError('Image attachments are available only in structured chat mode');
+    }
+  }
+
+  async store(session, bytes) {
+    this.assertSession(session);
+    if (!Buffer.isBuffer(bytes) || bytes.length === 0) throw inputError('Image data is required');
+    if (bytes.length > MAX_BYTES) throw inputError('Image must be 50 MB or smaller');
+    if (session.imageAttachments.size >= MAX_PER_SESSION) throw inputError(`You can attach at most ${MAX_PER_SESSION} images at a time`);
+
+    const extension = imageExtension(bytes);
+    if (!extension) throw inputError('Only PNG, JPEG, GIF, and WebP images are supported');
+    const directory = path.join(this.root, session.id);
+    await fs.promises.mkdir(directory, { recursive: true, mode: 0o700 });
+    const attachment = {
+      id: uuidv4(),
+      name: `image.${extension}`,
+      path: path.join(directory, `${uuidv4()}.${extension}`),
+      size: bytes.length,
+      createdAt: Date.now(),
+      cleanupTimer: null
+    };
+    await fs.promises.writeFile(attachment.path, bytes, { mode: 0o600, flag: 'wx' });
+    session.imageAttachments.set(attachment.id, attachment);
+    return { id: attachment.id, name: attachment.name, size: attachment.size };
+  }
+
+  async appendChunk(session, input = {}, bytes) {
+    this.assertSession(session);
+    if (!Buffer.isBuffer(bytes) || bytes.length === 0) throw inputError('Image chunk is required');
+    const uploadId = String(input.uploadId || '');
+    const chunkIndex = Number(input.chunkIndex);
+    const chunkTotal = Number(input.chunkTotal);
+    if (!safeUploadId(uploadId)) throw inputError('Invalid image upload id');
+    if (!Number.isInteger(chunkIndex) || !Number.isInteger(chunkTotal) || chunkIndex < 0 || chunkTotal < 1 || chunkTotal > MAX_CHUNKS || chunkIndex >= chunkTotal) {
+      throw inputError('Invalid image chunk metadata');
+    }
+
+    let upload = session.imageUploads.get(uploadId);
+    if (!upload) {
+      if (chunkIndex !== 0) throw inputError('Image 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, path: path.join(directory, `${uploadId}.part`), chunkTotal, nextChunkIndex: 0, bytes: 0 };
+      session.imageUploads.set(uploadId, upload);
+    }
+    if (upload.chunkTotal !== chunkTotal || upload.nextChunkIndex !== chunkIndex) throw inputError('Image chunks arrived out of order');
+    if (upload.bytes + bytes.length > MAX_BYTES) {
+      await this.discardUpload(session, uploadId);
+      throw inputError('Image 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 };
+    }
+
+    session.imageUploads.delete(uploadId);
+    try {
+      const attachment = await this.store(session, await fs.promises.readFile(upload.path));
+      return { complete: true, attachment };
+    } finally {
+      await fs.promises.rm(upload.path, { force: true });
+    }
+  }
+
+  async discardUpload(session, uploadId) {
+    if (!session?.imageUploads || !safeUploadId(uploadId)) return false;
+    const upload = session.imageUploads.get(uploadId);
+    if (!upload) return false;
+    session.imageUploads.delete(uploadId);
+    await fs.promises.rm(upload.path, { force: true });
+    return true;
+  }
+
+  async discardAttachment(session, attachmentId) {
+    if (!session || !['claude-structured', 'codex-structured'].includes(session.kind)) return false;
+    const attachment = session.imageAttachments.get(attachmentId);
+    if (!attachment) return false;
+    clearTimeout(attachment.cleanupTimer);
+    session.imageAttachments.delete(attachmentId);
+    await fs.promises.rm(attachment.path, { force: true });
+    return true;
+  }
+
+  resolve(session, attachmentIds = []) {
+    if (!session || !['claude-structured', 'codex-structured'].includes(session.kind)) throw inputError('Structured session not found', 404);
+    const ids = Array.isArray(attachmentIds) ? attachmentIds : [];
+    if (ids.length > MAX_PER_SESSION) throw inputError(`You can attach at most ${MAX_PER_SESSION} images at a time`);
+    const uniqueIds = [...new Set(ids.map(String))];
+    if (uniqueIds.length !== ids.length) throw inputError('Duplicate image attachment');
+    return uniqueIds.map(attachmentId => {
+      const attachment = session.imageAttachments.get(attachmentId);
+      if (!attachment) throw inputError('Image attachment is no longer available');
+      return attachment;
+    });
+  }
+
+  scheduleCleanup(session, attachmentIds) {
+    if (!session || !['claude-structured', 'codex-structured'].includes(session.kind)) return;
+    for (const attachmentId of attachmentIds) {
+      const attachment = session.imageAttachments.get(attachmentId);
+      if (!attachment) continue;
+      clearTimeout(attachment.cleanupTimer);
+      attachment.cleanupTimer = setTimeout(() => {
+        this.discardAttachment(session, attachmentId).catch(error => {
+          this.logger.debugInfo?.(`[structured-image] cleanup failed: ${error.message}`);
+        });
+      }, CLEANUP_DELAY_MS);
+      attachment.cleanupTimer.unref?.();
+    }
+  }
+
+  clearAttachments(session) {
+    if (!session?.imageAttachments) return;
+    for (const attachment of session.imageAttachments.values()) clearTimeout(attachment.cleanupTimer);
+    session.imageAttachments.clear();
+    fs.promises.rm(path.join(this.root, session.id), { recursive: true, force: true }).catch(error => {
+      this.logger.debugInfo?.(`[structured-image] session cleanup failed: ${error.message}`);
+    });
+  }
+
+  clearUploads(session) {
+    if (!session?.imageUploads) return;
+    session.imageUploads.clear();
+    fs.promises.rm(path.join(this.uploadRoot, session.id), { recursive: true, force: true }).catch(error => {
+      this.logger.debugInfo?.(`[structured-image] upload cleanup failed: ${error.message}`);
+    });
+  }
+}
+
+module.exports = CodexImageStore;

package/lib/codex/structured-session.js

@@ -167,8 +167,10 @@ class CodexStructuredSession extends EventEmitter {
     this.currentTurnId = null;
     this.currentTurnStartedAt = null;
     this.threadTurns = new Map();
+    this.turnContexts = new Map();
     this.providerItemContexts = new Map();
     this.tokenUsage = null;
+    this.compacting = false;
     this.permissionMode = normalizePermissionMode(options.permissionMode);
     this.sandboxMode = normalizeSandboxMode(options.sandboxMode);
     this.effectivePermissionMode = null;
@@ -226,6 +228,8 @@ class CodexStructuredSession extends EventEmitter {
       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),
+      compacting: this.compacting,
       canSwitchToTerminal: this.presentation === 'structured' && this.status === 'idle' && Boolean(this.threadId),
       canSwitchToStructured: this.presentation === 'terminal',
       pendingPermissionCount: this.pendingPermissions.size, activeSubagentCount, models: this.models };
@@ -289,6 +293,7 @@ class CodexStructuredSession extends EventEmitter {
           for (const request of this.pendingRequests.values()) request.reject(new Error(`Codex app-server exited (${code})`));
           this.pendingRequests.clear();
           if (this.running && this.presentation === 'structured') {
+            this.compacting = false;
             this.append({ kind: 'event', level: 'error', text: 'Codex app-server exited.' });
             this.setStatus('idle');
           }
@@ -382,6 +387,7 @@ class CodexStructuredSession extends EventEmitter {
   handleNotification(method, params) {
     if (method === 'thread/tokenUsage/updated') {
       this.tokenUsage = params.tokenUsage || params.usage || params;
+      this.recordTurnContext(params.turnId, this.tokenUsage);
       return;
     }
     if (method === 'turn/started') {
@@ -411,8 +417,9 @@ class CodexStructuredSession extends EventEmitter {
       const startedAtMs = trackedTurn?.startedAt || ((!threadId || threadId === this.threadId) ? this.currentTurnStartedAt : null);
       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 });
+        durationMs, createdAt: completedAtMs, ...(context ? { context } : {}) });
       const observedNow = Date.now();
       const observedCompletedAtMs = Math.abs(observedNow - completedAtMs) < 5000
         ? Math.max(completedAtMs, observedNow) : completedAtMs;
@@ -424,8 +431,13 @@ class CodexStructuredSession extends EventEmitter {
         this.patch(item.id, { toolStatus,
           completedAtMs: observedCompletedAtMs, ...(toolDurationMs != null ? { durationMs: toolDurationMs } : {}) });
       }
+      for (const item of this.messages.filter(message => message.kind === 'compaction'
+        && message.turnId === completedTurnId && message.compactionStatus === 'running')) {
+        this.patch(item.id, { compactionStatus: 'completed', completedAtMs: observedCompletedAtMs });
+      }
       if (threadId) this.threadTurns.delete(threadId);
       if (!threadId || threadId === this.threadId) {
+        this.compacting = false;
         for (const pending of this.pendingPermissions.values()) {
           this.recordPermission(pending.public, 'denied', 'abort');
         }
@@ -442,6 +454,14 @@ class CodexStructuredSession extends EventEmitter {
       }
       return;
     }
+    if (method === 'thread/compacted') {
+      const threadId = params.threadId || this.threadId;
+      const turnId = params.turnId || (threadId ? this.threadTurns.get(threadId)?.turnId : null) || this.currentTurnId;
+      this.applyProviderItem({ id: `compaction-${turnId || Date.now()}`, type: 'contextCompaction', threadId, turnId }, 'completed', {
+        threadId, turnId, completedAtMs: Date.now()
+      });
+      return;
+    }
     if (method === 'thread/started' || method === 'thread/resumed') {
       const threadId = params.thread?.id || params.threadId;
       if (threadId && !this.threadId) { this.threadId = threadId; this.emitControlState(); }
@@ -451,7 +471,7 @@ class CodexStructuredSession extends EventEmitter {
       const threadId = params.threadId || this.threadId;
       const status = params.status?.type || params.status;
       if (!threadId || threadId === this.threadId) {
-        if (status === 'idle' && !this.currentTurnId) this.setStatus('idle');
+        if (status === 'idle' && !this.currentTurnId) { this.compacting = false; this.setStatus('idle'); }
         if (status === 'active') this.setStatus('running');
       }
       return;
@@ -467,7 +487,7 @@ class CodexStructuredSession extends EventEmitter {
     }
     if (method === 'error') {
       this.append({ kind: 'event', level: 'error', text: params.error?.message || 'Codex reported an error.' });
-      if (!params.willRetry) this.setStatus('idle');
+      if (!params.willRetry) { this.compacting = false; this.setStatus('idle'); }
       return;
     }
     if (method === 'warning' || method === 'guardianWarning') {
@@ -519,9 +539,10 @@ class CodexStructuredSession extends EventEmitter {
   applyProviderItem(raw, inferredStatus = null, context = {}) {
     if (!raw || typeof raw !== 'object') return;
     const providerId = String(raw.id || '');
-    const existing = providerId && this.messages.find(item => item.providerId === providerId);
+    let existing = providerId && this.messages.find(item => item.providerId === providerId);
     const kind = raw.type === 'userMessage' ? 'user' : raw.type === 'agentMessage' ? 'assistant' : ['reasoning', 'plan'].includes(raw.type) ? 'reasoning'
-      : ['commandExecution', 'fileChange', 'mcpToolCall', 'dynamicToolCall', 'webSearch', 'collabAgentToolCall'].includes(raw.type) ? 'tool' : null;
+      : ['commandExecution', 'fileChange', 'mcpToolCall', 'dynamicToolCall', 'webSearch', 'collabAgentToolCall'].includes(raw.type) ? 'tool'
+        : raw.type === 'contextCompaction' ? 'compaction' : null;
     if (!kind) return;
     const text = kind === 'user' ? textFromInputItems(raw.content) : kind === 'assistant' ? String(raw.text || '')
       : kind === 'reasoning' ? (raw.text || (Array.isArray(raw.summary) ? raw.summary.join('\n') : Array.isArray(raw.content) ? raw.content.join('\n') : '')) : '';
@@ -530,6 +551,9 @@ class CodexStructuredSession extends EventEmitter {
     const threadId = raw.threadId || context.threadId || null;
     const trackedTurnId = threadId ? this.threadTurns.get(threadId)?.turnId : null;
     const turnId = raw.turnId || context.turnId || trackedTurnId || this.currentTurnId;
+    if (!existing && kind === 'compaction' && turnId) {
+      existing = this.messages.find(item => item.kind === 'compaction' && item.turnId === turnId);
+    }
     if (providerId && (threadId || turnId)) this.providerItemContexts.set(providerId, { threadId, turnId });
     const existingStartedAtMs = existing?.startedAtMs || existing?.createdAt || null;
     const startedAtMs = Number(context.startedAtMs || raw.startedAtMs || 0)
@@ -546,6 +570,8 @@ class CodexStructuredSession extends EventEmitter {
     };
     const patch = kind === 'tool' ? { ...toolDetails(raw), threadId, turnId,
       ...timing, toolStatus: inferredToolStatus || raw.status || 'running' }
+      : kind === 'compaction' ? { providerId, threadId, turnId, ...timing,
+        compactionStatus: inferredStatus || raw.status || 'running' }
       : { text, threadId, turnId, streaming: false, ...(completedAtMs ? { completedAtMs } : {}) };
     if (existing) {
       this.patch(existing.id, patch);
@@ -556,6 +582,10 @@ class CodexStructuredSession extends EventEmitter {
     } else {
       this.append({ kind, providerId, ...(startedAtMs ? { createdAt: startedAtMs } : {}), ...patch });
     }
+    if (kind === 'compaction' && (!threadId || threadId === this.threadId)) {
+      this.compacting = patch.compactionStatus === 'running';
+      this.emitControlState();
+    }
   }
 
   async refreshModels() {
@@ -625,8 +655,8 @@ class CodexStructuredSession extends EventEmitter {
     return items;
   }
 
-  contextStatus() {
-    const usage = this.tokenUsage || {};
+  contextStatus(tokenUsage = this.tokenUsage) {
+    const usage = tokenUsage || {};
     const selectedModel = this.models.find(item => item.id === this.model);
     const contextWindow = Number(usage.modelContextWindow || usage.model_context_window
       || usage.contextWindow || usage.context_window || selectedModel?.contextWindow || 0);
@@ -646,6 +676,16 @@ class CodexStructuredSession extends EventEmitter {
     };
   }
 
+  recordTurnContext(turnId, tokenUsage = this.tokenUsage) {
+    const id = String(turnId || '').trim();
+    const context = this.contextStatus(tokenUsage);
+    if (!id || !context) return context;
+    this.turnContexts.set(id, context);
+    const turnEnd = this.messages.find(item => item.kind === 'turn-end' && String(item.turnId || '') === id);
+    if (turnEnd) this.patch(turnEnd.id, { context });
+    return context;
+  }
+
   async showStatus() {
     if (this.presentation !== 'structured') return false;
     await this.ensureProcess();
@@ -759,6 +799,22 @@ class CodexStructuredSession extends EventEmitter {
     }
   }
 
+  async compactContext() {
+    if (!this.threadId || this.presentation !== 'structured' || this.status !== 'idle') return false;
+    await this.ensureProcess();
+    this.compacting = true;
+    this.setStatus('running');
+    try {
+      await this.request('thread/compact/start', { threadId: this.threadId });
+      return true;
+    } catch (error) {
+      this.compacting = false;
+      this.setStatus('idle');
+      this.append({ kind: 'event', level: 'error', text: `Unable to compact context: ${error.message}` });
+      throw error;
+    }
+  }
+
   write(data) {
     if (this.presentation === 'terminal') return this.terminalSession?.write(data) || false;
     const text = String(data || '').replace(/\r/g, '\n');
@@ -848,6 +904,7 @@ class CodexStructuredSession extends EventEmitter {
     this.tokenUsage = thread?.tokenUsage || thread?.token_usage || this.tokenUsage;
     this.messages = [];
     this.completedPermissions = [];
+    this.turnContexts.clear();
     this.providerItemContexts.clear();
     for (const turn of thread?.turns || []) {
       const status = turn.status === 'failed' ? 'failed' : turn.status === 'interrupted' ? 'cancelled' : 'completed';