codex-overleaf-link 2.5.0 → 2.6.0

package/extension/src/content/runController.js

@@ -1,17 +1,29 @@
 (function initCodexOverleafRunController(root, factory) {
   if (typeof module === 'object' && module.exports) {
-    module.exports = factory();
+    module.exports = factory(require('../shared/projectFiles'));
   } else {
-    root.CodexOverleafRunController = factory();
+    root.CodexOverleafRunController = factory(root.CodexOverleafProjectFiles);
   }
-})(typeof window !== 'undefined' ? window : globalThis, function runControllerFactory() {
+})(typeof window !== 'undefined' ? window : globalThis, function runControllerFactory(ProjectFiles) {
   'use strict';
 
   const DEFAULT_EXPECTED_MIRROR_FRESHNESS_MS = 5 * 60 * 1000;
 
+  function captureSessionContext(state = {}) {
+    // This is the prompt projection, not the mutable visible-session alias.
+    const session = state.session;
+    return session ? JSON.parse(JSON.stringify(session)) : null;
+  }
+
+  function isSubmittedComposerUnchanged(submitted, current) {
+    return ['task', 'attachments', 'skillInvocation', 'selectionContext'].every(key =>
+      JSON.stringify(submitted[key] ?? null) === JSON.stringify(current[key] ?? null));
+  }
+
   function buildCodexRunParams({
     currentProjectId,
     state = {},
+    locale = state.locale,
     task,
     project,
     useExistingMirror,
@@ -22,6 +34,7 @@
     customInstructions,
     skillLoadingSettings,
     enabledCodexOverleafSkillIds,
+    enabledCodexLocalSkillIds,
     attachments,
     skillInvocation,
     compileLogContext,
@@ -45,17 +58,21 @@
       otWarmStart: useExistingMirror && otWarmStart ? true : undefined,
       warmStartStrategy: useExistingMirror && otWarmStart ? 'ot-warm-mirror' : undefined,
       focusFiles,
+      focusFilesAreLiteral: true,
       restrictToFocusFiles: restrictToFocusFiles || undefined,
       model: state.model,
       reasoningEffort: state.reasoningEffort,
       speedTier: state.speedTier,
-      locale: state.locale === 'zh' ? 'zh' : 'en',
+      locale: locale === 'zh' ? 'zh' : 'en',
       session: state.session,
       threadId: codexThreadId || undefined,
       customInstructions: normalizedCustomInstructions || undefined,
       loadCodexLocalSkills: skillLoadingSettings?.loadCodexLocalSkills !== false,
       loadCodexOverleafSkills: skillLoadingSettings?.loadCodexOverleafSkills !== false,
       enabledCodexOverleafSkillIds: normalizedEnabledSkillIds,
+      enabledCodexLocalSkillIds: Array.isArray(enabledCodexLocalSkillIds)
+        ? [...new Set(enabledCodexLocalSkillIds.filter(id => typeof id === 'string' && isSafeSkillId(id)))]
+        : undefined,
       skillInvocation: normalizedSkillInvocation || undefined,
       attachments: normalizedAttachments.length ? normalizedAttachments : undefined
     };
@@ -106,13 +123,14 @@
     project = {},
     snapshotWarnings = {},
     focusFiles = [],
+    focusFilesAreLiteral = false,
     isUsableProjectFileContent = defaultIsUsableProjectFileContent
   } = {}) {
     const blocking = Array.isArray(snapshotWarnings.blocking) ? snapshotWarnings.blocking : [];
     if (!blocking.length || !blocking.some(isFullSnapshotWarning)) {
       return false;
     }
-    const normalizedFocusFiles = normalizeFocusFiles(focusFiles);
+    const normalizedFocusFiles = normalizeFocusFiles(focusFiles, focusFilesAreLiteral === true);
     if (!normalizedFocusFiles.length) {
       return false;
     }
@@ -122,10 +140,10 @@
 
     const textFilesByPath = new Map((project.files || [])
       .filter(file => file && typeof file.path === 'string' && typeof file.content === 'string')
-      .map(file => [normalizeFocusPath(file.path), file]));
+      .map(file => [normalizeFocusPath(file.path, true), file]));
 
     return normalizedFocusFiles.every(filePath => {
-      const file = textFilesByPath.get(normalizeFocusPath(filePath));
+      const file = textFilesByPath.get(filePath);
       return file && isUsableProjectFileContent(file.content);
     });
   }
@@ -138,11 +156,11 @@
     return /Full project snapshot was not captured/i.test(String(warning || ''));
   }
 
-  function normalizeFocusFiles(value) {
+  function normalizeFocusFiles(value, literal = false) {
     const seen = new Set();
     const files = [];
     for (const item of Array.isArray(value) ? value : []) {
-      const filePath = normalizeFocusPath(item);
+      const filePath = normalizeFocusPath(item, literal);
       if (!filePath || seen.has(filePath)) {
         continue;
       }
@@ -152,7 +170,8 @@
     return files;
   }
 
-  function normalizeFocusPath(value) {
+  function normalizeFocusPath(value, literal = false) {
+    if (literal) return ProjectFiles.normalizeSafeProjectPath(value);
     return String(value || '')
       .replace(/^@file:/i, '')
       .replace(/\\/g, '/')
@@ -187,19 +206,22 @@
     if (!isSafeSkillId(id)) {
       return null;
     }
-    const title = String(value?.title || 'Skill Installer').trim().slice(0, 80) || 'Skill Installer';
-    if (id === 'skill-installer') {
+    const installer = id === 'skill-installer' && (value?.scope == null || value.scope === 'builtin');
+    const fallbackTitle = installer ? 'Skill Installer' : id;
+    const title = String(value?.title || fallbackTitle).trim().slice(0, 80) || fallbackTitle;
+    if (installer) {
       return { id, title };
     }
-    if (value?.scope !== 'codex-overleaf') {
+    if (!['codex-overleaf', 'codex-local'].includes(value?.scope)) {
       return null;
     }
-    return { id, title, scope: 'codex-overleaf' };
+    return { id, title, scope: value.scope };
   }
 
   function isSafeSkillId(id) {
     return /^[a-zA-Z0-9][a-zA-Z0-9._-]{0,79}$/.test(String(id || ''))
-      && !String(id || '').includes('..');
+      && !String(id || '').includes('..')
+      && !['__proto__', 'prototype', 'constructor'].includes(id);
   }
 
   function normalizeAttachmentName(value) {
@@ -266,6 +288,8 @@
   }
 
   return {
+    captureSessionContext,
+    isSubmittedComposerUnchanged,
     buildCodexRunParams,
     canUseFocusedPartialSnapshot,
     shouldRestrictWritebackToFocus,

package/extension/src/content/runFailureNotice.js

@@ -1,15 +1,14 @@
 (function initRunFailureNotice(root, factory) {
   if (typeof module === 'object' && module.exports) {
-    module.exports = factory();
+    module.exports = factory(require('../shared/failureReasons'));
   } else {
-    root.CodexOverleafModuleRegistry.define('RunFailureNotice', [], factory);
+    root.CodexOverleafModuleRegistry.define('RunFailureNotice', ['FailureReasons'], factory);
   }
-})(typeof window !== 'undefined' ? window : globalThis, function runFailureNoticeFactory() {
+})(typeof window !== 'undefined' ? window : globalThis, function runFailureNoticeFactory(FailureReasons) {
   'use strict';
 
   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) {
@@ -27,18 +26,25 @@
     document: documentRef = globalThis.document } = {}) {
     const notices = new WeakMap();
 
-    function append(report, event = {}, run = {}) {
+    function append(report, event = {}, run = {}, outcomeTarget = null) {
       const projection = typeof projectRunSettlement === 'function' && run
         ? projectRunSettlement(run) : null;
       const failure = projection?.primaryFailure || event.failure;
       if (report.dataset.status === 'cancelled' || CANCEL_CODES.has(failure?.code)) return;
       const facts = run?.settlement || run?.settlementFacts || {};
-      const unconfirmed = REVIEW_CODES.has(failure?.code)
+      const unconfirmed = projection?.requiresWriteReview === true || REVIEW_CODES.has(failure?.code)
         || facts.documentEffect === 'possibly-changed'
         || (facts.evidence?.applied === 'unknown' && facts.evidence?.settled === 'needs-review');
       const partial = facts.evidence?.applied === 'partial' || run?.partialWriteback === true;
       if (!failure && !unconfirmed && !partial && report.dataset.status !== 'failed') return;
 
+      // A quiet outcome replaces the notice's presentation, not its recovery
+      // selection or precedence. Keep the same context for prepareRecovery.
+      if (outcomeTarget) {
+        notices.set(report, { notice: outcomeTarget, unconfirmed, failure, file: safeProjectPath(failure?.file) });
+        return;
+      }
+
       const notice = documentRef.createElement('aside');
       notice.className = 'run-feedback';
       notice.dataset.tone = unconfirmed || partial || failure?.terminalState === 'degraded'
@@ -49,9 +55,14 @@
       heading.textContent = tr(unconfirmed ? 'runFeedbackUnconfirmedTitle'
         : partial ? 'runFeedbackPartialTitle' : 'runFeedbackFailedTitle');
       const message = documentRef.createElement('p');
-      const detail = typeof failure?.userMessage === 'string' ? failure.userMessage : '';
       const file = safeProjectPath(failure?.file);
-      message.textContent = sanitizeText([file, detail].filter(Boolean).join(': ').slice(0, 1000))
+      // Localization is a display projection. Recovery keeps the original
+      // failure and its trusted file, even when historical text yields a path.
+      const display = FailureReasons?.formatFailureReasonForDisplay?.(failure, undefined, key => {
+        const value = tr(key);
+        return value && value !== key ? value : undefined;
+      });
+      message.textContent = sanitizeText((display?.message || [file, failure?.userMessage].filter(Boolean).join(': ')).slice(0, 1000))
         || tr('runFeedbackGeneric');
       notice.append(heading, message);
       if (unconfirmed) {
@@ -74,10 +85,15 @@
       return row.value;
     }
 
-    function prepareRecovery(report, { openFile } = {}) {
+    function getRecoveryContext(report) {
       const info = notices.get(report);
-      const target = info?.notice || report;
-      if (!info?.unconfirmed) return { target, handled: false };
+      return { target: info?.notice || report, failure: info?.failure, unconfirmed: info?.unconfirmed === true, file: info?.file || '' };
+    }
+
+    function prepareRecovery(report, { openFile } = {}) {
+      const info = getRecoveryContext(report);
+      const target = info.target;
+      if (!info.unconfirmed) return { target, handled: false, failure: info.failure };
       const canOpen = Boolean(info.file && typeof openFile === 'function');
       const button = documentRef.createElement('button');
       button.type = 'button';
@@ -100,10 +116,10 @@
         }
       });
       target.append(button);
-      return { target, handled: true };
+      return { target, handled: true, failure: info.failure };
     }
 
-    return Object.freeze({ append, formatMetaValue, prepareRecovery });
+    return Object.freeze({ append, formatMetaValue, getRecoveryContext, prepareRecovery });
   }
 
   function safeProjectPath(value) {

package/extension/src/content/runGuidanceController.js

@@ -2,40 +2,85 @@
   'use strict';
 
   function create(deps = {}) {
+    // Unacknowledged input is a page-local projection. Only confirmed delivery
+    // joins record.events; the durable queue owns refresh/recovery before that.
+    const pending = new Map();
+    let lastTimestamp = 0;
+    const keyOf = target => JSON.stringify([target.sessionId, target.recordId, target.guidanceId]);
+    const sameScope = scope => !scope || ['accountScopeId', 'projectId', 'generation'].every(key => scope[key] === deps.getScope?.()?.[key]);
+    function ownedRecord(target) {
+      if (!target.sessionId || !target.recordId) return null;
+      if (target.sessionCreatedAt !== undefined && deps.getSessionCreatedAt
+        && deps.getSessionCreatedAt(target.sessionId) !== target.sessionCreatedAt) return null;
+      return deps.findRunRecord?.(target.recordId, target.sessionId) || null;
+    }
+    function nextTimestamp() {
+      lastTimestamp = Math.max(Date.now(), lastTimestamp + 1);
+      return new Date(lastTimestamp).toISOString();
+    }
+    function getPending(run) {
+      return [...pending.values()].filter(token => token.target.recordId === run?.id
+        && (!deps.getActiveSessionId || token.target.sessionId === deps.getActiveSessionId())
+        && sameScope(token.scope) && ownedRecord(token.target)).map(token => token.event);
+    }
+    function refresh(target) {
+      const record = ownedRecord(target);
+      if (!record) return null;
+      const view = deps.getCurrentRunView?.();
+      const root = deps.getRunRoot?.(target) || (view?.recordId === target.recordId
+        && view?.sessionId === target.sessionId ? view.root : null);
+      const container = root?.querySelector('[data-run-guidance]');
+      deps.RunGuidanceView?.reconcileGuidance(container,
+        (record.events || []).concat(getPending(record)), deps.tx, { active: record.status === 'running' });
+      return container;
+    }
+    function refreshSettled(target) {
+      try { refresh(target); } catch (error) { deps.onPresentationError?.(error); }
+    }
+    function preview(text, target = {}) {
+      const title = String(text || '').trim();
+      if (!title || !target.guidanceId || !ownedRecord(target)) return null;
+      const token = { target: { ...target }, scope: deps.getScope?.(), event: { title, status: 'steering', kind: 'guidance',
+        guidanceId: target.guidanceId, timestamp: nextTimestamp(), guidancePending: true } };
+      pending.set(keyOf(target), token);
+      try {
+        const container = refresh(target);
+        const row = container?.querySelector?.(`[data-guidance-id="${deps.cssEscape?.(target.guidanceId) || target.guidanceId}"]`);
+        if (row) deps.revealGuidance?.(row);
+        deps.bumpUnreadIfDetached?.();
+      } catch (error) {
+        if (pending.get(keyOf(target)) === token) pending.delete(keyOf(target));
+        try { refresh(target); } catch { /* preserve the original presentation error */ }
+        throw error;
+      }
+      return token;
+    }
+    function clearPreview(token) {
+      if (!token || pending.get(keyOf(token.target)) !== token) return;
+      pending.delete(keyOf(token.target));
+      if (sameScope(token.scope)) refreshSettled(token.target);
+    }
     function upsert(text, target = {}) {
-      const record = deps.findRunRecord?.(target.recordId, target.sessionId);
+      const record = ownedRecord(target);
       const guidanceId = String(target.guidanceId || '').trim();
       if (!record || !guidanceId) return null;
-      const event = {
-        title: String(text || '').trim(),
-        status: target.status || 'queued',
-        kind: 'guidance',
-        guidanceId,
-        timestamp: new Date().toISOString()
-      };
-      const existing = (record.events || []).find(entry => entry.guidanceId === guidanceId);
-      if (!existing) {
-        deps.appendRunEvent?.(event, record);
-        return event;
-      }
-      Object.assign(existing, event, { timestamp: existing.timestamp || event.timestamp });
-      const view = deps.getCurrentRunView?.();
-      if (view?.recordId === target.recordId) {
-        view.root?.querySelector(`[data-guidance-id="${deps.cssEscape(guidanceId)}"]`)
-          ?.replaceWith(deps.renderRunEvent(existing));
-      }
-      return existing;
+      const existing = (record.events || []).find(entry => entry.kind === 'guidance' && entry.guidanceId === guidanceId);
+      const event = { title: String(text || '').trim(), status: target.status || 'completed', kind: 'guidance', guidanceId,
+        timestamp: existing?.timestamp || target.timestamp || pending.get(keyOf(target))?.event.timestamp || nextTimestamp() };
+      if (existing) Object.assign(existing, event);
+      else record.events = [...(record.events || []), event].slice(-(deps.maxRunEvents || 300));
+      // A late ACK still belongs to the captured run, even if another run is
+      // now active. The coordinator saves it together with queue removal.
+      deps.onRecordChanged?.(target);
+      refreshSettled(target);
+      return existing || event;
     }
-
     function remove(guidanceId, target = {}) {
-      const record = deps.findRunRecord?.(target.recordId, target.sessionId);
+      const record = ownedRecord(target);
       if (!record || !guidanceId) return false;
       const before = (record.events || []).length;
       record.events = (record.events || []).filter(event => event.guidanceId !== guidanceId);
-      const view = deps.getCurrentRunView?.();
-      if (view?.recordId === target.recordId) {
-        view.root?.querySelector(`[data-guidance-id="${deps.cssEscape(guidanceId)}"]`)?.remove();
-      }
+      refreshSettled(target);
       return record.events.length !== before;
     }
 
@@ -64,7 +109,7 @@
       return true;
     }
 
-    return { upsert, remove, settleView, appendToView };
+    return { preview, clearPreview, getPending, upsert, remove, settleView, appendToView };
   }
 
   window.CodexOverleafRunGuidanceController = { create };

package/extension/src/content/runGuidanceView.js

@@ -26,23 +26,72 @@
     const row = document.createElement('div');
     row.className = 'run-guidance-message run-user-message';
     row.dataset.kind = 'guidance';
-    row.dataset.status = event.status || 'completed';
-    if (event.guidanceId) {
-      row.dataset.guidanceId = event.guidanceId;
-    }
     row.setAttribute('role', 'group');
-    row.setAttribute('aria-label', tx('Follow-up guidance', '\u540e\u7eed\u5f15\u5bfc'));
-
     const text = document.createElement('div');
     text.className = 'run-guidance-text';
-    text.textContent = guidanceText;
-
-    row.append(text);
+    const label = document.createElement('div');
+    label.className = 'run-guidance-label';
+    row.append(text, label);
+    updateGuidanceMessage(row, event, guidanceText, tx);
     return row;
   }
 
+  function updateGuidanceMessage(row, event, guidanceText, tx, { active = true } = {}) {
+    row.dataset.status = event.status || 'completed';
+    if (event.guidanceId) row.dataset.guidanceId = event.guidanceId;
+    row.dataset.guidanceTimestamp = event.timestamp || '';
+    const label = tx('Follow-up guidance', '补充指令');
+    const sending = (active || event.guidancePending === true) && ['queued', 'steering'].includes(event.status);
+    const text = row.querySelector('.run-guidance-text');
+    if (text.textContent !== guidanceText) text.textContent = guidanceText;
+    const status = row.querySelector('.run-guidance-label');
+    const statusText = label + (sending ? tx(' · Sending…', ' · 发送中…') : '');
+    if (status.textContent !== statusText) status.textContent = statusText;
+    row.setAttribute('aria-label', statusText);
+  }
+
+  // Stored events and the controller's in-flight projection share a container.
+  // Confirmation updates the same row; removed previews leave no stale bubble.
+  function reconcileGuidance(container, events, tx, options = {}) {
+    if (!container) return;
+    const completedLegacy = new Set(events.filter(event => !event.guidanceId && event.status === 'completed')
+      .map(getGuidanceText).filter(Boolean));
+    const entries = new Map();
+    for (const [index, event] of events.entries()) {
+      const text = getGuidanceText(event);
+      if (!text || (!event.guidanceId && event.status === 'queued' && completedLegacy.has(text))) continue;
+      const key = event.guidanceId ? 'id:' + event.guidanceId : 'legacy:' + index;
+      const previous = entries.get(key);
+      if (previous && event.guidancePending === true && previous.event.guidancePending !== true) continue;
+      entries.set(key, { key, event: previous ? { ...event, timestamp: previous.event.timestamp || event.timestamp } : event, text });
+    }
+    const existing = new Map();
+    for (const row of [...container.children]) {
+      const key = row.dataset.guidanceId ? 'id:' + row.dataset.guidanceId : row.dataset.guidanceKey;
+      if (!key || existing.has(key)) { row.remove(); continue; }
+      existing.set(key, row);
+    }
+    for (const [key, row] of existing) if (!entries.has(key)) row.remove();
+    const known = [...entries.values()].filter(entry => Number.isFinite(Date.parse(entry.event.timestamp)))
+      .sort((a, b) => Date.parse(a.event.timestamp) - Date.parse(b.event.timestamp));
+    let datedIndex = 0;
+    // Keep legacy rows without timestamps in their event-order slots.
+    const ordered = [...entries.values()].map(entry => Number.isFinite(Date.parse(entry.event.timestamp)) ? known[datedIndex++] : entry);
+    let cursor = container.firstChild;
+    for (const entry of ordered) {
+      const row = existing.get(entry.key) || renderGuidanceMessage(entry.event, entry.text, tx);
+      row.dataset.guidanceKey = entry.key;
+      if (entry.event.guidancePending === true) row.dataset.guidancePending = 'true';
+      else delete row.dataset.guidancePending;
+      updateGuidanceMessage(row, entry.event, entry.text, tx, options);
+      if (row !== cursor) container.insertBefore(row, cursor);
+      cursor = row.nextSibling;
+    }
+  }
+
   window.CodexOverleafRunGuidanceView = {
     getGuidanceText,
-    renderGuidanceMessage
+    renderGuidanceMessage,
+    reconcileGuidance
   };
 })();

package/extension/src/content/runPresence.js

@@ -39,6 +39,10 @@
   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"/>',
+    minus: '<circle cx="8" cy="8" r="6"/><path d="M5 8h6"/>',
+    half: '<circle cx="6" cy="6" r="5"/><path d="M6 1a5 5 0 0 0 0 10z" fill="currentColor" stroke="none"/>',
+    written: '<path d="m2.4 6.3 2.4 2.4 4.8-5.2" stroke-width="1.5"/>',
+    skipped: '<path d="m3 3 6 6M9 3 3 9" stroke-width="1.5"/>',
     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"/>'
@@ -49,7 +53,8 @@
   })[char]);
 
   function icon(name, className = 'codex-glyph') {
-    return '<svg class="' + className + '" viewBox="0 0 16 16" aria-hidden="true" focusable="false">'
+    const size = ['half', 'written', 'skipped'].includes(name) ? 12 : 16;
+    return '<svg class="' + className + '" viewBox="0 0 ' + size + ' ' + size + '" aria-hidden="true" focusable="false">'
       + (ICONS[name] || ICONS.check) + '</svg>';
   }
 
@@ -103,14 +108,16 @@
       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>');
-      }
+      // Show only nonzero sides; a red "−0" reads as a problem that isn't there.
+      const counts = [];
+      if (Number(facts.added) > 0) counts.push('<span class="run-summary-add">+' + Number(facts.added) + '</span>');
+      if (Number(facts.removed) > 0) counts.push('<span class="run-summary-del">−' + Number(facts.removed) + '</span>');
+      if (counts.length) parts.push('<span>' + counts.join(' ') + '</span>');
     } else if (facts.steps > 0) {
-      parts.push('<span>' + escapeHtml(tx(facts.steps + ' steps', facts.steps + ' 步')) + '</span>');
+      parts.push('<span>' + escapeHtml(tx(facts.steps + (facts.steps === 1 ? ' step' : ' steps'), facts.steps + ' 步')) + '</span>');
     }
     if (facts.compiled) parts.push('<span>' + escapeHtml(tx('compiled', '已编译')) + '</span>');
+    if (facts.compileChip) parts.push('<span class="run-summary-compile-chip">' + escapeHtml(facts.compileChip) + '</span>');
     if (facts.firstCompile) {
       parts.push('<span class="run-summary-qed">' + escapeHtml(tx('Q.E.D. — first clean compile', 'Q.E.D. · 首次编译通过')) + '</span>');
     }
@@ -253,8 +260,11 @@
       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 if (['failed', 'not-started', 'not-started-cancelled'].includes(facts.kind)) {
+        el.innerHTML = icon(facts.kind === 'not-started-cancelled' ? 'minus' : 'alert') + '<span>' + escapeHtml(facts.text) + '</span>';
+      } else if (['didnt-finish', 'partly-written', 'not-written', 'check-overleaf'].includes(facts.kind)) {
+        el.innerHTML = icon(facts.kind === 'check-overleaf' ? 'alert' : facts.kind === 'partly-written' ? 'half' : 'minus') + '<span>' + escapeHtml(facts.text) + '</span>'
+          + (Number.isFinite(facts.elapsedMs) ? '<span class="run-summary-sep">·</span><span>' + escapeHtml(formatElapsed(facts.elapsedMs)) + '</span>' : '');
       } else {
         el.textContent = facts.text || '';
       }