codex-overleaf-link 2.4.1 → 2.5.1

package/extension/src/shared/auditRecords.js

@@ -25,6 +25,7 @@
     const now = new Date().toISOString();
     return {
       id: input.id || generateId('aud'),
+      accountScopeId: redactSecretLikeText(stringField(input.accountScopeId)),
       projectId: redactSecretLikeText(stringField(input.projectId)),
       sessionId: redactSecretLikeText(stringField(input.sessionId)),
       turnId: redactSecretLikeText(stringField(input.turnId)),
@@ -75,6 +76,7 @@
       mirror: summarizeMirror(input.mirror),
       auditLogs: summarizeAuditLogList(input.auditLogs),
       run: summarizeRun(input.run),
+      ...(Array.isArray(input.recentRuns) ? { recentRuns: input.recentRuns.slice(0, 8).map(summarizeRun) } : {}),
       governance: summarizeGovernance(input.governance),
       projectIdHash: hashString(stringField(input.projectId))
     };
@@ -83,6 +85,7 @@
   function normalizeAuditLogRecord(input = {}) {
     return {
       id: redactSecretLikeText(stringField(input.id)) || generateId('aud'),
+      accountScopeId: redactSecretLikeText(stringField(input.accountScopeId)),
       projectId: redactSecretLikeText(stringField(input.projectId)),
       sessionId: redactSecretLikeText(stringField(input.sessionId)),
       turnId: redactSecretLikeText(stringField(input.turnId)),
@@ -272,9 +275,22 @@
   }
 
   function summarizeRun(run = {}) {
+    run = run && typeof run === 'object' && !Array.isArray(run) ? run : {};
+    const captures = Array.isArray(run.trackedChangeCaptures) ? run.trackedChangeCaptures : [];
     return removeEmptySummaryFields({
       id: redactSecretLikeText(stringField(run.id)),
       status: redactSecretLikeText(stringField(run.status)),
+      startedAt: redactSecretLikeText(stringField(run.startedAt)),
+      finishedAt: redactSecretLikeText(stringField(run.finishedAt)),
+      requireReviewing: typeof run.executionSnapshot?.requireReviewing === 'boolean'
+        ? run.executionSnapshot.requireReviewing : undefined,
+      trackedChangeStatus: diagnosticToken(run.trackedChangeStatus),
+      undoStatus: diagnosticToken(run.undoStatus),
+      appliedOperationCount: Array.isArray(run.appliedOperations) ? run.appliedOperations.length : undefined,
+      undoTrackedChangeCount: Array.isArray(run.undoTrackedChanges) ? run.undoTrackedChanges.length : undefined,
+      captureCount: Array.isArray(run.trackedChangeCaptures) ? captures.length : undefined,
+      capturesTruncated: captures.length > 20 ? true : undefined,
+      trackedChangeCaptures: captures.slice(0, 20).map(summarizeTrackedCapture),
       errorCode: redactSecretLikeText(stringField(run.errorCode)),
       errorCategory: categorizeError(run.errorCode || run.message || run.error),
       events: (Array.isArray(run.events) ? run.events : []).map(event => removeEmptyFields({
@@ -287,6 +303,63 @@
     });
   }
 
+  // Export only proof metadata, never document text, prompts, labels or raw IDs.
+  function diagnosticToken(value) {
+    const text = redactSecretLikeText(stringField(value));
+    return /^[a-z][a-z0-9_]{0,79}$/.test(text) ? text : undefined;
+  }
+
+  function diagnosticNumbers(value, keys) {
+    const source = value && typeof value === 'object' ? value : {};
+    const result = {};
+    for (const key of keys) {
+      if (Number.isSafeInteger(source[key]) && source[key] >= 0) result[key] = source[key];
+    }
+    return result;
+  }
+
+  function diagnosticFingerprint(value) {
+    return typeof value === 'string' && /^\d{1,16}:[a-f0-9]{1,8}:[a-f0-9]{1,8}$/.test(value)
+      ? value : undefined;
+  }
+
+  function summarizeTrackedCapture(value) {
+    const capture = value && typeof value === 'object' && !Array.isArray(value) ? value : {};
+    const before = Array.isArray(capture.before) ? capture.before : [];
+    const refs = Array.isArray(capture.refs) ? capture.refs : [];
+    const ranges = Array.isArray(capture.ranges) ? capture.ranges : [];
+    const diagnostics = capture.diagnostics || {};
+    const refSummary = ref => removeEmptySummaryFields({
+      idHash: stringField(ref?.id) ? hashString(ref.id) : undefined,
+      kind: diagnosticToken(ref?.kind),
+      ...diagnosticNumbers(ref, ['from', 'to', 'textLength']),
+      textHash: diagnosticFingerprint(ref?.textHash)
+    });
+    return removeEmptySummaryFields({
+      pathHash: stringField(capture.path) ? hashString(capture.path) : undefined,
+      nativeDocIdHash: stringField(capture.nativeDocId) ? hashString(capture.nativeDocId) : undefined,
+      state: diagnosticToken(capture.state), reason: diagnosticToken(capture.reason),
+      source: diagnosticToken(capture.source),
+      ...diagnosticNumbers(capture, ['startedAt', 'expiresAt']),
+      expectedFingerprint: diagnosticFingerprint(capture.expected),
+      beforeCount: before.length, refCount: refs.length, rangeCount: ranges.length,
+      truncated: before.length > 1200 || refs.length > 1200 || ranges.length > 1000 ? true : undefined,
+      before: before.slice(0, 1200).map(refSummary),
+      refs: refs.slice(0, 1200).map(refSummary),
+      ranges: ranges.slice(0, 1000).map(range => removeEmptySummaryFields({
+        ...diagnosticNumbers(range, ['from', 'to', 'start', 'end', 'removedLength']),
+        removedHash: diagnosticFingerprint(range?.removedHash)
+      })),
+      diagnostics: removeEmptySummaryFields({
+        ...diagnosticNumbers(diagnostics, ['beforeCount', 'afterCount', 'capturedCount',
+          'filteredCount', 'polls', 'elapsedMs', 'waitMs']),
+        reason: diagnosticToken(diagnostics.reason),
+        source: diagnosticToken(diagnostics.source),
+        sourceReason: diagnosticToken(diagnostics.sourceReason)
+      })
+    });
+  }
+
   function summarizeGovernance(rules = {}) {
     return {
       readonlyPatternCount: Array.isArray(rules.readonlyPatterns) ? rules.readonlyPatterns.length : 0,

package/extension/src/shared/changeHistoryModel.js

@@ -0,0 +1,94 @@
+(function initChangeHistoryModel(root, factory) {
+  if (typeof module === 'object' && module.exports) {
+    module.exports = factory(require('./settlementFacts'), require('./sessionState'));
+  } else root.CodexOverleafModuleRegistry.define('ChangeHistoryModel', ['SettlementFacts', 'SessionState'], factory);
+})(typeof globalThis !== 'undefined' ? globalThis : window, function changeHistoryModelFactory(SettlementFacts, SessionState) {
+  'use strict';
+  const array = value => Array.isArray(value) ? value : [];
+  const text = value => typeof value === 'string' ? value : '';
+  const opaque = value => /^\[.*(?:omitted|redacted|chars=\d+|hash=).*?\]$/i.test(text(value).trim());
+
+  function project(records, options = {}) {
+    const { projectId, accountScopeId } = options;
+    if (!projectId || !accountScopeId) return [];
+    const sanitize = options.sanitizeText || text;
+    const safe = value => text(sanitize(text(value))).trim();
+    const sessions = new Map();
+    const live = new Map();
+    for (const session of array(options.storedSessions)) {
+      if (session?.projectId === projectId && session.accountScopeId === accountScopeId) sessions.set(session.id, session);
+    }
+    // In-memory sessions already passed the runtime's account/project hydrate
+    // boundary. Their review state is newer than the persisted audit snapshot.
+    for (const session of array(options.sessions)) {
+      if (!session?.id) continue;
+      const prior = sessions.get(session.id);
+      const runs = new Map(array(prior?.runs).map(run => [run.id, run]));
+      const current = session.id === options.activeSessionId ? array(options.activeRuns) : array(session.runs);
+      for (const run of current) if (run?.id) runs.set(run.id, run);
+      sessions.set(session.id, { ...prior, ...session, runs: [...runs.values()] });
+      live.set(session.id, new Set(current.filter(run => run?.id && (!run.runProjectId || run.runProjectId === projectId)).map(run => run.id)));
+    }
+    function path(value) {
+      const raw = text(value).replace(/\\/g, '/').replace(/^\.\//, '');
+      if (/(^|\/)\.codex-overleaf-(subagents|attachments)(\/|$)/.test(raw)) return '';
+      const result = safe(raw);
+      if (!result || /^\[.*\]$/.test(result)) return '';
+      return result.slice(0, 320);
+    }
+    const seen = new Set();
+    return array(records).filter(record => record?.projectId === projectId
+      && (!record.accountScopeId || record.accountScopeId === accountScopeId)
+      && sessions.has(record.sessionId))
+      .slice().sort((a, b) => String(b.createdAt || '').localeCompare(String(a.createdAt || '')))
+      .filter(record => {
+        const key = JSON.stringify([record.sessionId, record.turnId || record.id]);
+        if (seen.has(key)) return false;
+        seen.add(key); return true;
+      }).slice(0, 50).map(record => {
+        const session = sessions.get(record.sessionId);
+        const candidate = array(session.runs).find(run => run.id === record.turnId);
+        const run = candidate && (!candidate.runProjectId || candidate.runProjectId === projectId) ? candidate : null;
+        const facts = SettlementFacts.compactSettlementFacts(run?.settlement || run?.settlementFacts || {});
+        const projection = run ? SettlementFacts.projectRunSettlement(run) : null;
+        const applied = array(record.appliedFiles).filter(file => path(typeof file === 'string' ? file : file?.path));
+        const review = text(run?.trackedChangeStatus);
+        const hasWrites = applied.length > 0 || run?.changedDocument === true
+          || ['changed', 'possibly-changed'].includes(facts.documentEffect)
+          || ['pending', 'accepted', 'rejected', 'needs_review'].includes(review)
+          || run?.undoStatus === 'applied';
+        let files = applied.slice();
+        files.push(...facts.fileSettlements.filter(file => ['complete', 'partial'].includes(file.applied)
+          || ['changed', 'possibly-changed'].includes(file.documentEffect)));
+        if (!files.length && hasWrites) files = array(record.changedFiles);
+        const paths = [...new Set(files.flatMap(file => typeof file === 'string'
+          ? [path(file)] : [path(file?.path), path(file?.destinationPath)]).filter(Boolean))];
+        const unsafeSave = record.saveVerification?.ok === false
+          || ['failed', 'unavailable'].includes(record.saveVerification?.state);
+        let status;
+        if (review === 'accepted') status = 'accepted';
+        else if (review === 'rejected' || run?.undoStatus === 'applied') status = 'undone';
+        else if (review === 'needs_review' || projection?.terminalState === 'needs_review'
+          || facts.documentEffect === 'possibly-changed'
+          || ['partial', 'needs-review'].includes(facts.evidence.settled)
+          || hasWrites && (unsafeSave || ['failed', 'interrupted', 'needs_review_after_navigation'].includes(run?.status))) status = 'attention';
+        else if (run?.status === 'running' || record.resultStatus === 'draft' && !record.completedAt) status = 'running';
+        else if (review === 'pending') status = 'pending';
+        else if (!hasWrites) status = 'unchanged';
+        else status = run ? 'written' : 'unknown';
+        const suppliedSummary = safe(run?.safeTaskSummary || '');
+        const summary = suppliedSummary && !opaque(suppliedSummary)
+          ? SessionState.computeSafeTaskSummary(suppliedSummary) : '';
+        // Audit promptSummary deliberately stores a privacy marker. Never
+        // recover it, render it, or turn it into an apparent task summary.
+        return {
+          key: JSON.stringify([record.sessionId, record.turnId || record.id]),
+          projectId, accountScopeId, sessionId: record.sessionId, turnId: record.turnId,
+          createdAt: text(record.createdAt), paths, hasWrites, status, summary,
+          operation: paths.length === 1 ? text(files[0]?.type) : '',
+          canJump: Boolean(run && live.get(record.sessionId)?.has(record.turnId))
+        };
+      });
+  }
+  return { project };
+});

package/extension/src/shared/compatibility.js

@@ -12,7 +12,7 @@
   const MIN_NATIVE_VERSION = '1.0.0';
   const MIN_COMPATIBLE_NATIVE_VERSION = '1.0.0';
   const MIN_COMPATIBLE_EXTENSION_VERSION = '1.0.0';
-  const BUILD_TARGET_VERSION = '2.4.1';
+  const BUILD_TARGET_VERSION = '2.5.1';
   const DEFAULT_CHROME_EXTENSION_ID = 'illdpneeeopfffmiepaejglgmhpmdhdc';
   const REQUIRED_CAPABILITIES = Object.freeze([
     'bridgePing',
@@ -25,6 +25,7 @@
     'codexModels',
     'historyClearPlugin',
     'localSkills',
+    'localCodexSkills',
     'mirrorSensitiveScan',
     'providerProfiles',
     'assetTransfer',
@@ -64,6 +65,8 @@
   }
 
   function evaluateNativeCompatibility(response, metadata = {}) {
+    if (response?.extensionInstallIdentity) metadata = { ...metadata,
+      installIdentity: { ...(metadata.installIdentity || {}), ...response.extensionInstallIdentity } };
     const native = unwrapNativeResponse(response);
     if (!native) {
       return compatibilityResult('native_missing', response, metadata, 'incompatible');
@@ -86,13 +89,25 @@
     return analyzeNativeCompatibility(native, metadata).classification;
   }
 
-  function buildInstallCommand(version = BUILD_TARGET_VERSION, platform, extensionId) {
+  function buildInstallCommand(version = BUILD_TARGET_VERSION, platform, extensionId, options = {}) {
     const normalized = normalizeReleaseVersion(version) || BUILD_TARGET_VERSION;
     const allowedExtensionId = normalizeInstallExtensionId(extensionId);
     const extensionIdArg = allowedExtensionId && allowedExtensionId !== DEFAULT_CHROME_EXTENSION_ID
-      ? ` --extension-id ${allowedExtensionId}`
-      : '';
-
+      ? ` --extension-id ${allowedExtensionId}` : '';
+    if (options.managed === true) {
+      if (!allowedExtensionId || options.extensionId !== allowedExtensionId) return '';
+      const managedRoot = options.managedRoot;
+      const browser = options.browser === 'auto' ? 'chrome' : options.browser;
+      if (!['chrome', 'chromium'].includes(browser) || typeof managedRoot !== 'string'
+        || !managedRoot || managedRoot.length > 4096 || managedRoot.trim() !== managedRoot
+        || /[\u0000-\u001f\u007f]/.test(managedRoot)
+        || !(/^(?:\/|[a-zA-Z]:[\\/]|\\\\)/.test(managedRoot))) return '';
+      // Windows setup commands are shown for PowerShell; POSIX uses sh quoting.
+      const quotedRoot = platform === 'win32' || options.platform === 'win32'
+        ? "'" + managedRoot.replace(/'/g, "''") + "'"
+        : "'" + managedRoot.replace(/'/g, "'\\''") + "'";
+      return `npm exec --yes codex-overleaf-link@${normalized} -- install-managed --browser ${browser} --managed-root ${quotedRoot}${extensionIdArg}`;
+    }
     return `npm exec --yes codex-overleaf-link@${normalized} -- install-native${extensionIdArg}`;
   }
 
@@ -126,7 +141,7 @@
     const extensionVersion = resolveMetadataVersion(metadata);
     const nativeVersion = native && typeof native === 'object' ? native.version : undefined;
     const platform = native && typeof native === 'object' ? native.platform : undefined;
-    const updateCommand = buildInstallCommand(BUILD_TARGET_VERSION, platform, metadata.extensionId);
+    const updateCommand = buildInstallCommand(BUILD_TARGET_VERSION, platform, metadata.extensionId, metadata.installIdentity);
     const updateAvailable = isOlderReleaseVersion(nativeVersion, BUILD_TARGET_VERSION);
     return {
       status,
@@ -139,6 +154,7 @@
       requiredVersion: MIN_COMPATIBLE_NATIVE_VERSION,
       recommendedVersion: BUILD_TARGET_VERSION,
       updateAvailable,
+      ...(metadata.installIdentity ? { installIdentity: metadata.installIdentity } : {}),
       installCommand: updateCommand,
       updateCommand,
       releaseUrl: buildReleaseUrl(BUILD_TARGET_VERSION),

package/extension/src/shared/compileAdapter.js

@@ -9,32 +9,18 @@
 
   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' };
-    }
-
+    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 (!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' };
-    }
-
+    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 (!logUrl) return { ok: false, reason: 'Log file has no URL' };
     return {
       ok: true,
       status: response.status,
@@ -82,13 +68,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,26 +90,17 @@
   }
 
   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);
@@ -163,7 +136,98 @@
     return result;
   }
 
+  function buildPostWriteCompileSummary({ result = null, logResult = null, error = null } = {}) {
+    const logAvailable = logResult?.ok === true;
+    const errors = logAvailable && Array.isArray(logResult.errors)
+      ? logResult.errors.slice(0, 5).map(formatCompileDiagnosticForSummary)
+      : [];
+    const warnings = logAvailable && Array.isArray(logResult.warnings)
+      ? logResult.warnings.slice(0, 5).map(formatCompileDiagnosticForSummary)
+      : [];
+    const failed = Boolean(error) || !result?.ok;
+    return {
+      status: failed ? 'failed' : result.compile?.status || 'triggered',
+      reason: error ? error?.message || 'Post-write compile failed.'
+        : !result?.ok ? result?.reason || 'Post-write compile did not succeed.' : result.reason || '',
+      errors,
+      warnings,
+      logAvailable
+    };
+  }
+
+  function formatCompileDiagnosticForSummary(value) {
+    const text = String(value || '').replace(/\s+/g, ' ').trim();
+    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,151 @@
+(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) 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/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 };
+});