codex-overleaf-link 2.5.0 → 2.6.0

package/extension/src/shared/compileAdapter.js

@@ -9,47 +9,48 @@
 
   const MAX_LOG_BYTES = 32 * 1024;
   const COMPILABLE_EXTENSIONS = new Set(['.tex', '.bib', '.sty', '.cls', '.bst', '.bbx', '.cbx']);
-
   function parseCompileResponse(response) {
-    if (!response || typeof response !== 'object') {
-      return { ok: false, reason: 'Invalid compile response: not an object' };
-    }
-
-    if (!Array.isArray(response.outputFiles)) {
-      return { ok: false, reason: 'Invalid compile response: outputFiles is not an array' };
-    }
-
-    const logFile = response.outputFiles.find(function (file) {
+    if (!response || typeof response !== 'object') return { ok: false, reason: 'Invalid compile response: not an object' };
+    if (!Array.isArray(response.outputFiles)) return { ok: false, status: response.status, reason: 'Invalid compile response: outputFiles is not an array' };
+    const logFile = response.outputFiles.find(file => /(^|\/)output\.log$/.test(file?.path || '')) || response.outputFiles.find(function (file) {
       if (!file) return false;
       if (file.type === 'log') return true;
       if (typeof file.path === 'string' && file.path.endsWith('.log')) return true;
       return false;
     });
-
-    if (!logFile) {
-      return { ok: false, reason: 'No log file found in compile output' };
-    }
-
-    var logUrl = logFile.url || null;
-    if (!logUrl) {
-      return { ok: false, reason: 'Log file has no URL' };
-    }
-
+    if (!logFile) return { ok: false, status: response.status, reason: 'No log file found in compile output' };
+    var logUrl = typeof logFile.url === 'string' ? logFile.url : null;
+    if (!logUrl) return { ok: false, status: response.status, reason: 'Log file has no URL' };
     return {
       ok: true,
       status: response.status,
+      fromCache: response.fromCache === true,
       logUrl: logUrl,
-      logPath: logFile.path || null
+      logPath: logFile.path || null,
+      build: logFile.build || null,
+      pdfDownloadDomain: normalizePdfDownloadDomain(response.pdfDownloadDomain),
+      clsiServerId: typeof response.clsiServerId === 'string' && /^[A-Za-z0-9_-]{1,128}$/.test(response.clsiServerId)
+        ? response.clsiServerId : null
     };
   }
 
+  function normalizePdfDownloadDomain(value) {
+    if (typeof value !== 'string' || !/^https:\/\/[^\s\\]+$/i.test(value)) return null;
+    try {
+      const url = new URL(value);
+      return url.protocol === 'https:' && !url.username && !url.password && !url.search && !url.hash ? value : null;
+    } catch (_error) {
+      return null;
+    }
+  }
+
   function extractErrorBlocks(lines) {
     var blocks = [];
     var i = 0;
 
     while (i < lines.length && blocks.length < 20) {
       var line = lines[i];
-      if (line.startsWith('!') || /^l\.\d+/.test(line)) {
+      if (isLogErrorLine(line) || /^l\.\d+/.test(line)) {
         var block = [];
         // Collect surrounding context: go back up to 2 lines for pre-context
         var start = Math.max(0, i - 2);
@@ -82,13 +83,9 @@
   }
 
   function truncateLogForContext(log) {
-    if (!log || typeof log !== 'string') {
-      return '';
-    }
+    if (!log || typeof log !== 'string') return '';
 
-    if (new Blob([log]).size <= MAX_LOG_BYTES) {
-      return log;
-    }
+    if (new Blob([log]).size <= MAX_LOG_BYTES) return log;
 
     var lines = log.split('\n');
     var errorBlocks = extractErrorBlocks(lines);
@@ -108,31 +105,28 @@
   }
 
   function isCompileLogFresh(log, lastKnownSourceEditTimestamp) {
-    if (!log || typeof log !== 'object') {
-      return false;
-    }
-
-    if (log.sourceChangeTimestamp == null) {
-      return false;
-    }
+    if (!log || typeof log !== 'object') return false;
+    if (log.sourceChangeTimestamp == null) return false;
 
     return log.sourceChangeTimestamp >= lastKnownSourceEditTimestamp;
   }
 
   function isCompilableFile(filePath) {
-    if (!filePath || typeof filePath !== 'string') {
-      return false;
-    }
+    if (!filePath || typeof filePath !== 'string') return false;
 
     var lastDot = filePath.lastIndexOf('.');
-    if (lastDot === -1) {
-      return false;
-    }
+    if (lastDot === -1) return false;
 
     var ext = filePath.slice(lastDot).toLowerCase();
     return COMPILABLE_EXTENSIONS.has(ext);
   }
 
+  function isLogErrorLine(line) {
+    // TeX's -file-line-error output (used by Overleaf) has no leading '!'.
+    return line.startsWith('!') || /^Runaway argument/.test(line)
+      || (/^(?:\.{0,2}\/|[A-Za-z]:[\\/])?.+?:\d+:\s+\S/.test(line) && !/\bWarning\b/i.test(line));
+  }
+
   function parseLogErrors(logContent) {
     var result = { errors: [], warnings: [] };
 
@@ -142,20 +136,23 @@
 
     var lines = logContent.split('\n');
 
-    // Extract errors: lines starting with '!' plus up to 3 following context lines
+    // Retain the bounded error list; consumers limit displayed snippets separately.
     for (var i = 0; i < lines.length && result.errors.length < 50; i++) {
-      if (lines[i].startsWith('!')) {
+      if (isLogErrorLine(lines[i])) {
         var errorLines = [lines[i]];
         for (var j = 1; j <= 3 && (i + j) < lines.length; j++) {
+          if (!lines[i + j].trim() || isLogErrorLine(lines[i + j])) break;
           errorLines.push(lines[i + j]);
         }
         result.errors.push(errorLines.join('\n'));
       }
     }
 
-    // Extract warnings: lines matching /Warning/i that don't start with whitespace
+    // Count only the warning forms Overleaf's own log parser reports, so
+    // informational lines such as "Package: infwarerr … info/warning/error
+    // messages" are not shown as warnings.
     for (var k = 0; k < lines.length && result.warnings.length < 50; k++) {
-      if (/Warning/i.test(lines[k]) && !/^\s/.test(lines[k])) {
+      if (/^LaTeX(?:3| Font)? Warning: /.test(lines[k]) || /^(?:Package|Class|Module) \b.+\b Warning:/.test(lines[k])) {
         result.warnings.push(lines[k]);
       }
     }
@@ -164,34 +161,35 @@
   }
 
   function buildPostWriteCompileSummary({ result = null, logResult = null, error = null } = {}) {
-    const logAvailable = logResult?.ok === true;
+    const captured = result?.ok === true && result.resultCaptured === true
+      && Number.isSafeInteger(result.compile?.captureId) && result.compile.captureId > 0;
+    const logAvailable = captured && logResult?.ok === true && logResult.fresh === true
+      && result.compile?.captureId === logResult.captureId;
     const errors = logAvailable && Array.isArray(logResult.errors)
-      ? logResult.errors.slice(0, 5).map(formatCompileDiagnosticForSummary)
+      ? logResult.errors.map(formatCompileDiagnosticForSummary)
       : [];
     const warnings = logAvailable && Array.isArray(logResult.warnings)
       ? logResult.warnings.slice(0, 5).map(formatCompileDiagnosticForSummary)
       : [];
-    if (error) {
-      return {
-        status: 'failed',
-        reason: error?.message || 'Post-write compile failed.',
-        errors,
-        warnings,
-        logAvailable
-      };
-    }
-    if (!result?.ok) {
-      return {
-        status: 'failed',
-        reason: result?.reason || 'Post-write compile did not succeed.',
-        errors,
-        warnings,
-        logAvailable
-      };
+    const compilerFailed = captured && logResult?.fresh !== false
+      && ['failed', 'failure', 'error', 'timedout', 'timeout'].includes(result.compile?.status);
+    if (compilerFailed && !errors.length) errors.push('Post-write compile failed.');
+    const failed = compilerFailed || errors.length > 0;
+    const success = captured && result.compile?.ok === true && result.compile.status === 'success'
+      && result.compile.fromCache !== true && logAvailable;
+    const status = failed ? 'failed' : success ? 'success' : result?.ok && !captured ? 'triggered' : 'unconfirmed';
+    let reason = error ? error?.message || 'Post-write compile failed.'
+      : !result?.ok ? result?.reason || 'Post-write compile did not succeed.' : result.reason || '';
+    if (status === 'unconfirmed' || status === 'triggered') {
+      // Technical evidence belongs in the existing activity output, not the outcome label.
+      reason ||= logResult?.reason || (!captured ? 'compile_capture_missing'
+        : result.compile?.reason || (result.compile.fromCache ? 'compile_response_from_cache'
+          : logResult?.captureId !== result.compile.captureId ? 'compile_log_capture_mismatch'
+            : logResult?.fresh === false ? 'compile_log_stale' : 'compile_result_unconfirmed'));
     }
     return {
-      status: result.compile?.status || 'triggered',
-      reason: result.reason || '',
+      status,
+      reason,
       errors,
       warnings,
       logAvailable
@@ -203,9 +201,74 @@
     return text.length > 180 ? `${text.slice(0, 179)}...` : text;
   }
 
+  // Page/adapter-owned explanations and activity labels are display copy. TeX logs and unknown
+  // upstream diagnostics stay literal; callers retain the original evidence.
+  function localizeCompileReason(value, locale = 'en', depth = 0) {
+    const text = String(value || '');
+    const zh = /^zh(?:\b|[-_])/i.test(String(locale));
+    const messages = [
+      ['Compile succeeded.', '编译成功。'],
+      ['Overleaf compile was triggered. The page will continue showing progress.', '已触发 Overleaf 编译；页面会继续显示编译进度。'],
+      ['Fetching compile log (@compile-log).', '正在获取编译日志 (@compile-log)。'],
+      ['Overleaf save state was not verified.', '尚未确认 Overleaf 已保存。'],
+      ['No Overleaf Recompile button or compile request template is available.', '没有可用的 Overleaf 重新编译按钮或编译请求模板。'],
+      ['Stored compile request template expired. Please click Overleaf Recompile once, then retry.', '已保存的编译请求模板已过期。请先点击一次 Overleaf 重新编译，再重试。'],
+      ['CompileAdapter not available', '编译适配器不可用'],
+      ['CompileAdapter not loaded', '编译适配器未加载'],
+      ['Overleaf save-state checker is unavailable.', 'Overleaf 保存状态检查器不可用。'],
+      ['No compile log URL available', '没有可用的编译日志地址'],
+      ['Clicked Overleaf Recompile, but no compile result was captured.', '已点击 Overleaf 重新编译，但未获取到编译结果。'],
+      ['Invalid compile response: not an object', '编译响应无效：结果不是对象'],
+      ['Invalid compile response: outputFiles is not an array', '编译响应无效：outputFiles 不是数组'],
+      ['No log file found in compile output', '编译输出中未找到日志文件'],
+      ['Log file has no URL', '日志文件没有可用地址'],
+      ['Post-write compile failed.', '写后编译失败。'],
+      ['Post-write compile did not succeed.', '写后编译未成功。'],
+      ['Overleaf save state has not been checked yet.', '尚未检查 Overleaf 保存状态。'],
+      ['Overleaf save state is unavailable.', 'Overleaf 保存状态不可用。'],
+      ['Overleaf is offline; saving cannot be confirmed.', 'Overleaf 当前离线，无法确认保存。'],
+      ['Overleaf document is unavailable for save-state detection.', 'Overleaf 文档不可用，无法检测保存状态。'],
+      ['Overleaf save indicator reports changes are not saved.', 'Overleaf 保存指示器显示修改尚未保存。'],
+      ['Overleaf is still saving or syncing changes.', 'Overleaf 仍在保存或同步修改。'],
+      ['Overleaf save indicator was present, but did not verify that all changes are saved.', '已找到 Overleaf 保存指示器，但未能确认全部修改已保存。'],
+      ['Overleaf save indicator was not found.', '未找到 Overleaf 保存指示器。']
+    ];
+    for (const [en, chinese] of messages) {
+      if (text === en || text === chinese) return zh ? chinese : en;
+    }
+    for (const [en, chinese] of [
+      ['Compile request failed with status ', '编译请求失败，状态码为 '],
+      ['Failed to fetch compile log: ', '获取编译日志失败，状态码为 ']
+    ]) {
+      const prefix = text.startsWith(en) ? en : text.startsWith(chinese) ? chinese : '';
+      if (prefix && /^\d{3}$/.test(text.slice(prefix.length))) return (zh ? chinese : en) + text.slice(prefix.length);
+    }
+    if (depth < 4) for (const [en, chinese] of [
+      ['Post-write compile did not succeed: ', '写后编译未成功：'],
+      ['Post-write compile failed: ', '写后编译出错：'],
+      ['Compile log unavailable: ', '编译日志不可用：'],
+      ['Compile request error: ', '编译请求出错：'],
+      ['Overleaf save-state checker failed: ', 'Overleaf 保存状态检查失败：'],
+      ['Could not check Overleaf save state: ', '无法检查 Overleaf 保存状态：'],
+      ['Could not get fresh compile: ', '无法获取最新编译结果：'],
+      ['Log fetch error: ', '获取日志出错：'],
+      ['Timed out waiting for Overleaf to finish saving changes.', '等待 Overleaf 完成保存超时。'],
+      ['Timed out waiting for a verified Overleaf save state.', '等待确认 Overleaf 保存状态超时。']
+    ]) {
+      const prefix = text.startsWith(en) ? en : text.startsWith(chinese) ? chinese : '';
+      if (prefix) {
+        const rest = text.slice(prefix.length);
+        if (prefix === en && en.endsWith('.') && rest && !rest.startsWith(' ')) continue;
+        const suffix = localizeCompileReason(prefix === en && en.endsWith('.') ? rest.slice(1) : rest, locale, depth + 1);
+        return (zh ? chinese : en) + (!zh && suffix && en.endsWith('.') ? ' ' : '') + suffix;
+      }
+    }
+    return text;
+  }
   return {
     buildPostWriteCompileSummary,
     formatCompileDiagnosticForSummary,
+    localizeCompileReason,
     COMPILABLE_EXTENSIONS,
     MAX_LOG_BYTES,
     extractErrorBlocks,

package/extension/src/shared/composerAttachmentDraft.js

@@ -0,0 +1,156 @@
+(function (root, factory) {
+  if (typeof module === 'object' && module.exports) module.exports = factory(require('./sessionState'));
+  else root.CodexOverleafModuleRegistry.define('ComposerAttachmentDraft', ['SessionState'], factory);
+})(typeof globalThis !== 'undefined' ? globalThis : this, function (SessionState) {
+  'use strict';
+  const EPOCH_KEY = 'composer-attachment-draft:clear-epoch';
+  const normalize = value => SessionState.normalizeComposerAttachmentsForPersistence(value);
+  const scopeKey = scope => JSON.stringify([scope?.accountScopeId || '', scope?.projectId || '']);
+  function checkedScope(scope) {
+    const accountScopeId = String(scope?.accountScopeId || '').trim();
+    const projectId = String(scope?.projectId || '').trim();
+    if (!accountScopeId || !projectId) throw failure('account_scope_unavailable');
+    return { accountScopeId, projectId };
+  }
+  function failure(code) {
+    return Object.assign(new Error(code === 'composer_draft_cleared'
+      ? 'Saved attachments were cleared in another tab. Reload, then reattach files before retrying.'
+      : code === 'composer_draft_conflict'
+        ? 'The saved attachment draft changed in another tab. Reload before changing it.'
+        : 'Attachment draft scope is unavailable or changed.'), { code });
+  }
+  function createStore(openDb) {
+    async function access(input, value) {
+      const scope = checkedScope(input);
+      const id = 'composer-attachment-draft:' + scopeKey(scope);
+      const db = await openDb();
+      return new Promise((resolve, reject) => {
+        const tx = db.transaction('artifacts', value ? 'readwrite' : 'readonly');
+        const store = tx.objectStore('artifacts');
+        let result, error;
+        tx.oncomplete = () => resolve(result);
+        tx.onerror = tx.onabort = () => reject(error || tx.error || new Error('Attachment draft transaction failed.'));
+        const epochRequest = store.get(EPOCH_KEY);
+        epochRequest.onsuccess = () => {
+          const epoch = Number(epochRequest.result?.epoch) || 0;
+          const clearedAt = Number(epochRequest.result?.clearedAt) || 0;
+          const request = store.get(id);
+          request.onsuccess = () => {
+            try {
+              const previous = request.result;
+              if (previous && (previous.accountScopeId !== scope.accountScopeId || previous.projectId !== scope.projectId)) {
+                throw failure('account_scope_unavailable');
+              }
+              const revision = Number(previous?.revision) || 0;
+              result = { epoch, clearedAt, revision, attachments: normalize(previous?.attachments) };
+              if (!value) return;
+              const attachments = normalize(value.attachments);
+              if (value.epoch !== epoch) {
+                // A clear performed by this page also invalidates its old base.
+                // Its empty draft needs no write; an old nonempty draft cannot return.
+                if (!attachments.length) return;
+                throw failure('composer_draft_cleared');
+              }
+              if (value.revision !== revision) {
+                // Writing what another tab already stored changes nothing (for example
+                // both tabs clearing an empty draft on send); only a real edit conflicts.
+                if (JSON.stringify(attachments) === JSON.stringify(result.attachments)) return;
+                throw failure('composer_draft_conflict');
+              }
+              if (attachments.length && value.unbased && clearedAt && value.changedAt <= clearedAt) {
+                throw failure('composer_draft_cleared');
+              }
+              result = { epoch, clearedAt, revision: revision + 1, attachments };
+              store.put({ id, type: 'composer-attachment-draft', ...scope, ...result });
+            } catch (caught) { error = caught; tx.abort(); }
+          };
+        };
+      });
+    }
+    async function clear(storeNames) {
+      const db = await openDb();
+      return new Promise((resolve, reject) => {
+        const tx = db.transaction(storeNames, 'readwrite');
+        const artifacts = tx.objectStore('artifacts');
+        const request = artifacts.get(EPOCH_KEY);
+        let epoch;
+        request.onsuccess = () => {
+          epoch = (Number(request.result?.epoch) || 0) + 1;
+          for (const name of storeNames) tx.objectStore(name).clear();
+          artifacts.put({ id: EPOCH_KEY, type: 'composer-attachment-draft-epoch', epoch, clearedAt: Date.now() });
+        };
+        tx.oncomplete = () => resolve({ composerDraftEpoch: epoch });
+        tx.onerror = tx.onabort = () => reject(tx.error || new Error('History clear failed.'));
+      });
+    }
+    return { read: scope => access(scope), write: (scope, value) => access(scope, value), clear };
+  }
+
+  function createController(options) {
+    let scope = options.getScope(), key = scopeKey(scope), generation = 0;
+    let base = null, hydrated = false, changedVersion = 0, savedVersion = 0;
+    let dirtySince = 0, dirtyUnbased = false, loadSequence = 0;
+    let saving = Promise.resolve();
+    const publish = () => options.setAttachments(normalize(options.getAttachments()));
+    function syncScope() {
+      const next = options.getScope(), nextKey = scopeKey(next);
+      if (nextKey === key) return;
+      scope = next; key = nextKey; generation++;
+      base = null; hydrated = false; changedVersion = savedVersion = 0; dirtySince = 0; dirtyUnbased = false;
+      options.clear(); publish();
+    }
+    async function load(requestedScope = options.getScope()) {
+      syncScope();
+      if (scopeKey(requestedScope) !== key) throw failure('stale_hydration');
+      const captured = generation, sequence = ++loadSequence;
+      const snapshot = await options.read(checkedScope(scope));
+      if (captured !== generation || sequence !== loadSequence || scopeKey(options.getScope()) !== key) throw failure('stale_hydration');
+      if (base && snapshot.epoch !== base.epoch) {
+        // Adopt an observed history clear together with its empty local view;
+        // otherwise the next edit could attach an old view to the new epoch.
+        options.clear(); changedVersion = savedVersion = 0; dirtySince = 0; dirtyUnbased = false;
+        hydrated = false; base = snapshot; publish();
+      }
+      const keepLocal = changedVersion || hydrated;
+      // A read alone does not give an unchanged visible draft a newer CAS base.
+      if (!base || !keepLocal) base = snapshot;
+      return keepLocal ? normalize(options.getAttachments()) : snapshot.attachments;
+    }
+    function hydrate(attachments) {
+      syncScope();
+      if (hydrated) return;
+      // Loading is allowed to finish after a local add/remove. Local edits win.
+      if (!changedVersion && !options.getAttachments().length) options.restore(normalize(attachments));
+      hydrated = true; publish();
+    }
+    function changed() {
+      const before = key;
+      syncScope();
+      if (before !== key) return;
+      if (changedVersion === savedVersion) { dirtySince = Date.now(); dirtyUnbased = !base; }
+      changedVersion++; hydrated = true; publish(); options.scheduleSave();
+    }
+    function save(requestedScope = options.getScope()) {
+      syncScope();
+      if (scopeKey(requestedScope) !== key) return Promise.resolve();
+      const captured = generation;
+      const work = async () => {
+        if (captured !== generation || scopeKey(options.getScope()) !== key || changedVersion === savedVersion) return;
+        const version = changedVersion;
+        const attachments = normalize(options.getAttachments());
+        const unbased = dirtyUnbased, changedAt = dirtySince;
+        if (!base) await load(scope);
+        if (captured !== generation || scopeKey(options.getScope()) !== key) return;
+        const written = await options.write(checkedScope(scope), { ...base, attachments, unbased, changedAt });
+        if (captured !== generation) return;
+        base = written; savedVersion = version;
+        if (changedVersion === version) { dirtySince = 0; dirtyUnbased = false; }
+      };
+      const next = saving.then(work, work);
+      saving = next.catch(() => {});
+      return next;
+    }
+    return { syncScope, load, hydrate, changed, save };
+  }
+  return { createStore, createController, normalize, EPOCH_KEY };
+});

package/extension/src/shared/contextUsage.js

@@ -0,0 +1,125 @@
+(function initContextUsage(root, factory) {
+  if (typeof module === 'object' && module.exports) module.exports = factory();
+  else root.CodexOverleafModuleRegistry.define('ContextUsage', [], factory);
+})(typeof globalThis !== 'undefined' ? globalThis : window, function contextUsageFactory() {
+  'use strict';
+
+  const count = value => Number.isSafeInteger(value) && value >= 0 ? value : null;
+  const identity = value => typeof value === 'string' && value.trim() && value.length <= 512
+    && !/[\0\r\n]/.test(value) ? value.trim() : '';
+  const timestamp = value => typeof value === 'string' && Number.isFinite(Date.parse(value))
+    ? new Date(value).toISOString() : '';
+
+  // Store a bounded fact from one model response, never the cumulative billed
+  // token total. The last reported response is an estimate of context occupancy;
+  // tool output added since then is not included until the next server update.
+  function normalize(value) {
+    if (!value || value.v !== 1) return null;
+    const threadId = identity(value.threadId), turnId = identity(value.turnId);
+    const runId = identity(value.runId), providerId = identity(value.providerId), model = identity(value.model);
+    const usedTokens = count(value.usedTokens), providerRevision = count(value.providerRevision);
+    const observedAt = timestamp(value.observedAt);
+    if (!threadId || !turnId || !runId || !providerId || !model || usedTokens === null
+      || providerRevision === null || !observedAt) return null;
+    const capacity = count(value.contextWindow);
+    const eventSeq = count(value.eventSeq);
+    const inputTokens = count(value.inputTokens), outputTokens = count(value.outputTokens);
+    const cachedInput = count(value.cachedInputTokens);
+    // Cache reads are a subset of input, never an additional category. Older
+    // snapshots and providers without these counters retain unknown values.
+    const cachedInputTokens = inputTokens !== null && cachedInput !== null && cachedInput <= inputTokens
+      ? cachedInput : null;
+    return { v: 1, threadId, turnId, runId, providerId, providerRevision, model,
+      usedTokens, contextWindow: capacity > 0 ? capacity : null,
+      inputTokens, outputTokens, cachedInputTokens,
+      eventSeq: eventSeq > 0 ? eventSeq : null, observedAt };
+  }
+
+  function matches(value, scope = {}) {
+    const snapshot = normalize(value);
+    return Boolean(snapshot && snapshot.threadId === identity(scope.threadId || scope.codexThreadId)
+      && snapshot.providerId === identity(scope.providerId)
+      && snapshot.providerRevision === count(scope.providerRevision)
+      && snapshot.model === identity(scope.model));
+  }
+
+  // The caller supplies the captured run owner, after its Native thread/turn
+  // binding is known. Reject worker, previous-turn and unbound notifications.
+  function fromEvent(event, owner = {}) {
+    if (!event || (event.type && event.type !== 'codex.session.event') || event.subagent === true) return null;
+    const notification = event.detail || event;
+    if (notification.method !== 'thread/tokenUsage/updated') return null;
+    const params = notification.params || {};
+    const threadId = identity(params.threadId), turnId = identity(params.turnId);
+    if (!threadId || !turnId || threadId !== identity(owner.threadId || owner.codexThreadId)
+      || turnId !== identity(owner.turnId || owner.codexTurnId) || owner.forkSnapshot === true) return null;
+    const last = params.tokenUsage?.last;
+    const usedTokens = count(last?.totalTokens);
+    if (usedTokens === null) return null;
+    return normalize({ v: 1, threadId, turnId, runId: owner.runId || owner.id,
+      providerId: owner.providerId, providerRevision: owner.providerRevision, model: owner.model,
+      usedTokens, contextWindow: params.tokenUsage?.modelContextWindow,
+      inputTokens: last?.inputTokens, outputTokens: last?.outputTokens, cachedInputTokens: last?.cachedInputTokens,
+      eventSeq: event.nativeEventSeq ?? event.eventSeq ?? event.seq ?? owner.eventSeq,
+      observedAt: timestamp(event.timestamp || event.at) || timestamp(owner.observedAt) || new Date().toISOString() });
+  }
+
+  function isNewer(next, previous) {
+    next = normalize(next); previous = normalize(previous);
+    if (!next) return false;
+    if (!previous) return true;
+    if (next.runId === previous.runId && next.threadId === previous.threadId && next.turnId === previous.turnId
+      && next.eventSeq !== null && previous.eventSeq !== null)
+      return next.eventSeq > previous.eventSeq;
+    return Date.parse(next.observedAt) > Date.parse(previous.observedAt);
+  }
+
+  // `scope.compactedAt` (epoch ms) carries an automatic compaction completed
+  // inside a normal turn; manual compact runs are read from the session.
+  // `pending` means the old sample is invalid; `compacted` additionally requires
+  // successful completion of the most recent compaction that invalidated it.
+  function status(session, scope = {}) {
+    if (!session || session.forkSnapshot === true) return { usage: null, pending: false, compacted: false };
+    const inThread = value => value && value.threadId === identity(scope.threadId || scope.codexThreadId)
+      && value.providerId === identity(scope.providerId)
+      && value.providerRevision === count(scope.providerRevision);
+    // A dispatched compaction can change this thread even when its completion
+    // is lost on reload. Do not re-display a pre-compaction sample as current.
+    const runs = Array.isArray(session.runs) ? session.runs : [];
+    let invalidatedAfter = Number.isFinite(scope.compactedAt) && scope.compactedAt > 0 ? scope.compactedAt : 0;
+    let completedAfter = invalidatedAfter;
+    for (const run of runs) {
+      if (run?.operation !== 'compact' || run.forkSnapshot
+        || run.codexThreadId !== identity(scope.threadId || scope.codexThreadId)) continue;
+      const startedAt = Date.parse(run.startedAt || '') || 0;
+      invalidatedAfter = Math.max(invalidatedAfter, startedAt);
+      if (run.status === 'completed') completedAfter = Math.max(completedAfter, startedAt);
+    }
+    let selected = normalize(session.contextUsage);
+    if (!inThread(selected)) selected = null;
+    for (const run of runs) {
+      if (run?.forkSnapshot === true) continue;
+      const candidate = normalize(run.contextUsage);
+      if (!inThread(candidate) || candidate.runId !== run.id) continue;
+      if (isNewer(candidate, selected)) selected = candidate;
+    }
+    const beforeCompaction = !selected || Date.parse(selected.observedAt) < invalidatedAfter;
+    // A later turn can grow this thread using another model. Selecting an older
+    // model again must not resurrect its obsolete, smaller context estimate.
+    const usage = selected?.model === identity(scope.model) && !beforeCompaction ? selected : null;
+    const pending = !usage && invalidatedAfter > 0 && beforeCompaction;
+    return { usage, pending, compacted: pending && completedAfter >= invalidatedAfter };
+  }
+
+  function select(session, scope = {}) {
+    return status(session, scope).usage;
+  }
+
+  // Presentation level of a reported share of the window, in percent.
+  function level(percent) {
+    if (typeof percent !== 'number' || !Number.isFinite(percent)) return '';
+    return percent >= 90 ? 'near-limit' : percent >= 70 ? 'high' : 'normal';
+  }
+
+  return { normalize, fromEvent, matches, isNewer, select, status, level };
+});

package/extension/src/shared/directoryCleanupProof.js

@@ -0,0 +1,43 @@
+(function (root, factory) {
+  if (typeof module === 'object' && module.exports) module.exports = factory();
+  else if (root.CodexOverleafModuleRegistry) root.CodexOverleafModuleRegistry.define('DirectoryCleanupProof', [], factory);
+  else root.CodexOverleafDirectoryCleanupProof = factory();
+})(typeof globalThis !== 'undefined' ? globalThis : window, function () {
+  'use strict';
+  const LIMITS = Object.freeze({ maxDirectories: 100, maxBytes: 64 * 1024 });
+  const id = (value, max = 160) => typeof value === 'string' && value.length > 0 && value.length <= max
+    && value.trim() === value && !/[\u0000-\u001f\u007f]/.test(value);
+  const path = value => id(value, 2048) && !/[\\]/.test(value) && !value.startsWith('/') && !/^[A-Za-z]:/.test(value)
+    && !value.split('/').some(part => !part || part === '.' || part === '..');
+  const ownerKeys = ['accountScopeId', 'projectId', 'sessionId', 'runId'];
+  function normalize(value) {
+    if (!value || value.v !== 1 || !ownerKeys.every(key => id(value[key])) || !Array.isArray(value.directories)
+      || !value.directories.length || value.directories.length > LIMITS.maxDirectories) return null;
+    const directories = [], seen = new Set();
+    for (const raw of value.directories) {
+      if (raw?.v !== 1 || raw.projectId !== value.projectId || !path(raw.path)
+        || typeof raw.nativeFolderId !== 'string' || (raw.nativeFolderId && !id(raw.nativeFolderId, 256))) return null;
+      const key = JSON.stringify([raw.path, raw.nativeFolderId]);
+      if (seen.has(key)) continue;
+      seen.add(key);
+      directories.push({ v: 1, projectId: raw.projectId, path: raw.path, nativeFolderId: raw.nativeFolderId,
+        // No current producer has an acknowledged server-side creator ID.
+        ownershipConfirmed: false, observedAfterCreate: raw.observedAfterCreate === true });
+    }
+    const result = { v: 1, ...Object.fromEntries(ownerKeys.map(key => [key, value[key]])), directories };
+    const bytes = typeof TextEncoder === 'function' ? new TextEncoder().encode(JSON.stringify(result)).length : JSON.stringify(result).length * 2;
+    return bytes <= LIMITS.maxBytes ? result : null;
+  }
+  function merge(owner, previous, directories) {
+    const prior = previous == null ? null : normalize(previous);
+    if (previous != null && (!prior || ownerKeys.some(key => prior[key] !== owner[key]))) return null;
+    const combined = [...(prior?.directories || [])];
+    for (const next of directories || []) {
+      const index = combined.findIndex(item => item.path === next?.path && item.projectId === next?.projectId
+        && (!item.nativeFolderId || item.nativeFolderId === next?.nativeFolderId));
+      if (index < 0) combined.push(next); else combined[index] = next;
+    }
+    return normalize({ v: 1, ...owner, directories: combined });
+  }
+  return { LIMITS, normalize, merge };
+});