codex-overleaf-link 2.3.0 → 2.3.2

package/extension/src/content/generated/content.bundle.meta.json

@@ -2,13 +2,14 @@
   "schemaVersion": 1,
   "entry": "extension/entries/content-entry.mjs",
   "output": "extension/src/content/generated/content.bundle.js",
-  "sourceDigest": "83c5f2bc9eb28735ba091c432476e505b311cfba37d53aa205049ea70ef2d2fc",
-  "outputDigest": "582a7804b46491dd34cd9f6f24304597f4e946e79870e323b9868a825b4666dd",
-  "byteLength": 2277820,
+  "sourceDigest": "d2167fca49721d0ef5e477dc76b11a0cedb33c9f51b920b55ea666ab4668dc4c",
+  "outputDigest": "87cbcf7d9877860b7c1d047cd3fa6e985e28812c8df81c9105ec9312a5e45ea6",
+  "byteLength": 2309285,
   "inputs": [
     "extension/entries/content-entry.mjs",
     "extension/src/content/activeTurnControl.js",
     "extension/src/content/applyResultFormatters.js",
+    "extension/src/content/assetTransferBroker.js",
     "extension/src/content/composerAttachments.js",
     "extension/src/content/composerPanel.js",
     "extension/src/content/contentRuntime.js",
@@ -45,11 +46,13 @@
     "extension/src/content/runGuidanceController.js",
     "extension/src/content/runGuidanceView.js",
     "extension/src/content/runQueueScheduler.js",
+    "extension/src/content/runResultActions.js",
     "extension/src/content/runSettlementPersistence.js",
     "extension/src/content/runTimelineView.js",
     "extension/src/content/scopedPersistenceCoordinator.js",
     "extension/src/content/scopedPersistenceDetachedCommit.js",
     "extension/src/content/scopedPersistencePanelState.js",
+    "extension/src/content/sessionForkController.js",
     "extension/src/content/sessionManager.js",
     "extension/src/content/sessionMenuView.js",
     "extension/src/content/sessionPanel.js",
@@ -81,6 +84,7 @@
     "extension/src/shared/runInputQueue.js",
     "extension/src/shared/scopedPersistenceBrowserAdapter.js",
     "extension/src/shared/scopedPersistenceQueuePolicy.js",
+    "extension/src/shared/scopedPersistenceReceipt.js",
     "extension/src/shared/scopedPersistenceTransaction.js",
     "extension/src/shared/sensitiveScan.js",
     "extension/src/shared/sessionState.js",

package/extension/src/content/legacyGlobalRegistry.js

@@ -15,6 +15,7 @@
     'ActiveTurnControl',
     'AgentTranscript',
     'ApplyResultFormatters',
+    'AssetTransferBroker',
     'AuditRecords',
     'Compatibility',
     'ComposerAttachments',
@@ -53,12 +54,14 @@
     'RunGuidanceController',
     'RunInputQueue',
     'RunQueueScheduler',
+    'RunResultActions',
     'RunSettlementPersistence',
     'RunTimelineView',
     'ScopedPersistenceCoordinator',
     'ScopedPersistenceTransaction',
     'SensitiveScan',
     'SessionManager',
+    'SessionForkController',
     'SessionPanel',
     'SessionPersistence',
     'SessionState',

package/extension/src/content/markdownText.js

@@ -13,12 +13,14 @@
       tx,
       callPageBridge, getCurrentProjectId,
       getCurrentProjectReferenceFiles,
+      getCurrentProjectMathSources,
       showPluginToast
     } = deps;
 
   function renderMarkdownInlineText(target, value) {
     target.replaceChildren(...buildMarkdownInlineNodes(value));
   }
+  function getMathMacros() { return MathText?.buildMathMacros?.(getCurrentProjectMathSources?.() || []) || {}; }
 
   function sanitizeAssistantVisibleText(value) {
     if (typeof value !== 'string' || !value) {
@@ -67,11 +69,8 @@
     if (!mathText?.buildMathNodes) {
       return buildMarkdownInlineNodesWithoutMath(source);
     }
-    return mathText.buildMathNodes(source, {
-      document,
-      katex: window.katex,
-      renderText: buildMarkdownInlineNodesWithoutMath
-    });
+    return mathText.buildMathNodes(source, { document, katex: window.katex,
+      macros: getMathMacros(), renderText: buildMarkdownInlineNodesWithoutMath });
   }
 
   function buildMarkdownInlineNodesWithoutMath(value) {
@@ -109,6 +108,10 @@
   function buildInlineCodeNodes(value) {
     const source = String(value || '');
     const trimmed = source.trim();
+    const standaloneMath = MathText?.parseStandaloneMath?.(trimmed);
+    if (standaloneMath && MathText?.createMathNode) return [MathText.createMathNode(
+      standaloneMath, { document, katex: window.katex, macros: getMathMacros() }
+    )];
     const refs = trimmed ? parseRuntimeLineReferences(trimmed, 'plain-text-token') : [];
     const ref = refs.length === 1 && refs[0]?.rawText === trimmed ? refs[0] : null;
     if (ref && !isRuntimeLocalPathLike(ref.rawPath)) {
@@ -492,12 +495,11 @@
               `[${safeLabel.replace(/]/g, '\\]')}](${target.replace(/\)/g, '\\)')})`
             );
           },
-          renderCodeNodes: text => buildMarkdownInlineNodes(`\`${String(text || '').replace(/`/g, '\\`')}\``),
+          renderCodeNodes: text => buildInlineCodeNodes(text),
           sanitizeText: sanitizeAssistantVisibleText,
-          createMathNode: segment => runtimeRoot.CodexOverleafMathText.createMathNode(segment, {
-            document, katex: runtimeRoot.katex,
-            renderText: text => buildMarkdownInlineNodes(text)
-          }),
+          createMathNode: segment => runtimeRoot.CodexOverleafMathText.createMathNode(segment,
+            { document, katex: runtimeRoot.katex, macros: getMathMacros(),
+              renderText: text => buildMarkdownInlineNodes(text) }),
           recordDiagnostic: recordRenderingDiagnostic
         });
         return;

package/extension/src/content/mathText.js

@@ -9,6 +9,19 @@
   ]);
   const LONG_INLINE_MATH_CHARS = 120;
   const COMPLEX_INLINE_MATH_CHARS = 80;
+  const MAX_PROJECT_MACRO_SOURCES = 12;
+  const MAX_PROJECT_MACRO_SOURCE_CHARS = 256 * 1024;
+  const MAX_PROJECT_MACROS = 64;
+  const MAX_MACRO_EXPANSION_CHARS = 512;
+  const DEFAULT_MATH_MACROS = Object.freeze({
+    '\\E': '\\mathbb{E}',
+    '\\Var': '\\operatorname{Var}',
+    '\\Cov': '\\operatorname{Cov}',
+    '\\R': '\\mathbb{R}',
+    '\\N': '\\mathbb{N}',
+    '\\Z': '\\mathbb{Z}'
+  });
+  const UNSAFE_MACRO_PATTERN = /\\(?:href|url|includegraphics|input|include|write|openout|read|html\w*|class|style|data|def|gdef|edef|xdef|newcommand|renewcommand|providecommand|DeclareMathOperator)\b/i;
 
   function parseMathSegments(value) {
     const source = String(value || '');
@@ -74,9 +87,10 @@
         searchFrom = start + delimiter.open.length;
         continue;
       }
-      const value = source.slice(start + delimiter.open.length, closeStart);
+      const rawValue = source.slice(start + delimiter.open.length, closeStart);
+      const value = rawValue.trim();
       const end = closeStart + delimiter.close.length;
-      if (!isValidMathValue(value, delimiter) || overlapsCodeRange(start, end, codeRanges)) {
+      if (!isValidMathValue(rawValue, delimiter) || overlapsCodeRange(start, end, codeRanges)) {
         searchFrom = start + delimiter.open.length;
         continue;
       }
@@ -94,7 +108,7 @@
     }
     const previous = source[index - 1] || '';
     const next = source[index + 1] || '';
-    return previous !== '$' && next !== '$' && next !== '' && !/\s/.test(next);
+    return previous !== '$' && next !== '$' && next !== '';
   }
 
   function findClosingDelimiter(source, fromIndex, delimiter, codeRanges) {
@@ -107,7 +121,7 @@
       const previous = source[index - 1] || '';
       const next = source[index + delimiter.close.length] || '';
       const invalidSingleDollar = delimiter.singleDollar
-        && (previous === '$' || next === '$' || /\s/.test(previous));
+        && (previous === '$' || next === '$');
       if (!isEscaped(source, index) && !isInsideRange(index, codeRanges) && !invalidSingleDollar) {
         return index;
       }
@@ -118,10 +132,24 @@
 
   function isValidMathValue(value, delimiter) {
     const source = String(value || '');
-    if (!source.trim()) {
+    const trimmed = source.trim();
+    if (!trimmed) {
       return false;
     }
-    return delimiter.display || !/[\r\n]/.test(source);
+    if (!delimiter.display && /[\r\n]/.test(source)) {
+      return false;
+    }
+    if (!delimiter.singleDollar || (!/^\s/.test(source) && !/\s$/.test(source))) {
+      return true;
+    }
+    return looksLikeWhitespaceWrappedMath(trimmed);
+  }
+
+  function looksLikeWhitespaceWrappedMath(value) {
+    const source = String(value || '').trim();
+    return /\\[A-Za-z]+/.test(source)
+      || /[_^=<>+\-*/()[\]{}|]/.test(source)
+      || /^[A-Za-z](?:_[A-Za-z0-9{}]+|\^[A-Za-z0-9{}]+)?$/.test(source);
   }
 
   function collectInlineCodeRanges(source) {
@@ -179,7 +207,8 @@
       }
       nodes.push(createMathNode(segment, {
         document: documentRef,
-        katex: options.katex || root.katex
+        katex: options.katex || root.katex,
+        macros: options.macros || buildMathMacros(options.projectSources)
       }));
     }
     return nodes;
@@ -206,6 +235,7 @@
         strict: 'warn',
         maxExpand: 200,
         maxSize: 20,
+        macros: options.macros || buildMathMacros(),
         output: 'htmlAndMathml'
       });
       node.dataset.mathRendered = 'true';
@@ -213,7 +243,7 @@
     } catch (_error) {
       node.classList.add('run-math--fallback');
       node.dataset.mathRendered = 'false';
-      node.textContent = segment.raw;
+      node.textContent = source;
       return node;
     }
   }
@@ -235,6 +265,120 @@
     return /(?:=|\\(?:le|ge|approx|sim|to|Rightarrow|Longrightarrow)\b|\\begin\{(?:aligned|gathered|split|array)\}|\\\\)/.test(source);
   }
 
+  function parseStandaloneMath(value) {
+    const source = String(value || '').trim();
+    if (!source) {
+      return null;
+    }
+    const segments = parseMathSegments(source);
+    if (segments.length !== 1 || segments[0].type !== 'math' || segments[0].raw !== source) {
+      return null;
+    }
+    return segments[0];
+  }
+
+  function buildMathMacros(projectSources = []) {
+    const macros = { ...DEFAULT_MATH_MACROS };
+    let remainingChars = MAX_PROJECT_MACRO_SOURCE_CHARS;
+    let projectMacroCount = 0;
+    for (const sourceRecord of Array.isArray(projectSources)
+      ? projectSources.slice(0, MAX_PROJECT_MACRO_SOURCES)
+      : []) {
+      if (projectMacroCount >= MAX_PROJECT_MACROS || remainingChars <= 0) {
+        break;
+      }
+      const path = String(sourceRecord?.path || '');
+      if (!/\.(?:tex|sty|cls|ltx)$/i.test(path)) {
+        continue;
+      }
+      const source = stripLatexComments(
+        String(sourceRecord?.content || '').slice(0, remainingChars)
+      );
+      remainingChars -= source.length;
+      const pattern = /\\(newcommand|renewcommand|providecommand|DeclareMathOperator)(\*)?/g;
+      let match;
+      while ((match = pattern.exec(source)) !== null && projectMacroCount < MAX_PROJECT_MACROS) {
+        let cursor = skipWhitespace(source, pattern.lastIndex);
+        const nameGroup = readBracedGroup(source, cursor);
+        if (!nameGroup) {
+          continue;
+        }
+        const macroName = nameGroup.value.trim();
+        cursor = skipWhitespace(source, nameGroup.end);
+        if (source[cursor] === '[') {
+          continue;
+        }
+        const expansionGroup = readBracedGroup(source, cursor);
+        if (!expansionGroup) {
+          continue;
+        }
+        let expansion = expansionGroup.value.trim();
+        if (match[1] === 'DeclareMathOperator') {
+          expansion = `\\operatorname${match[2] ? '*' : ''}{${expansion}}`;
+        }
+        if (!isSafeMacroDefinition(macroName, expansion)) {
+          continue;
+        }
+        macros[macroName] = expansion;
+        projectMacroCount++;
+        pattern.lastIndex = expansionGroup.end;
+      }
+    }
+    return macros;
+  }
+
+  function readBracedGroup(source, start) {
+    if (source[start] !== '{') {
+      return null;
+    }
+    let depth = 0;
+    for (let index = start; index < source.length; index++) {
+      if (source[index] === '{' && !isEscaped(source, index)) {
+        depth++;
+      } else if (source[index] === '}' && !isEscaped(source, index)) {
+        depth--;
+        if (depth === 0) {
+          return {
+            value: source.slice(start + 1, index),
+            end: index + 1
+          };
+        }
+      }
+    }
+    return null;
+  }
+
+  function skipWhitespace(source, start) {
+    let index = start;
+    while (index < source.length && /\s/.test(source[index])) {
+      index++;
+    }
+    return index;
+  }
+
+  function stripLatexComments(source) {
+    return String(source || '').split(/\r?\n/).map(line => {
+      for (let index = 0; index < line.length; index++) {
+        if (line[index] === '%' && !isEscaped(line, index)) {
+          return line.slice(0, index);
+        }
+      }
+      return line;
+    }).join('\n');
+  }
+
+  function isSafeMacroDefinition(name, expansion) {
+    const macroName = String(name || '');
+    const body = String(expansion || '');
+    return /^\\[A-Za-z@]+$/.test(macroName)
+      && body.length > 0
+      && body.length <= MAX_MACRO_EXPANSION_CHARS
+      && !body.includes('#')
+      && !body.includes(macroName)
+      && !UNSAFE_MACRO_PATTERN.test(macroName)
+      && !UNSAFE_MACRO_PATTERN.test(body);
+  }
+
   function toNodeArray(value) {
     if (Array.isArray(value)) {
       return value;
@@ -265,11 +409,13 @@
   }
 
   const api = {
+    buildMathMacros,
     buildMathNodes,
     createMathNode,
     matchMathAt,
     normalizeMathForRendering,
-    parseMathSegments
+    parseMathSegments,
+    parseStandaloneMath
   };
   root.CodexOverleafMathText = api;
   if (typeof module !== 'undefined' && module.exports) {

package/extension/src/content/modelPicker.js

@@ -452,8 +452,8 @@
       if (effort === 'xhigh') return 'Max';
     }
     const labels = getLocale() === 'zh'
-      ? { none: '关闭', minimal: '最小', low: '低', medium: '中', high: '高', xhigh: '超高' }
-      : { none: 'Off', minimal: 'Minimal', low: 'Low', medium: 'Medium', high: 'High', xhigh: 'XHigh' };
+      ? { none: '关闭', minimal: '最小', low: '低', medium: '中', high: '高', xhigh: '超高', max: '最大', ultra: '极限' }
+      : { none: 'Off', minimal: 'Minimal', low: 'Low', medium: 'Medium', high: 'High', xhigh: 'XHigh', max: 'Max', ultra: 'Ultra' };
     return labels[effort] || effort || '';
   }
 

package/extension/src/content/modelPickerSupport.js

@@ -19,7 +19,7 @@
   }
 
   function normalizeReasoningEffortsForSelect(efforts) {
-    const allowed = new Set(['none', 'minimal', 'low', 'medium', 'high', 'xhigh']);
+    const allowed = new Set(['none', 'minimal', 'low', 'medium', 'high', 'xhigh', 'max', 'ultra']);
     return Array.from(new Set((Array.isArray(efforts) ? efforts : [])
       .map(effort => normalizeModelOptionId(effort))
       .filter(effort => allowed.has(effort))));
@@ -92,12 +92,12 @@
       const normalized = {
         id,
         label: typeof model?.label === 'string' && model.label.length > 0 ? model.label : id,
-        reasoningEfforts: Array.isArray(model?.reasoningEfforts) ? model.reasoningEfforts.slice() : [],
+        reasoningEfforts: normalizeReasoningEffortsForSelect(model?.reasoningEfforts),
         reasoningPresentation: typeof model?.reasoningPresentation === 'string' ? model.reasoningPresentation : '',
         speedTiers: normalizeSpeedTiersForSelect(model?.speedTiers)
       };
       if (Object.prototype.hasOwnProperty.call(Object(model), 'defaultReasoningEffort')) {
-        normalized.defaultReasoningEffort = model.defaultReasoningEffort;
+        normalized.defaultReasoningEffort = normalizeModelOptionId(model.defaultReasoningEffort);
       }
       if (Object.prototype.hasOwnProperty.call(Object(model), 'defaultSpeedTier')) {
         normalized.defaultSpeedTier = model.defaultSpeedTier;

package/extension/src/content/nativeCompatibilityController.js

@@ -256,8 +256,8 @@
       tip.dataset.onboardingTip = 'true';
       tip.setAttribute('role', 'status');
       tip.textContent = tx(
-        'Tip: Start with Ask mode to explore safely. Switch to Suggest to review edits before applying.',
-        '提示：先用 Ask 模式安全探索；需要修改时切换到 Suggest，应用前可先审阅。'
+        'Tip: Start with Ask mode to explore safely. Switch to Auto only when you want Codex to edit files.',
+        '提示：先用 Ask 模式安全探索；只有需要 Codex 修改文件时才切换到 Auto。'
       );
       Object.assign(tip.style, {
         position: 'absolute',

package/extension/src/content/otWarmMirror.js

@@ -868,7 +868,7 @@
         applyResults: [],
         nextStep: tr('warmMirrorStaleBlockedNextStep')
       });
-      finishRunView(tr('warmMirrorStaleBlockedTitle'), 'failed');
+      await finishRunView(tr('warmMirrorStaleBlockedTitle'), 'failed');
       return { ok: false };
     }
     if (focusedPartialSnapshot) {

package/extension/src/content/pageBridgeClient.js

@@ -21,6 +21,7 @@
     ['src/page/overleafProjectSnapshot.js', 'codex-overleaf-project-snapshot-script'],
     ['src/page/pageBridgeCapability.js', 'codex-overleaf-page-bridge-capability-script'],
     ['src/page/treeOperations.js', 'codex-overleaf-tree-operations-script', true],
+    ['src/page/binaryAssetUploader.js', 'codex-overleaf-binary-asset-uploader-script', true],
     ['src/page/snapshotRouter.js', 'codex-overleaf-snapshot-router-script'],
     ['src/page/writeGuard.js', 'codex-overleaf-write-guard-script', true],
     ['src/page/trackedChangesLifecycle.js', 'codex-overleaf-tracked-changes-lifecycle-script', true],

package/extension/src/content/runResultActions.js

@@ -0,0 +1,114 @@
+(function initCodexOverleafRunResultActions(root, factory) {
+  const api = factory();
+  if (typeof module === 'object' && module.exports) module.exports = api;
+  if (root) root.CodexOverleafRunResultActions = api;
+})(typeof window !== 'undefined' ? window : globalThis, function runResultActionsFactory() {
+  'use strict';
+
+  function create(deps = {}) {
+    const {
+      tr,
+      getLocale,
+      forkRunFromNode,
+      document: documentRef = globalThis.document,
+      navigator: navigatorRef = globalThis.navigator
+    } = deps;
+
+    function configureResultActions(root, run) {
+      const actions = root.querySelector('.run-result-actions');
+      const reports = root.querySelectorAll('.run-completion-report');
+      const report = reports[reports.length - 1];
+      if (!actions || !report) return;
+      report.append(actions);
+      actions.hidden = false;
+      configureCopyButton(root);
+      configureForkButton(root, run);
+      configureCompletedTime(actions, run);
+    }
+
+    function configureForkButton(root, run) {
+      const existing = root.querySelector('[data-run-fork]');
+      const button = existing.cloneNode(true);
+      existing.replaceWith(button);
+      const available = run.forkSnapshot !== true
+        && run.status !== 'running'
+        && Boolean(run.codexTurnId)
+        && typeof forkRunFromNode === 'function';
+      button.hidden = false;
+      button.disabled = !available;
+      button.title = tr(available ? 'forkRunTitle' : 'forkRunUnavailable');
+      button.setAttribute('aria-label', button.title);
+      button.innerHTML = '<svg viewBox="0 0 20 20" aria-hidden="true"><path d="M3 10h3.5c3.5 0 4.2-4 7.5-4h2m-2.5-2.5L16 6l-2.5 2.5M6.5 10c3.5 0 4.2 4 7.5 4h2m-2.5-2.5L16 14l-2.5 2.5"/></svg>';
+      if (!available) return;
+      button.addEventListener('click', async event => {
+        event.stopPropagation();
+        button.disabled = true;
+        button.classList.add('is-running');
+        try {
+          await forkRunFromNode(run.id);
+        } catch (_error) {
+          button.disabled = false;
+          button.classList.remove('is-running');
+        }
+      });
+    }
+
+    function configureCompletedTime(actions, run) {
+      const target = actions.querySelector('[data-run-completed-time]');
+      const finishedAt = String(run.finishedAt || '').trim();
+      const date = finishedAt ? new Date(finishedAt) : null;
+      if (!target || !date || !Number.isFinite(date.getTime())) return;
+      target.hidden = false;
+      target.textContent = new Intl.DateTimeFormat(getLocale(), {
+        hour: '2-digit',
+        minute: '2-digit'
+      }).format(date);
+      target.title = date.toLocaleString(getLocale());
+    }
+
+    function configureCopyButton(root) {
+      const existing = root.querySelector('[data-run-copy]');
+      const button = existing.cloneNode(true);
+      existing.replaceWith(button);
+      const finalAnswer = root.querySelector('.run-completion-report .run-final-answer');
+      const copyText = String(finalAnswer?.innerText || finalAnswer?.textContent || '').trim();
+      button.hidden = false;
+      button.disabled = !copyText;
+      button.title = tr('copyConclusionTitle');
+      button.setAttribute('aria-label', button.title);
+      button.innerHTML = '<svg viewBox="0 0 20 20" aria-hidden="true"><rect x="6.5" y="6.5" width="9" height="9" rx="2"/><path d="M13.5 6.5V5a2 2 0 0 0-2-2H5a2 2 0 0 0-2 2v6.5a2 2 0 0 0 2 2h1.5"/></svg>';
+      if (!copyText) return;
+      button.addEventListener('click', async event => {
+        event.stopPropagation();
+        try {
+          await writeClipboardText(copyText);
+          button.title = tr('copyConclusionDone');
+        } catch (_error) {
+          button.title = tr('copyConclusionFailed');
+        }
+        button.setAttribute('aria-label', button.title);
+      });
+    }
+
+    async function writeClipboardText(text) {
+      if (navigatorRef?.clipboard?.writeText) {
+        await navigatorRef.clipboard.writeText(text);
+        return;
+      }
+      const textarea = documentRef.createElement('textarea');
+      textarea.value = text;
+      textarea.setAttribute('readonly', '');
+      textarea.style.position = 'fixed';
+      textarea.style.opacity = '0';
+      documentRef.body.append(textarea);
+      textarea.select();
+      const copied = documentRef.execCommand('copy');
+      textarea.remove();
+      if (!copied) throw new Error('clipboard_copy_failed');
+    }
+
+    return Object.freeze({ configureResultActions });
+  }
+
+  return Object.freeze({ create });
+});

package/extension/src/content/runTimelineView.js

@@ -13,6 +13,7 @@
   function create(deps = {}) {
     const {
       RunGuidanceView,
+      RunResultActions,
       tr,
       tx,
       getLocale,
@@ -274,6 +275,9 @@
     if (status === 'failed') {
       return tr('processedFailed', { elapsed });
     }
+    if (status === 'rejected' || status === 'cancelled') {
+      return tr('processedCancelled', { elapsed });
+    }
     if (status === 'running') {
       return tr('processing', { elapsed });
     }
@@ -343,6 +347,11 @@
           </summary>
         </details>
         <div class="run-activity-list" data-run-events></div>
+        <div class="run-result-actions" hidden>
+          <button type="button" class="run-copy-action" data-run-copy hidden></button>
+          <button type="button" class="run-fork-action" data-run-fork hidden></button>
+          <span class="run-completed-time" data-run-completed-time hidden></span>
+        </div>
         <div class="run-report" data-run-report aria-live="polite" hidden></div>
       </div>
     `;
@@ -396,6 +405,7 @@
       }
     }
 
+    RunResultActions.configureResultActions(root, run);
     configureAcceptButton(root, run);
     configureUndoButton(root, run);
     return root;
@@ -411,6 +421,9 @@
     if (run.startedAt && run.finishedAt) {
       return formatProcessedSummary(run.status || 'completed', new Date(run.finishedAt).getTime() - new Date(run.startedAt).getTime());
     }
+    if (run.status === 'rejected' || run.status === 'cancelled') {
+      return tx('Cancelled', '已取消');
+    }
     return run.status === 'failed' ? tx('Failed', '处理失败') : tx('Done', '已处理');
   }
 
@@ -880,6 +893,11 @@
     const button = existing.cloneNode(true);
     existing.replaceWith(button);
 
+    if (run.forkSnapshot === true) {
+      button.hidden = true;
+      return;
+    }
+
     if (isTrackedChangeLifecycleRun(run)) {
       configureLifecycleUndoButton(button, run);
       return;
@@ -976,6 +994,11 @@
     const button = existing.cloneNode(true);
     existing.replaceWith(button);
 
+    if (run.forkSnapshot === true) {
+      button.hidden = true;
+      return;
+    }
+
     if (!isTrackedChangeLifecycleRun(run)) {
       button.hidden = true;
       return;