codex-overleaf-link 2.4.1 → 2.5.0

package/extension/src/content/runFailureNotice.js

@@ -10,6 +10,19 @@
   const REVIEW_CODES = new Set(['write_timeout', 'partial_write_needs_review']);
   const CANCEL_CODES = new Set(['cancelled', 'user_cancelled', 'codex_cancelled']);
 
+  // Old attempts remain in the stored audit trail; a resolved undo must not
+  // advertise them as a current failure in the transcript or its summary.
+  function projectResolvedUndo(run) {
+    if (!run || (run.undoStatus !== 'applied' && run.trackedChangeStatus !== 'rejected')
+      || !Array.isArray(run.events)) return run;
+    const events = run.events.filter(event => {
+      if (event?.status !== 'failed' || event.streamRole
+        || ['report', 'guidance', 'stream'].includes(event.kind)) return true;
+      return !/^(?:Undo result:\s*(?:undone|rejected)\s+\d+\s+(?:item\(s\)|file\(s\)|tracked change\(s\)),\s*skipped\s+\d+(?:\s+item\(s\))?|撤销结果[：:]\s*已(?:撤销|拒绝)\s*\d+\s*(?:项|条留痕|个文件)，\s*跳过\s*\d+\s*(?:项|条))$/.test(String(event.title || '').trim());
+    });
+    return events.length === run.events.length ? run : { ...run, events };
+  }
+
   function create({ tr, projectRunSettlement, sanitizeText = value => value,
     document: documentRef = globalThis.document } = {}) {
     const notices = new WeakMap();
@@ -100,5 +113,5 @@
       && !path.split('/').includes('..') ? path.slice(0, 300) : '';
   }
 
-  return Object.freeze({ create });
+  return Object.freeze({ create, projectResolvedUndo });
 });

package/extension/src/content/runGuidanceController.js

@@ -49,13 +49,14 @@
     function appendToView(event, view) {
       const text = deps.RunGuidanceView?.getGuidanceText(event);
       if (!text) return false;
-      const guidance = view.guidance || view.root?.querySelector('[data-run-guidance]');
-      const target = view.terminalStatus ? guidance : view.events;
+      const root = view.root || view.events?.closest('[data-run-id]');
+      const guidance = view.guidance || root?.querySelector('[data-run-guidance]');
+      const target = guidance || view.events;
       if (!target) return false;
       view.guidance = guidance;
       const rendered = deps.renderRunEvent(event);
       const existing = event.guidanceId
-        ? view.root?.querySelector(`[data-guidance-id="${deps.cssEscape(event.guidanceId)}"]`)
+        ? root?.querySelector(`[data-guidance-id="${deps.cssEscape(event.guidanceId)}"]`)
         : null;
       if (existing) existing.replaceWith(rendered);
       else target.append(rendered);

package/extension/src/content/runPresence.js

@@ -0,0 +1,306 @@
+(function initRunPresence(root, factory) {
+  if (typeof module === 'object' && module.exports) {
+    module.exports = factory();
+  } else {
+    root.CodexOverleafModuleRegistry.define('RunPresence', [], factory);
+  }
+})(typeof window !== 'undefined' ? window : globalThis, function runPresenceFactory() {
+  'use strict';
+
+  // Presentation-only run header: the animated brand mark, the live label and
+  // the settled summary. It never reads or writes run records.
+  const VERBS = {
+    en: ['Vibe writing', 'Typesetting', 'Kerning', 'Footnoting', 'Citing sources', 'Peer-reviewing',
+      'Polishing prose', 'Balancing braces', 'Chasing references', 'Proofreading', 'Untangling macros',
+      'Hunting overfull hboxes'],
+    zh: ['推敲中', '斟酌措辞', '排版中', '查文献', '对齐公式', '润色中', '翻稿纸', '补脚注', '配平括号',
+      '追引用', '校对中', '抓 overfull hbox']
+  };
+  const TIPS = {
+    en: ['Type @ to add a file as context, e.g. @sections/intro.tex.',
+      'Ask for an edit, not a rewrite: “tighten §2, keep every citation”.',
+      'Compile errors can go straight back to Codex from the log.',
+      '\\label everything. Cross-references are cheaper than prose.',
+      'Reviewer 2 is not here. Yet.',
+      'Overfull \\hbox? Ask Codex to rephrase the line, not shrink the font.'],
+    zh: ['输入 @ 把文件加入上下文，比如 @sections/intro.tex。',
+      '让它“改”而不是“重写”：“精简 §2，保留所有引用”。',
+      '编译报错可以直接从日志发回给 Codex。',
+      '多打 \\label。交叉引用比文字描述省事。',
+      'Reviewer 2 还没来，趁现在。',
+      'Overfull \\hbox？让 Codex 改写这一行，而不是缩字号。']
+  };
+  // The header word changes rarely: at 1, 3, 7 and 15 minutes, so even a long run shows only a few words.
+  const WORD_AT_MS = [0, 60000, 180000, 420000, 900000];
+  const LONG_RUN_MS = 120000;
+  // Layers (inlined in panel.css) are pixel-exact slices of assets/icons/codex-overleaf-icon.png;
+  // the origins (percent of the square crop) are the leaf stem and cloud centre.
+  const MARK_LAYERS = ['cloud', 'cursor', 'leaf'];
+  const MARK_STYLE = '--mark-leaf-origin:70.6% 41.6%;--mark-cloud-origin:44.3% 55%';
+  const ICONS = {
+    alert: '<circle cx="8" cy="8" r="6"/><path d="M8 4.5v4 M8 11h.01"/>',
+    check: '<path d="m3.5 8 3 3 6-6"/>',
+    file: '<path d="M9 2H4v12h8V5L9 2Z M9 2v4h3 M6 9h4 M6 11h3"/>',
+    refresh: '<path d="M4.2 5.3A5 5 0 1 1 3.6 10"/><path d="M4.2 2.2v3.1H1.1"/>'
+  };
+
+  const escapeHtml = value => String(value ?? '').replace(/[&<>"']/g, char => ({
+    '&': '&amp;', '<': '&lt;', '>': '&gt;', '"': '&quot;', "'": '&#39;'
+  })[char]);
+
+  function icon(name, className = 'codex-glyph') {
+    return '<svg class="' + className + '" viewBox="0 0 16 16" aria-hidden="true" focusable="false">'
+      + (ICONS[name] || ICONS.check) + '</svg>';
+  }
+
+  function qed(className = '') {
+    return '<span class="run-qed' + (className ? ' ' + className : '') + '" aria-hidden="true">'
+      + '<svg viewBox="0 0 11 11" focusable="false"><rect x="1" y="1" width="9" height="9" rx=".6"/></svg></span>';
+  }
+
+  function pickDifferent(list, previous, random) {
+    if (list.length < 2) return list[0] || '';
+    const index = Math.min(list.length - 1, Math.floor(random() * list.length));
+    // Step past a repeat instead of re-rolling, so a fixed random source can never spin.
+    return list[index] === previous ? list[(index + 1) % list.length] : list[index];
+  }
+
+  // Tool rows win over playful verbs; the label names the real action.
+  function activityVerb(item, tx) {
+    const meta = item?.meta || {};
+    if (item?.kind === 'explore') {
+      return ({ read: tx('Reading', '读取'), search: tx('Searching', '搜索'), list: tx('Listing', '查看') })[meta.action]
+        || tx('Exploring', '查阅');
+    }
+    if (item?.kind === 'edit') {
+      return ({ add: tx('Creating', '新建'), delete: tx('Deleting', '删除'), move: tx('Moving', '移动') })[item.file?.operation]
+        || tx('Editing', '修改');
+    }
+    return ({ command: tx('Running', '执行'), compile: tx('Compiling', '编译'), sync: tx('Syncing to Overleaf', '同步到 Overleaf'),
+      tool: tx('Using', '调用'), agent: tx('Delegating', '委派子代理'), plan: tx('Planning', '规划') })[item?.kind]
+      || tx('Working', '处理中');
+  }
+
+  // Header-only command label: drop the shell wrapper and the leading `cd …&&`, keep the first command.
+  function commandSummary(command) {
+    let text = String(command || '').trim().replace(/^(?:\/usr)?\/bin\/(?:ba|z)?sh\s+-l?c\s+/, '');
+    if (/^(["']).*\1$/s.test(text)) text = text.slice(1, -1);
+    text = text.replace(/^cd\s+.*?&&\s*/, '').split(/\s*(?:&&|\|\||[|;])\s*/)[0].replace(/\s+/g, ' ').trim();
+    return text.length > 48 ? text.slice(0, 47) + '…' : text;
+  }
+
+  // Settled header: ∎ (end of proof) followed by what the run actually did.
+  function settledHtml(facts = {}, tx, formatElapsed) {
+    const hasElapsed = Number.isFinite(facts.elapsedMs);
+    const elapsed = hasElapsed ? '<span>' + escapeHtml(formatElapsed(facts.elapsedMs)) + '</span>' : '';
+    const sep = '<span class="run-summary-sep">·</span>';
+    if (facts.kind === 'stopped') {
+      return qed('is-open' + (facts.animate ? ' is-settling' : '')) + '<span class="run-summary-stopped">\\end{draft}</span>'
+        + (hasElapsed ? sep + '<span>' + escapeHtml(tx('stopped at ', '停在 ') + formatElapsed(facts.elapsedMs)) + '</span>' : '');
+    }
+    const parts = elapsed ? [elapsed] : [];
+    if (facts.files > 0) {
+      const files = tx(facts.files + (facts.files === 1 ? ' file' : ' files'), facts.files + ' 个文件');
+      // A clipped history only proves the files it recorded.
+      parts.push('<span>' + escapeHtml(facts.filesClipped ? tx(files + ' recorded', '已记录 ' + files) : files) + '</span>');
+      if (facts.added || facts.removed) {
+        parts.push('<span><span class="run-summary-add">+' + Number(facts.added || 0) + '</span> <span class="run-summary-del">−'
+          + Number(facts.removed || 0) + '</span></span>');
+      }
+    } else if (facts.steps > 0) {
+      parts.push('<span>' + escapeHtml(tx(facts.steps + ' steps', facts.steps + ' 步')) + '</span>');
+    }
+    if (facts.compiled) parts.push('<span>' + escapeHtml(tx('compiled', '已编译')) + '</span>');
+    if (facts.firstCompile) {
+      parts.push('<span class="run-summary-qed">' + escapeHtml(tx('Q.E.D. — first clean compile', 'Q.E.D. · 首次编译通过')) + '</span>');
+    }
+    const mark = qed(facts.animate ? 'is-settling' + (facts.firstCompile ? ' is-first' : '') : '');
+    return '<span class="codex-sr-only">' + escapeHtml(tx('Done', '已完成')) + '</span>' + mark + parts.join(sep);
+  }
+
+  function create(deps = {}) {
+    const tx = deps.tx || ((en) => en);
+    const locale = () => (deps.getLocale?.() === 'zh' ? 'zh' : 'en');
+    const formatElapsed = deps.formatElapsed || (ms => Math.round(ms / 1000) + 's');
+    const now = deps.now || Date.now;
+    const random = deps.random || Math.random;
+    const storage = deps.storage === undefined ? safeStorage() : deps.storage;
+    // Wrapped, never stored bare: browser timers throw "Illegal invocation" when called as methods of another object.
+    const timers = { later: (fn, ms) => (deps.setTimeout || globalThis.setTimeout)(fn, ms) };
+    const doc = () => deps.document || globalThis.document;
+    const live = new WeakMap();
+    const longRunsShown = new Set();
+    let tipIndex = Math.floor(random() * TIPS.en.length);
+
+    function safeStorage() {
+      try { return globalThis.localStorage || null; } catch { return null; }
+    }
+    function once(key) {
+      try {
+        if (!storage || storage.getItem(key)) return false;
+        storage.setItem(key, '1');
+        return true;
+      } catch { return false; }
+    }
+    function isLateNight() {
+      const hour = new Date(now()).getHours();
+      return hour >= 23 || hour < 5;
+    }
+    function lateNightEgg() {
+      if (!isLateNight()) return '';
+      // One "night" runs until 05:00, so a 01:00 run belongs to the previous date.
+      const night = new Date(now() - 5 * 3600000).toDateString();
+      return once('codex-overleaf:egg:late-night:' + night) ? tx('Burning the midnight oil', '挑灯夜战') : '';
+    }
+
+    function markHtml(className = '') {
+      return '<span class="run-mark' + (className ? ' ' + className : '') + '" aria-hidden="true" style="' + MARK_STYLE + '">'
+        + MARK_LAYERS.map(layer => '<span class="run-mark-' + layer + '"></span>').join('') + '</span>';
+    }
+
+    function stop(el) {
+      live.delete(el);
+    }
+
+    function swapLabel(state, html, egg = false) {
+      const box = state.label;
+      const next = doc().createElement('span');
+      next.className = 'is-in';
+      next.innerHTML = '<span class="run-shimmer' + (egg ? ' is-egg' : '') + '">' + html + '…</span>';
+      // Drop anything still fading out, so a slow timer can never leave the label blank.
+      for (const stale of [...(box.children || [])]) if (stale.className === 'is-out') stale.remove();
+      const old = box.lastElementChild;
+      box.append(next);
+      if (old) {
+        old.className = 'is-out';
+        timers.later(() => old.remove(), 280);
+      }
+    }
+
+    function nextIdle(state) {
+      const egg = state.eggs.shift();
+      if (egg) { swapLabel(state, escapeHtml(egg), true); return; }
+      state.verb = pickDifferent(VERBS[locale()], state.verb, random);
+      swapLabel(state, escapeHtml(state.verb));
+    }
+
+    function wordSlot(elapsedMs) {
+      let slot = 0;
+      for (let index = 0; index < WORD_AT_MS.length; index += 1) if (elapsedMs >= WORD_AT_MS[index]) slot = index;
+      return slot;
+    }
+
+    function ensureRunning(el, runId) {
+      let state = live.get(el);
+      if (state && state.runId === runId) return state;
+      stop(el);
+      el.dataset.presence = 'running';
+      el.innerHTML = markHtml() + '<span class="codex-sr-only">' + escapeHtml(tx('Running', '运行中')) + '</span>'
+        + '<span class="run-presence-label"></span><span class="run-presence-timer"></span>';
+      state = { runId, key: '', verb: '', slot: -1, elapsedMs: 0, eggs: [], label: el.querySelector('.run-presence-label'),
+        timer: el.querySelector('.run-presence-timer') };
+      const late = lateNightEgg();
+      if (late) state.eggs.push(late);
+      live.set(el, state);
+      return state;
+    }
+
+    // label: { kind: 'stage', text } | { kind: 'idle' }. Tool steps live in the round list, not the header.
+    function paintRunning(el, { runId = '', label = { kind: 'idle' }, elapsedMs } = {}) {
+      if (!el) return;
+      const state = ensureRunning(el, runId);
+      state.idle = label.kind !== 'stage';
+      if (elapsedMs !== undefined) tick(el, elapsedMs);
+      if (!state.idle) {
+        const key = 's:' + label.text;
+        if (key !== state.key) { state.key = key; swapLabel(state, escapeHtml(label.text)); }
+        return;
+      }
+      refreshWord(state);
+    }
+
+    function refreshWord(state) {
+      const slot = wordSlot(state.elapsedMs);
+      if (state.key === 'idle' && slot === state.slot) return;
+      state.key = 'idle';
+      state.slot = slot;
+      nextIdle(state);
+    }
+
+    function tick(el, elapsedMs) {
+      const state = live.get(el);
+      if (!state) return;
+      const value = formatElapsed(elapsedMs);
+      if (state.timer.textContent !== value) state.timer.textContent = value;
+      state.elapsedMs = elapsedMs;
+      if (elapsedMs > LONG_RUN_MS && state.runId && !longRunsShown.has(state.runId)) {
+        longRunsShown.add(state.runId);
+        state.eggs.push(tx('This is a long proof', '这是个长证明'));
+      }
+      if (state.idle) refreshWord(state);
+    }
+
+    // facts: { kind: 'done' | 'stopped' | 'failed' | 'plain', text, elapsedMs, files, added, removed,
+    //          steps, compiled, projectId, animate }
+    function paintSettled(el, facts = {}) {
+      if (!el) return;
+      stop(el);
+      const firstCompile = facts.kind === 'done' && facts.animate && facts.compiled && facts.projectId
+        ? once('codex-overleaf:egg:first-compile:' + facts.projectId) : false;
+      const stamp = JSON.stringify({ ...facts, animate: false });
+      if (el.dataset.presenceStamp === stamp && !facts.animate) return;
+      el.dataset.presenceStamp = stamp;
+      el.dataset.presence = facts.kind || 'plain';
+      if (facts.kind === 'done' || facts.kind === 'stopped') {
+        el.innerHTML = settledHtml({ ...facts, firstCompile }, tx, formatElapsed);
+      } else if (facts.kind === 'failed') {
+        el.innerHTML = icon('alert') + '<span>' + escapeHtml(facts.text) + '</span>';
+      } else {
+        el.textContent = facts.text || '';
+      }
+    }
+
+    function emptyTitle() {
+      return isLateNight() ? tx("Still up? Let's finish this section.", '还没睡？把这一节写完吧。')
+        : tx('What are we writing today?', '今天写点什么？');
+    }
+
+    // Decorates the existing empty-state element with the mark, project chip and a tip.
+    function decorateEmpty(empty, { projectName = '' } = {}) {
+      const mark = doc().createElement('div');
+      mark.className = 'run-empty-mark';
+      mark.innerHTML = markHtml('is-large');
+      empty.prepend(mark);
+      const title = empty.querySelector('.empty-runs-title');
+      if (title) title.textContent = emptyTitle();
+      if (projectName) {
+        const chip = doc().createElement('span');
+        chip.className = 'run-empty-project';
+        chip.innerHTML = icon('file') + '<span></span>';
+        chip.lastElementChild.textContent = projectName;
+        title?.after(chip);
+      }
+      const tip = doc().createElement('div');
+      tip.className = 'run-empty-tip';
+      tip.innerHTML = '<span class="run-empty-pilcrow" aria-hidden="true">¶</span><span class="run-empty-tip-text"></span>'
+        + '<button type="button" class="run-empty-tip-next">' + icon('refresh') + '</button>';
+      const next = tip.querySelector('button');
+      next.title = tx('Next tip', '换一条');
+      next.setAttribute('aria-label', next.title);
+      const show = () => {
+        const old = tip.querySelector('.run-empty-tip-text');
+        const fresh = old.cloneNode(false);
+        fresh.textContent = TIPS[locale()][tipIndex % TIPS.en.length];
+        old.replaceWith(fresh);
+      };
+      next.addEventListener('click', () => { tipIndex += 1; show(); });
+      show();
+      empty.append(tip);
+      return empty;
+    }
+
+    return { markHtml, paintRunning, tick, paintSettled, decorateEmpty, stop };
+  }
+
+  return { create, VERBS, TIPS, activityVerb, commandSummary, settledHtml, icon };
+});

package/extension/src/content/runQueueScheduler.js

@@ -322,7 +322,8 @@
           tr: options.tr,
           onGuide: itemId => guide(itemId).catch(error => options.toast?.(error.message, 'warning')),
           onRemove: remove,
-          onResume: resume
+          onResume: resume,
+          onToast: message => options.toast?.(message, 'warning')
         });
         if (view) {
           view.container = container;

package/extension/src/content/runResultActions.js

@@ -107,17 +107,137 @@
       if (!copied) throw new Error('clipboard_copy_failed');
     }
 
-    return Object.freeze({ configureResultActions, projectUndoAvailability });
+    return Object.freeze({ configureResultActions, projectUndoAvailability, splitFlatCompletionReport, projectCompletionMeta, summarizeCompletionMeta });
+  }
+
+
+  const FLAT_REPORT_STATUS_SECTIONS = [
+    { key: 'saveState', prefixes: ['Save:', '保存：'], en: 'Save', zh: '保存' },
+    { key: 'unchangedReason', prefixes: ['Why nothing changed:', '未修改原因：'], en: 'Why nothing changed', zh: '未修改原因' },
+    { key: 'writeResult', prefixes: ['Write result:', '写入结果：'], en: 'Write result', zh: '写入结果' },
+    { key: 'undo', prefixes: ['Undo:', '可撤销：'], en: 'Undo', zh: '可撤销' },
+    { key: 'nextStep', prefixes: ['Next:', '下一步：'], en: 'Next', zh: '下一步' }
+  ];
+
+  function splitFlatCompletionReport(text, tx = value => value) {
+    const raw = typeof text === 'string' ? text : '';
+    if (!raw.trim()) return { body: raw, meta: [] };
+    const bodySections = [], meta = [];
+    for (const section of raw.split(/\n{2,}/)) {
+      const trimmed = section.trim();
+      if (!trimmed) continue;
+      const entry = trimmed.includes('\n') ? null
+        : FLAT_REPORT_STATUS_SECTIONS.find(item => item.prefixes.some(prefix => trimmed.startsWith(prefix)));
+      if (entry) {
+        const prefix = entry.prefixes.find(value => trimmed.startsWith(value));
+        const value = trimmed.slice(prefix.length).trim();
+        if (value) {
+          meta.push({ key: entry.key, label: tx(entry.en, entry.zh), value });
+          continue;
+        }
+      }
+      bodySections.push(trimmed);
+    }
+    return { body: bodySections.join('\n\n'), meta };
+  }
+
+  function projectCompletionMeta(meta, run, options) {
+    const { tx, trackedChangeInFlight, isTrackedChangeLifecycleRun, projectRunSettlement } = options;
+    if (!Array.isArray(meta) || !run) return meta;
+    const undone = run.undoStatus === 'applied' || run.trackedChangeStatus === 'rejected';
+    const rows = undone ? meta.filter(row => row?.key !== 'saveState') : meta;
+    const inFlight = trackedChangeInFlight?.get(run.id);
+    const tracked = isTrackedChangeLifecycleRun(run);
+    const pendingCreatedUndo = tracked && run.trackedChangeStatus === 'needs_review' && run.undoOperations?.some(operation => operation?.undoCreatedFile?.v === 1);
+    let undo;
+    if (run.undoStatus === 'running' || inFlight === 'reject') {
+      undo = tx('Undoing changes...', '正在撤销修改…');
+    } else if (run.undoStatus === 'applied' || (tracked && run.trackedChangeStatus === 'rejected')) {
+      undo = tx('This run\'s changes have been undone.', '本轮修改已撤销。');
+    } else if (tracked && run.trackedChangeStatus === 'accepted') {
+      undo = tx('Changes accepted; undo is no longer available.', '修改已接受，无法再撤销。');
+    } else if (run.undoStatus === 'partial' || pendingCreatedUndo) {
+      undo = hasUndoProgress(run)
+        ? projectRunSettlement(run).canUndo
+          ? tx(pendingCreatedUndo ? 'Some changes were undone; retry the remaining files.' : 'Some changes were undone; remaining changes can still be undone.', pendingCreatedUndo ? '已撤销部分修改，可重试剩余文件。' : '已撤销部分修改，剩余修改仍可撤销。')
+          : tx('Some changes were undone.', '已撤销部分修改。')
+        : projectRunSettlement(run).canUndo
+          ? tx(pendingCreatedUndo ? 'Undo is incomplete; retry the remaining files.' : 'Undo is incomplete; remaining changes can still be undone.', pendingCreatedUndo ? '撤销未完成，可重试剩余文件。' : '撤销未完成，剩余修改仍可撤销。')
+          : tx('Undo is incomplete.', '撤销未完成。');
+    }
+    if (!undo && !run.saveCheck && !run.saveConfirmedAt) return rows;
+    return rows.map(row => row?.key === 'undo' && undo
+      ? { ...row, label: tx('Undo', '撤销'), value: undo }
+      : row?.key === 'saveState' && (run.saveCheck || run.saveConfirmedAt)
+        ? { ...row, label: tx('Save', '保存'), value: run.saveCheck
+          ? tx('Pending confirmation', '待确认') : tx('Saved', '已确认保存') }
+        : row);
+  }
+
+  function hasUndoProgress(run) {
+    const failures = run?.settlement?.failures || run?.settlementFacts?.failures || [];
+    return (Array.isArray(run?.events) ? run.events : []).some(event => {
+      if (!['completed', 'failed'].includes(event?.status) || event.streamRole || ['report', 'guidance', 'stream'].includes(event.kind)) return false;
+      const count = String(event.title || '').match(/^(?:Undo result: (?:undone|rejected) (\d+) (?:item\(s\)|file\(s\)|tracked change\(s\)), skipped \d+(?: item\(s\))?|撤销结果：已(?:撤销|拒绝) (\d+) (?:项|条留痕|个文件)，跳过 \d+ (?:项|条))$/);
+      if (!(Number(count?.[1] || count?.[2]) > 0)) return false;
+      const detail = event.detail || {}, applied = detail.Undone || detail.Rejected || detail['已撤销'] || detail['已拒绝'];
+      const skipped = detail.Skipped || detail['跳过'], path = item => item?.File || item?.['文件'];
+      return Array.isArray(applied) && Array.isArray(skipped) && applied.some(item =>
+        typeof path(item) === 'string' && path(item).trim() && !skipped.some(other => path(other) === path(item))
+        && !(Array.isArray(failures) && failures.some(failure => failure?.code === 'undo_not_verified'
+          && (!failure.file || failure.file === path(item)))));
+    });
+  }
+
+  // Generic reasons say nothing beyond "no files were written", so they stay in
+  // the details. Both locales match because a report keeps its original locale.
+  const GENERIC_UNCHANGED_REASONS = new Set([
+    'No file changes need to sync back to Overleaf.', '没有产生需要同步回 Overleaf 的文件改动。',
+    'No approved file changes remain to sync back to Overleaf.', '没有剩余已确认的文件改动需要同步回 Overleaf。',
+    'This run was Ask mode.', '这轮是只问不改。'
+  ]);
+
+  // One summary line for the meta rows: what was written, whether it can be
+  // undone, and a pending save. The rows themselves stay behind the disclosure,
+  // which opens by itself only when something needs the user's attention.
+  function summarizeCompletionMeta(rows, run, { tx, failed = false, unconfirmed = false } = {}) {
+    const find = key => String(rows.find(row => row?.key === key)?.value || '').trim();
+    const counts = find('writeResult').match(/wrote (\d+) items?, skipped (\d+)|已写入 (\d+) 项，跳过 (\d+) 项/);
+    const wrote = Number(counts?.[1] ?? counts?.[3] ?? 0), skipped = Number(counts?.[2] ?? counts?.[4] ?? 0);
+    const reason = find('unchangedReason');
+    const undone = run?.undoStatus === 'applied' || run?.trackedChangeStatus === 'rejected';
+    const savePending = !undone && (Boolean(run?.saveCheck) || (!run?.saveConfirmedAt && /^(?:Pending|待确认)/.test(find('saveState'))));
+    const pendingCreatedUndo = run?.trackedChangeStatus === 'needs_review'
+      && run.undoOperations?.some(operation => operation?.undoCreatedFile?.v === 1);
+    const facts = [];
+    if (failed) facts.push({ key: 'write', tone: 'fail', text: unconfirmed ? tx('Write not confirmed', '写入结果未确认') : tx('Write incomplete', '写入未完成') });
+    else if (wrote) facts.push({ key: 'write', text: tx(`Wrote ${wrote} item${wrote === 1 ? '' : 's'}`, `已写入 ${wrote} 项`) });
+    else if (reason && !GENERIC_UNCHANGED_REASONS.has(reason)) facts.push({ key: 'write', text: tx('Not written: ', '未写入：') + reason.replace(/[.。]$/, '') });
+    else facts.push({ key: 'write', text: tx('No files written', '未写入文件') });
+    if (skipped) facts.push({ key: 'skip', tone: 'warn', text: tx(`${skipped} skipped`, `跳过 ${skipped} 项`) });
+    const undoable = Number(find('undo').match(/(\d+)/)?.[1] || 0);
+    const undo = run?.undoStatus === 'running' || /^(?:Undoing changes\.\.\.|正在撤销修改…)$/.test(find('undo')) ? tx('Undoing…', '正在撤销…')
+      : run?.undoStatus === 'applied' || run?.trackedChangeStatus === 'rejected' ? tx('Changes undone', '已撤销本轮修改')
+        : run?.trackedChangeStatus === 'accepted' ? tx('Changes accepted', '修改已接受')
+          : pendingCreatedUndo || run?.undoStatus === 'partial'
+            ? (hasUndoProgress(run) ? tx('Partly undone', '已撤销部分修改') : tx('Undo incomplete', '撤销未完成'))
+            : undoable ? tx(`${undoable} undoable`, `可撤销 ${undoable} 项`)
+              : failed ? '' : tx('Nothing to undo', '无可撤销写入');
+    if (undo) facts.push({ key: 'undo', text: undo });
+    if (savePending) facts.push({ key: 'save', tone: 'warn', text: tx('Save pending', '保存待确认') });
+    const attention = failed || skipped > 0;
+    const warnKeys = new Set([...(attention ? ['writeResult', 'nextStep'] : []), ...(savePending ? ['saveState'] : [])]);
+    return { facts, open: attention, warnKeys };
   }
 
   function projectUndoAvailability(run, projectRunSettlement) {
     const payload = run.recoveryPayload && typeof run.recoveryPayload === 'object'
       ? run.recoveryPayload : run;
     if (!Array.isArray(payload.appliedOperations)) return projectRunSettlement(run);
-    // Forward binary writes do not provide a rollback. Filter them only for
+    // Forward creation/asset writes alone do not provide a rollback. Filter them only for
     // display; preserve the canonical settlement and every real recovery field.
     const appliedOperations = payload.appliedOperations.filter(operation =>
-      operation?.type !== 'binary-create' && operation?.type !== 'overwrite-binary');
+      operation?.type !== 'create' && operation?.type !== 'binary-create' && operation?.type !== 'overwrite-binary');
     if (appliedOperations.length === payload.appliedOperations.length) return projectRunSettlement(run);
     return projectRunSettlement({
       ...run,