codex-overleaf-link 2.5.0 → 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\./,
@@ -63,6 +281,14 @@
     const locale = normalizeLocale(options);
     const type = String(event.type || '');
 
+    if (type === 'codex.local_skills.missing' || type === 'codex.local_skill_invocation.ignored') {
+      return { kind: 'activity', visible: true,
+        title: type === 'codex.local_skills.missing'
+          ? textFor(locale, '所选的本地技能未能加载。', 'A selected local skill could not be loaded.')
+          : textFor(locale, '所选的本地技能已关闭或不可用。', 'A selected local skill is disabled or unavailable.'),
+        status: event.status || 'failed', technicalDetail: normalizeRawEvent(event) };
+    }
+
     if (isContextCompactionEvent(event)) {
       return formatContextCompactionCheckpoint(event, locale);
     }
@@ -428,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,
@@ -720,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,
@@ -730,6 +951,28 @@
     // failure data alongside the human-readable text. The string text is kept
     // verbatim because it has mode-aware nuance (e.g. "No files were written"
     // vs "This run did not start") the catalog's fallback strings don't capture.
+    if (context.code === 'codex_local_skill_unavailable' || /(?:The )?selected local Codex skill is unavailable/i.test(text)) {
+      return {
+        conclusion: textFor(locale, '所选 Codex 本地技能不可用或已关闭，本轮没有启动。', 'The selected local Codex skill is unavailable or disabled. This run did not start.'),
+        nextStep: textFor(locale, '请打开技能页，选择可用且已启用的技能后重新提交。', 'Open Skills, select an available enabled skill, and submit again.'),
+        failureCode: 'codex_local_skill_unavailable'
+      };
+    }
+    if (/^codex_local_skills_/.test(String(context.code || ''))
+      || /local Codex skill discovery|Codex could not (?:list local skills|start local skill discovery)|Codex returned an invalid local skill catalog/i.test(text)) {
+      return {
+        conclusion: textFor(locale, 'Codex 本地技能未能加载，本轮没有启动。', 'Local Codex skills could not be loaded. This run did not start.'),
+        nextStep: textFor(locale, '请打开技能页重新加载本地目录，然后重新提交。', 'Open Skills to reload the local catalog, then submit again.'),
+        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;
@@ -848,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,
@@ -905,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 /
@@ -915,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);
@@ -959,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}`));
     }
@@ -1005,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)),
@@ -1733,6 +2087,8 @@
 
   return {
     buildHumanCompletionReport,
+    projectProductConclusion,
+    projectContextLimitEvent,
     buildStructuredHumanReport,
     formatFallbackFinalReport,
     formatFailureBlock,

package/extension/src/shared/auditRecords.js

@@ -25,12 +25,15 @@
     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)),
       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,
@@ -84,6 +87,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)),

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.0';
+  const BUILD_TARGET_VERSION = '2.6.0';
   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),