codex-overleaf-link 2.5.1 → 2.6.0

package/extension/src/shared/agentTranscript.js

@@ -2,16 +2,19 @@
   if (typeof module === 'object' && module.exports) {
     module.exports = factory({
       getFailureReasons: function getFailureReasonsCjs() { return require('./failureReasons.js'); },
-      getI18n: function getI18nCjs() { return require('./i18n.js'); }
+      getI18n: function getI18nCjs() { return require('./i18n.js'); },
+      RunActivityModel: require('./runActivityModel.js')
     });
   } else {
     root.CodexOverleafModuleRegistry.define('AgentTranscript', [
       'FailureReasons',
-      'I18n'
-    ], function createAgentTranscript(FailureReasons, I18n) {
+      'I18n',
+      'RunActivityModel'
+    ], function createAgentTranscript(FailureReasons, I18n, RunActivityModel) {
       return factory({
         getFailureReasons: function getFailureReasonsWindow() { return FailureReasons; },
-        getI18n: function getI18nWindow() { return I18n; }
+        getI18n: function getI18nWindow() { return I18n; },
+        RunActivityModel
       });
     });
   }
@@ -25,6 +28,221 @@
     ? deps.getI18n
     : function noI18n() { return null; };
 
+  // Only explicit product producers may attach these semantic identities.
+  const PRODUCT_CONCLUSIONS = {
+    "context_compacted": ["Conversation context compacted.", "会话上下文已压缩。"],
+    "compact_busy": ["Wait for the current task to finish before compacting context.", "请等待当前任务结束后再压缩上下文。"],
+    "compact_unsupported": ["This local Codex connection does not support manual compaction. Update Codex and reload the extension.", "当前本地 Codex 连接不支持手动压缩，请更新 Codex 并重新加载扩展。"],
+    "compact_failed": ["Context compaction did not complete. Check Technical Details before retrying.", "上下文压缩未完成，请查看技术详情后再重试。"],
+    "full_project_unread": [
+      "This run did not continue: the full Overleaf project was not read.",
+      "这轮没有继续：没有读到完整的 Overleaf 项目内容。"
+    ],
+    "empty_result": [
+      "Codex completed, but it produced no assistant response and no local file changes.",
+      "Codex 已完成，但没有产生助手回复，也没有产生本地文件改动。"
+    ],
+    "skill_installer_completed": [
+      "Skill installer completed.",
+      "Skill installer 已完成。"
+    ],
+    "launch_not_started": [
+      "This task did not start: Codex did not run and no files were written.",
+      "这轮任务没有开始：Codex 没有运行，也没有写入文件。"
+    ],
+    "cancelled": [
+      "This run was cancelled. It did not continue syncing or writing to Overleaf.",
+      "这轮已中断，没有继续同步或写入 Overleaf。"
+    ],
+    "reload_interrupted": [
+      "The plugin reloaded while this run was still marked in progress. It has been marked interrupted to avoid showing a stale status — run the task again to continue.",
+      "插件重新加载时发现这轮任务还标记为处理中。为了避免继续显示过期状态，已把它标记为中断；可以重新运行任务。"
+    ],
+    "ask_inspected": [
+      "This run only inspected and explained; no files were written.",
+      "这轮只做了检查和说明，没有写入文件。"
+    ],
+    "delete_handled": [
+      "Changes were written, and delete items were handled after your confirmation.",
+      "已写入修改，并按你的确认处理删除项。"
+    ],
+    "delete_rejected": [
+      "Non-delete changes were kept; delete items were not written.",
+      "已保留非删除修改；删除项没有写入。"
+    ],
+    "run_complete": [
+      "This run is complete.",
+      "这轮任务已完成。"
+    ],
+    "withheld_changes": [
+      "Some generated changes were blocked.",
+      "部分生成的改动已被阻止。"
+    ],
+    "ask_ignored_changes": [
+      "Codex finished in Ask mode. Any local file changes were ignored and were not synced to Overleaf.",
+      "Codex 已在 Ask 模式完成；本地文件改动已忽略，未同步到 Overleaf。"
+    ],
+    "no_sync_changes": [
+      "Codex finished locally. There are no changes to sync back to Overleaf.",
+      "Codex 已完成本地处理，没有需要同步回 Overleaf 的改动。"
+    ],
+    "no_approved_changes": [
+      "No approved changes were written back to Overleaf.",
+      "没有已确认的改动写回 Overleaf。"
+    ],
+    "reviewing_unavailable": [
+      "No files were written: Track is enabled, but Codex could not verify Overleaf Reviewing/Track Changes.",
+      "这轮没有写入：已开启“留痕”要求，但 Codex 没能确认 Overleaf 正在用 Reviewing/Track Changes。"
+    ],
+    "sensitive_blocked": [
+      "This run was blocked before Codex received project context because sensitive content was detected.",
+      "检测到敏感内容，本轮已在向 Codex 发送项目上下文前阻止。"
+    ],
+    "synced": [
+      "Local Codex changes were synced back to Overleaf.",
+      "本地 Codex 改动已同步回 Overleaf。"
+    ],
+    "partial_sync": [
+      "Local Codex changes were sent to Overleaf, but some items were skipped.",
+      "本地 Codex 改动已尝试同步回 Overleaf，但有部分项目被跳过。"
+    ],
+    "blocked_sync": [
+      "No changes were written to Overleaf; every change was blocked before writing.",
+      "没有向 Overleaf 写入任何改动；所有改动都在写入前被拦下。"
+    ],
+    "unconfirmed_sync": [
+      "Codex tried to write local changes to Overleaf, but the write result did not confirm any applied or skipped entries.",
+      "Codex 已尝试把本地改动写入 Overleaf，但写入结果没有确认任何已写入或已跳过条目。"
+    ],
+    "partial_sync_note": [
+      "Sync note: local Codex changes were sent to Overleaf, but some items were skipped.",
+      "同步提示：本地 Codex 改动已尝试写回 Overleaf，但有部分项目被跳过。"
+    ],
+    "blocked_sync_note": [
+      "Sync note: no changes were written to Overleaf; every change was blocked before writing.",
+      "同步提示：没有向 Overleaf 写入任何改动；所有改动都在写入前被拦下。"
+    ],
+    "unconfirmed_sync_note": [
+      "Writeback note: Codex could not confirm any Overleaf write result entries, so local mirror refresh and auto compile were skipped.",
+      "写入提示：Codex 没能确认任何 Overleaf 写入结果条目，因此已跳过本地 mirror 刷新和自动编译。"
+    ],
+    "retry_sync": [
+      "Retried the remaining file transfers for this task.",
+      "已重试本轮未完成的文件同步。"
+    ],
+    "default_no_write": [
+      "This task completed without writing Overleaf files.",
+      "这轮任务已完成，没有写入 Overleaf 文件。"
+    ],
+    "default_complete": [
+      "This task completed.",
+      "这轮任务已完成。"
+    ],
+    "warm_mirror_stale": [
+      "This run did not continue: Overleaf did not provide the full project, and the local workspace is not fresh enough.",
+      "这轮没有继续：Overleaf 没有提供完整项目内容，本地 workspace 也不够新。"
+    ]
+  };
+
+  const ERROR_CONCLUSIONS = {
+    "local_skill_unavailable": {
+      "code": "codex_local_skill_unavailable"
+    },
+    "local_skills_failed": {
+      "code": "codex_local_skills_failed"
+    },
+    "mode_removed": {
+      "message": "suggest_mode_removed"
+    },
+    "mode_write_required": {
+      "message": "Mode must be \"ask\" or \"auto\""
+    },
+    "invalid_json": {
+      "message": "Agent returned invalid JSON"
+    },
+    "invalid_output": {
+      "message": "Could not parse Codex output"
+    },
+    "timeout": {
+      "message": "timed out"
+    },
+    "output_limit": {
+      "message": "output limit exceeded"
+    },
+    "context_limit": {
+      "code": "codex_context_limit"
+    },
+    "codex_not_found": {
+      "message": "codex_not_found"
+    },
+    "project_locked": {
+      "message": "project_locked"
+    },
+    "reasoning_unsupported": {
+      "message": "unsupported_parameter reasoning.summary"
+    },
+    "storage_quota": {
+      "message": "quota"
+    },
+    "checkpoint": {
+      "message": "checkpoint"
+    },
+    "stale_source": {
+      "message": "changed while Codex was working"
+    },
+    "post_processing": {
+      "codexReturned": true
+    },
+    "ask_failed": {
+      "mode": "ask"
+    },
+    "auto_failed": {
+      "mode": "auto"
+    },
+    "provider_revision_conflict": {
+      "message": "provider_revision_conflict"
+    },
+    "provider_auth_rejected": {
+      "message": "provider_auth_rejected"
+    },
+    "provider_model_not_found": {
+      "message": "provider_model_not_found"
+    },
+    "provider_model_not_configured": {
+      "message": "provider_model_not_configured"
+    },
+    "provider_protocol_unverified": {
+      "message": "provider_protocol_unverified"
+    },
+    "provider_protocol_incompatible": {
+      "message": "provider_protocol_incompatible"
+    },
+    "provider_rate_limited": {
+      "message": "provider_rate_limited"
+    },
+    "provider_connection_timeout": {
+      "message": "provider_connection_timeout"
+    },
+    "provider_dns_failed": {
+      "message": "provider_dns_failed"
+    },
+    "provider_tls_failed": {
+      "message": "provider_tls_failed"
+    },
+    "provider_not_found": {
+      "message": "provider_not_found"
+    },
+    "provider_store_corrupt": {
+      "message": "provider_store_corrupt"
+    },
+    "provider_store_unavailable": {
+      "message": "provider_store_unavailable"
+    },
+    "provider_response_invalid": {
+      "message": "provider_response_invalid"
+    }
+  };
+
   const TECHNICAL_EVENT_PATTERNS = [
     /^agent\.command\./,
     /^native\.task\./,
@@ -436,16 +654,11 @@
   }
 
   function isContextCompactionEvent(event = {}) {
-    const type = String(event.type || '');
-    const method = String(event.detail?.method || event.title || '');
-    const label = `${type} ${method}`;
-    return /(compact|compaction|compacted)/i.test(label)
-      && /(context|thread|turn|conversation|codex)/i.test(label);
+    return Boolean(deps.RunActivityModel.contextCompactionState(event));
   }
 
   function formatContextCompactionCheckpoint(event = {}, locale = 'en') {
-    const method = String(event.detail?.method || event.title || '');
-    const running = event.status === 'running' || /(started|starting|begin|prepar)/i.test(method);
+    const running = deps.RunActivityModel.contextCompactionState(event) === 'running';
     return {
       kind: 'checkpoint',
       visible: true,
@@ -728,7 +941,7 @@
     };
   }
 
-  function translateRawError(message, context = {}) {
+  function translateRawErrorCopy(message, context = {}) {
     const locale = normalizeLocale(context);
     const text = String(message || '');
     // Each branch returns the user-visible {conclusion, nextStep} pair and,
@@ -753,6 +966,13 @@
         failureCode: 'codex_local_skills_failed'
       };
     }
+    if (getFailureReasonsModule()?.isContextLimitError(text, context.code)) {
+      return {
+        conclusion: textFor(locale, '本轮已停止：上下文超出模型的容量限制。', 'This run stopped because the model context limit was exceeded.'),
+        nextStep: textFor(locale, '请重试任务；如果再次超限，可使用 /compact，或新建会话并减少上下文。', 'Retry the task. If the context limit is reached again, use /compact or start a new conversation with less context.'),
+        failureCode: 'codex_context_limit'
+      };
+    }
     const providerError = translateProviderError(text, locale);
     if (providerError) {
       return providerError;
@@ -871,12 +1091,107 @@
     };
   }
 
+  function productConclusionText(key, locale = 'en') {
+    if (Object.hasOwn(PRODUCT_CONCLUSIONS, key)) return PRODUCT_CONCLUSIONS[key][locale === 'zh' ? 1 : 0];
+    const error = key.startsWith('error:') && Object.hasOwn(ERROR_CONCLUSIONS, key.slice(6)) && ERROR_CONCLUSIONS[key.slice(6)];
+    return error ? translateRawErrorCopy(error.message || '', { ...error, locale }).conclusion : null;
+  }
+
+  function translateRawError(message, context = {}) {
+    const translated = translateRawErrorCopy(message, context), locale = normalizeLocale(context);
+    const key = Object.keys(ERROR_CONCLUSIONS).find(id => productConclusionText(`error:${id}`, locale) === translated.conclusion);
+    return { ...translated, ...(key ? { conclusionKey: `error:${key}` } : {}) };
+  }
+
+  // Old Native failures retained the real transport error even when their
+  // product summary used the generic empty-result category. Re-project only
+  // those identified product events; model prose and stored records stay intact.
+  function projectContextLimitEvent(event, locale = 'en') {
+    const failure = event?.failure;
+    if (event?.status !== 'failed' || event.streamRole || event.guidanceId || event.subagent) return event;
+    if (failure?.code === 'codex_context_limit' && failure.stage === 'codex'
+      && (!event.kind || event.kind === 'activity')
+      && ['en', 'zh'].some(language => productConclusionText('error:context_limit', language) === event.title)) {
+      return { ...event, title: productConclusionText('error:context_limit', locale) };
+    }
+    if (failure?.code !== 'codex_no_usable_result' || failure.stage !== 'codex'
+      || !getFailureReasonsModule()?.isContextLimitError(failure.technicalMessage)) return event;
+    const generic = ['ask_failed', 'auto_failed'].flatMap(key => ['en', 'zh'].map(language =>
+      productConclusionText(`error:${key}`, language)));
+    const translated = translateRawError(failure.technicalMessage, { locale });
+    const projectedFailure = { ...failure, code: translated.failureCode,
+      userMessage: translated.conclusion, nextAction: translated.nextStep };
+    if ((!event.kind || event.kind === 'activity') && generic.includes(event.title)) {
+      return { ...event, title: translated.conclusion, failure: projectedFailure };
+    }
+    const structured = event.detailStructured, source = structured?.conclusionSource;
+    if (event.kind !== 'report' || source?.origin !== 'product'
+      || !['error:ask_failed', 'error:auto_failed'].includes(source.key)
+      || !generic.includes(structured.conclusion)) return event;
+    const oldNext = ['en', 'zh'].map(language => translateRawError('', { locale: language }).nextStep);
+    return { ...event, failure: projectedFailure, detailStructured: { ...structured,
+      conclusion: translated.conclusion, conclusionSource: { origin: 'product', key: translated.conclusionKey },
+      meta: (structured.meta || []).map(row => row.key === 'nextStep' && oldNext.includes(row.value)
+        ? { ...row, value: translated.nextStep } : row) } };
+  }
+
+  function normalizeConclusionSource(source) {
+    if (source?.origin !== 'product' || typeof source.key !== 'string') return null;
+    if (productConclusionText(source.key) !== null) return { origin: 'product', key: source.key };
+    if (source.key !== 'writeback' || !['synced', 'partial_sync', 'blocked_sync', 'unconfirmed_sync'].includes(source.outcome)) return null;
+    return { origin: 'product', key: 'writeback', outcome: source.outcome,
+      prefixLength: Number.isSafeInteger(source.prefixLength) && source.prefixLength >= 0 ? source.prefixLength : -1,
+      prefixKey: source.prefixKey === 'retry_sync' ? 'retry_sync' : '',
+      hasCompile: source.hasCompile === true,
+      compileStatus: typeof source.compileStatus === 'string' ? source.compileStatus : '',
+      compileReason: typeof source.compileReason === 'string' ? source.compileReason : '',
+      errorCount: Number.isSafeInteger(source.errorCount) && source.errorCount >= 0 ? source.errorCount : 0,
+      errors: Array.isArray(source.errors) ? source.errors.slice(0, 3).filter(value => typeof value === 'string') : [],
+      warningCount: Number.isSafeInteger(source.warningCount) && source.warningCount >= 0 ? source.warningCount : 0 };
+  }
+
+  function projectProductConclusion(source, locale = 'en', localizeCompileReason = value => value, raw = '') {
+    const identity = normalizeConclusionSource(source);
+    if (!identity) return null;
+    if (identity.key !== 'writeback') return productConclusionText(identity.key, locale);
+    if (identity.prefixLength < 0 || identity.prefixLength > raw.length) return null;
+    const originalPrefix = raw.slice(0, identity.prefixLength);
+    if (identity.prefixKey && !['en', 'zh'].some(language => productConclusionText(identity.prefixKey, language) === originalPrefix)) return null;
+    const compose = (language, projectReason) => {
+      const tx = (en, zh) => language === 'zh' ? zh : en;
+      const prefix = projectReason && identity.prefixKey ? productConclusionText(identity.prefixKey, language) : originalPrefix;
+      const note = productConclusionText(identity.outcome + (prefix && identity.outcome !== 'synced' ? '_note' : ''), language);
+      const conclusion = prefix ? [prefix, identity.outcome === 'synced' ? '' : note].filter(Boolean).join('\n\n') : note;
+      const { compileStatus: status, errors, errorCount, warningCount: warnings } = identity;
+      if (!identity.hasCompile) return conclusion;
+      const reason = projectReason ? localizeCompileReason(identity.compileReason) : identity.compileReason;
+      const summary = errorCount
+        ? tx(`Post-write compile check: ${errorCount} remaining error(s): ${errors.slice(0, 3).join('; ')}`,
+          `写后编译检查：仍有 ${errorCount} 个错误：${errors.slice(0, 3).join('；')}`)
+        : status === 'success' ? (warnings
+          ? tx(`Post-write compile check succeeded with ${warnings} warning(s).`, `写后编译检查已通过，但仍有 ${warnings} 个警告。`)
+          : tx('Post-write compile check succeeded with no reported errors.', '写后编译检查已通过，未发现错误。'))
+        : status === 'triggered' ? (warnings
+          ? tx(`Post-write compile was triggered; latest log shows ${warnings} warning(s).`, `已触发写后编译；最新日志显示 ${warnings} 个警告。`)
+          : tx('Post-write compile was triggered; Overleaf may still be updating the result.', '已触发写后编译；Overleaf 可能仍在更新结果。'))
+        : status === 'unconfirmed' ? getI18nModule().t(language, 'runCompileUnconfirmed')
+        : status === 'failed' ? tx(`Post-write compile check failed: ${reason || 'unknown reason'}`,
+          `写后编译检查失败：${reason || '未知原因'}`)
+        : tx(`Post-write compile finished with status: ${status || 'unknown'}.`, `写后编译完成，状态：${status || '未知'}。`);
+      return [conclusion, summary].filter(Boolean).join('\n');
+    };
+    // A compacted or changed raw answer must never be reconstructed from metadata.
+    if (!['en', 'zh'].some(language => compose(language, false) === raw)) return null;
+    return compose(locale, true);
+  }
+
   function buildHumanCompletionReport(input = {}) {
     const locale = normalizeLocale(input);
     const applyResults = normalizeApplyResults(input.applyResults);
     const appliedCount = countApplyResultEntries(applyResults, 'applied');
     const skippedCount = countApplyResultEntries(applyResults, 'skipped');
-    const translatedError = input.errorMessage ? translateRawError(input.errorMessage, { mode: input.mode, locale }) : null;
+    const translatedError = input.errorMessage ? translateRawError(input.errorMessage, { mode: input.mode, locale, code: input.failure?.code,
+      codexReturned: input.conclusionKey === 'error:post_processing' }) : null;
     const userReport = normalizeUserReport(input.userReport);
     const report = userReport || buildFallbackReport(input, {
       appliedCount,
@@ -928,6 +1243,16 @@
     return report.text;
   }
 
+  function completionConclusionText(report) {
+    const source = report.conclusionSource;
+    // The new blocked composite preserves its exact model prefix. Keep the
+    // historical formatter for every other report shape.
+    if (source?.key === 'writeback' && source.outcome === 'blocked_sync'
+      && typeof report.conclusion === 'string' && ['en', 'zh'].some(locale =>
+        projectProductConclusion(source, locale, undefined, report.conclusion) === report.conclusion)) return report.conclusion;
+    return cleanVisibleMarkdownText(report.conclusion || '');
+  }
+
   /**
    * Splits the human report into a conclusion (the human-language outcome),
    * a body of list-style content sections (checked / findings / planned /
@@ -938,7 +1263,7 @@
    * shape for transcripts, storage fallback, and existing assertions.
    */
   function buildStructuredHumanReport(report = {}, locale = 'en') {
-    const conclusion = cleanVisibleMarkdownText(report.conclusion || '');
+    const conclusion = completionConclusionText(report);
 
     const bodySections = [];
     addListSection(bodySections, textFor(locale, '检查范围', 'Checked'), report.checked, locale);
@@ -982,12 +1307,13 @@
     }
 
     if (report.saveState) meta.push({ key: 'saveState', label: textFor(locale, '保存', 'Save'), value: report.saveState });
-    return { conclusion, body: bodySections.join('\n\n'), meta };
+    return { conclusion, body: bodySections.join('\n\n'), meta,
+      ...(normalizeConclusionSource(report.conclusionSource) ? { conclusionSource: normalizeConclusionSource(report.conclusionSource) } : {}) };
   }
 
   function formatHumanReport(report = {}, locale = 'en') {
     const sections = [];
-    const conclusion = cleanVisibleMarkdownText(report.conclusion || '');
+    const conclusion = completionConclusionText(report);
     if (conclusion) {
       sections.push(textFor(locale, `结论：${conclusion}`, `Conclusion: ${conclusion}`));
     }
@@ -1028,8 +1354,13 @@
         ? textFor(locale, '这轮任务已完成，没有写入 Overleaf 文件。', 'This task completed without writing Overleaf files.')
         : textFor(locale, '这轮任务已完成。', 'This task completed.'));
 
+    const conclusionSource = counts.translatedError?.conclusionKey
+      ? { origin: 'product', key: counts.translatedError.conclusionKey }
+      : input.conclusionKey ? { origin: 'product', key: input.conclusionKey }
+      : input.conclusionSource || (!input.conclusion && !input.notes
+        ? { origin: 'product', key: noWrites ? 'default_no_write' : 'default_complete' } : null);
     return {
-      conclusion,
+      conclusion, conclusionSource: normalizeConclusionSource(conclusionSource),
       checked: normalizeStringList(input.checked || input.userReport?.checked),
       findings: normalizeStringList(input.findings),
       plannedChanges: counts.appliedCount ? [] : operations.map(operation => formatOperationLine(operation, locale)),
@@ -1756,6 +2087,8 @@
 
   return {
     buildHumanCompletionReport,
+    projectProductConclusion,
+    projectContextLimitEvent,
     buildStructuredHumanReport,
     formatFallbackFinalReport,
     formatFailureBlock,

package/extension/src/shared/auditRecords.js

@@ -32,6 +32,8 @@
       createdAt: redactSecretLikeText(stringField(input.createdAt)) || now,
       completedAt: '',
       mode: redactSecretLikeText(stringField(input.mode)),
+      requireReviewing: typeof input.requireReviewing === 'boolean' ? input.requireReviewing : undefined,
+      trackingDecision: ['continue', 'disable'].includes(input.trackingDecision) ? input.trackingDecision : '',
       providerId: redactSecretLikeText(stringField(input.providerId)) || 'builtin',
       providerName: redactSecretLikeText(stringField(input.providerName)),
       providerRevision: finiteNumber(input.providerRevision) || 0,

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.5.1';
+  const BUILD_TARGET_VERSION = '2.6.0';
   const DEFAULT_CHROME_EXTENSION_ID = 'illdpneeeopfffmiepaejglgmhpmdhdc';
   const REQUIRED_CAPABILITIES = Object.freeze([
     'bridgePing',

package/extension/src/shared/compileAdapter.js

@@ -11,31 +11,46 @@
   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 (!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);
@@ -106,6 +121,12 @@
     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: [] };
 
@@ -115,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]);
       }
     }
@@ -137,18 +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)
       : [];
-    const failed = Boolean(error) || !result?.ok;
+    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: 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 || '',
+      status,
+      reason,
       errors,
       warnings,
       logAvailable

package/extension/src/shared/composerAttachmentDraft.js

@@ -51,7 +51,12 @@
                 if (!attachments.length) return;
                 throw failure('composer_draft_cleared');
               }
-              if (value.revision !== revision) throw failure('composer_draft_conflict');
+              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');
               }