codex-overleaf-link 2.1.5 → 2.2.0

package/extension/src/shared/storageMigration.js

@@ -8,6 +8,9 @@
   'use strict';
 
   var PREFS_KEY = 'codexOverleafPrefs';
+  var SESSION_TOMBSTONES_KEY = 'codexOverleafSessionTombstones';
+  var SESSION_TOMBSTONE_ENTRY_PREFIX = 'codexOverleafSessionTombstone:v2:';
+  var MAX_DELETED_SESSION_IDS_PER_PROJECT = 100;
   var CUSTOM_INSTRUCTIONS_MAX_CHARS = 12000;
   var PROJECT_PREF_KEY_MAX_CHARS = 160;
 
@@ -15,15 +18,20 @@
     var StorageDb = (typeof window !== 'undefined' && window.CodexOverleafStorageDb)
       ? window.CodexOverleafStorageDb
       : require('./storageDb');
-    return chrome.storage.local.get([PREFS_KEY, legacyStorageKey]).then(function (stored) {
+    return chrome.storage.local.get(null).then(function (stored) {
       var prefs = normalizePrefs(stored[PREFS_KEY] || {});
+      var tombstones = collectSessionTombstones(stored);
+      var deletedSessionIds = getDeletedSessionIds(tombstones, projectId);
       var schemaVersion = prefs.storageSchemaVersion || 0;
 
       if (schemaVersion >= StorageDb.TARGET_SCHEMA_VERSION) {
         var activeSessionByProject = prefs.activeSessionByProject || {};
         var activeSessionId = activeSessionByProject[projectId] || '';
         return StorageDb.getAllByIndex('sessions', 'projectId', projectId).then(function (sessions) {
-          return { prefs: prefs, sessions: sessions, activeSessionId: activeSessionId, migrated: false };
+          var visibleSessions = sessions.filter(function (session) {
+            return deletedSessionIds.indexOf(session && session.id) === -1;
+          });
+          return { prefs: prefs, sessions: visibleSessions, activeSessionId: activeSessionId, migrated: false };
         });
       }
 
@@ -35,6 +43,7 @@
       for (var i = 0; i < legacySessions.length; i++) {
         var legacy = legacySessions[i];
         if (!legacy || !legacy.id) { continue; }
+        if (deletedSessionIds.indexOf(legacy.id) !== -1) { continue; }
         var record = StorageDb.buildSessionRecord(
           buildLegacySessionRecordInput(projectId, legacyBlob, legacy)
         );
@@ -101,6 +110,112 @@
     });
   }
 
+  function normalizeDeletedSessionIdsByProject(value) {
+    var result = {};
+    if (!value || typeof value !== 'object' || Array.isArray(value)) {
+      return result;
+    }
+    Object.keys(value).forEach(function (rawProjectId) {
+      var projectId = normalizeProjectPrefKey(rawProjectId);
+      if (!projectId || !Array.isArray(value[rawProjectId])) {
+        return;
+      }
+      var seen = {};
+      var ids = value[rawProjectId].map(function (id) {
+        return normalizeTextField(id, PROJECT_PREF_KEY_MAX_CHARS);
+      }).filter(function (id) {
+        if (!id || seen[id]) { return false; }
+        seen[id] = true;
+        return true;
+      }).slice(-MAX_DELETED_SESSION_IDS_PER_PROJECT);
+      if (ids.length) {
+        result[projectId] = ids;
+      }
+    });
+    return result;
+  }
+
+  function getDeletedSessionIds(tombstones, projectId) {
+    var normalized = normalizeDeletedSessionIdsByProject(tombstones);
+    var key = normalizeProjectPrefKey(projectId);
+    return key && Array.isArray(normalized[key]) ? normalized[key].slice() : [];
+  }
+
+  function loadSessionTombstones() {
+    return chrome.storage.local.get(null).then(function (stored) {
+      return collectSessionTombstones(stored);
+    });
+  }
+
+  function addSessionTombstones(projectId, sessionIds) {
+    var key = normalizeProjectPrefKey(projectId);
+    if (!key) {
+      return loadSessionTombstones();
+    }
+    var incoming = (Array.isArray(sessionIds) ? sessionIds : [])
+      .map(function (id) { return normalizeTextField(id, PROJECT_PREF_KEY_MAX_CHARS); })
+      .filter(Boolean);
+    if (!incoming.length) {
+      return loadSessionTombstones();
+    }
+    var deletedAt = new Date().toISOString();
+    var payload = {};
+    incoming.forEach(function (sessionId) {
+      payload[buildSessionTombstoneEntryKey(key, sessionId)] = {
+        projectId: key,
+        sessionId: sessionId,
+        deletedAt: deletedAt
+      };
+    });
+    return chrome.storage.local.set(payload)
+      .then(function () { return pruneSessionTombstoneEntries(key); })
+      .then(loadSessionTombstones);
+  }
+
+  function collectSessionTombstones(stored) {
+    var tombstones = normalizeDeletedSessionIdsByProject(
+      stored && stored[SESSION_TOMBSTONES_KEY] || {}
+    );
+    Object.keys(stored || {}).forEach(function (storageKey) {
+      if (storageKey.indexOf(SESSION_TOMBSTONE_ENTRY_PREFIX) !== 0) {
+        return;
+      }
+      var entry = stored[storageKey];
+      var projectId = normalizeProjectPrefKey(entry && entry.projectId);
+      var sessionId = normalizeTextField(entry && entry.sessionId, PROJECT_PREF_KEY_MAX_CHARS);
+      if (!projectId || !sessionId) {
+        return;
+      }
+      tombstones[projectId] = (tombstones[projectId] || [])
+        .filter(function (id) { return id !== sessionId; })
+        .concat(sessionId)
+        .slice(-MAX_DELETED_SESSION_IDS_PER_PROJECT);
+    });
+    return normalizeDeletedSessionIdsByProject(tombstones);
+  }
+
+  function buildSessionTombstoneEntryKey(projectId, sessionId) {
+    return SESSION_TOMBSTONE_ENTRY_PREFIX +
+      encodeURIComponent(projectId) + ':' +
+      encodeURIComponent(sessionId);
+  }
+
+  function pruneSessionTombstoneEntries(projectId) {
+    return chrome.storage.local.get(null).then(function (stored) {
+      var entries = Object.keys(stored || {}).filter(function (storageKey) {
+        var entry = stored[storageKey];
+        return storageKey.indexOf(SESSION_TOMBSTONE_ENTRY_PREFIX) === 0 &&
+          normalizeProjectPrefKey(entry && entry.projectId) === projectId;
+      }).sort(function (leftKey, rightKey) {
+        var left = String(stored[leftKey] && stored[leftKey].deletedAt || '');
+        var right = String(stored[rightKey] && stored[rightKey].deletedAt || '');
+        return left === right ? leftKey.localeCompare(rightKey) : left.localeCompare(right);
+      });
+      var obsolete = entries.slice(0, Math.max(0, entries.length - MAX_DELETED_SESSION_IDS_PER_PROJECT));
+      return obsolete.length ? chrome.storage.local.remove(obsolete) : undefined;
+    });
+  }
+
   function normalizePrefs(prefs) {
     var source = prefs && typeof prefs === 'object' ? prefs : {};
     return Object.assign({}, source, {
@@ -162,8 +277,13 @@
 
   return {
     PREFS_KEY: PREFS_KEY,
+    SESSION_TOMBSTONES_KEY: SESSION_TOMBSTONES_KEY,
     runMigrationIfNeeded: runMigrationIfNeeded,
     savePrefs: savePrefs,
-    loadPrefs: loadPrefs
+    loadPrefs: loadPrefs,
+    loadSessionTombstones: loadSessionTombstones,
+    addSessionTombstones: addSessionTombstones,
+    getDeletedSessionIds: getDeletedSessionIds,
+    normalizeDeletedSessionIdsByProject: normalizeDeletedSessionIdsByProject
   };
 });

package/extension/src/shared/storageRunActions.js

@@ -101,9 +101,42 @@
     };
   }
 
+  function compactStructuredEventValue(value, options, depth) {
+    var config = options || {};
+    var d = depth || 0;
+    if (typeof value === 'string') {
+      return typeof config.normalizeString === 'function' ? config.normalizeString(value) : value;
+    }
+    if (value === null || typeof value === 'number' || typeof value === 'boolean') return value;
+    if (d > 6 || typeof value !== 'object') return null;
+    if (Array.isArray(value)) {
+      return value.slice(0, 32).map(function (item) {
+        return compactStructuredEventValue(item, config, d + 1);
+      });
+    }
+    var out = {};
+    var keys = Object.keys(value).slice(0, 32);
+    for (var i = 0; i < keys.length; i++) {
+      out[keys[i]] = compactStructuredEventValue(value[keys[i]], config, d + 1);
+    }
+    return out;
+  }
+
+  function hashString(value) {
+    var hash = 2166136261;
+    var text = String(value || '');
+    for (var i = 0; i < text.length; i++) {
+      hash ^= text.charCodeAt(i);
+      hash = Math.imul(hash, 16777619);
+    }
+    return (hash >>> 0).toString(16).padStart(8, '0');
+  }
+
   return {
+    compactStructuredEventValue: compactStructuredEventValue,
     compactRunsForStorage: compactRunsForStorage,
     compactRunActionPayload: compactRunActionPayload,
-    compactProviderSnapshot: compactProviderSnapshot
+    compactProviderSnapshot: compactProviderSnapshot,
+    hashString: hashString
   };
 });

package/extension/src/shared/updateConsent.js

@@ -18,6 +18,7 @@
     'waiting_for_idle',
     'applying',
     'awaiting_health',
+    'rolling_back',
     'committed',
     'rolled_back',
     'failed'
@@ -27,7 +28,8 @@
     'staged',
     'waiting_for_idle',
     'applying',
-    'awaiting_health'
+    'awaiting_health',
+    'rolling_back'
   ]);
   const TERMINAL_STATES = new Set(['committed', 'rolled_back', 'failed']);
   const QUIET_FAILURE_CODES = new Set([
@@ -44,6 +46,7 @@
     waiting_for_idle: { value: 65, determinate: true, phase: 'waiting' },
     applying: { value: 82, determinate: false, phase: 'applying' },
     awaiting_health: { value: 94, determinate: false, phase: 'health' },
+    rolling_back: { value: 94, determinate: false, phase: 'rollback' },
     committed: { value: 100, determinate: true, phase: 'committed' },
     rolled_back: { value: 94, determinate: true, phase: 'rolled_back' },
     failed: { value: 0, determinate: true, phase: 'failed' }
@@ -63,8 +66,12 @@
       blocker: blockers[0] || '',
       blockers,
       transactionId: safeId(value.transactionId),
+      initiatedBy: ['automatic', 'manual'].includes(value.initiatedBy) ? value.initiatedBy : '',
       lastCheckedAt: finiteNumber(value.lastCheckedAt),
       stagedAt: finiteNumber(value.stagedAt),
+      phaseStartedAt: finiteNumber(value.phaseStartedAt),
+      deadlineAt: finiteNumber(value.deadlineAt),
+      heartbeatAt: finiteNumber(value.heartbeatAt),
       postponeUntil: finiteNumber(value.postponeUntil),
       code: safeToken(value.code),
       message: String(value.message || '').replace(/\s+/g, ' ').trim().slice(0, 300)
@@ -96,7 +103,11 @@
     const execution = EXECUTION_STATES.has(state.state);
     const available = state.state === 'update_available' && newer;
     const progress = getProgressModel(state);
-    const quietFailure = state.state === 'failed' && QUIET_FAILURE_CODES.has(state.code);
+    const quietFailure = state.state === 'failed' &&
+      state.initiatedBy !== 'manual' &&
+      QUIET_FAILURE_CODES.has(state.code);
+    const visibleFailure = state.state === 'failed' &&
+      (state.initiatedBy === 'manual' || (!quietFailure && newer));
 
     return {
       state,
@@ -112,7 +123,7 @@
       snoozed,
       execution,
       showPanel: (available && !snoozed) || execution || state.state === 'rolled_back' ||
-        (state.state === 'failed' && !quietFailure && newer),
+        visibleFailure,
       badge: getBadge(state, { available, snoozed }),
       actions: {
         check: ['idle', 'committed', 'rolled_back', 'failed'].includes(state.state),
@@ -135,7 +146,7 @@
   }
 
   function getBadge(state, flags) {
-    if (state.state === 'applying' || state.state === 'awaiting_health') {
+    if (state.state === 'applying' || state.state === 'awaiting_health' || state.state === 'rolling_back') {
       return { text: '...', color: '#3578bd' };
     }
     if (state.state === 'failed' || state.state === 'rolled_back') {

package/extension/styles/panel.css

@@ -2,6 +2,136 @@
   --codex-overleaf-panel-width: 380px;
 }
 
+/* Rich response geometry is shared by streaming and settled output. Repeated
+   class selectors intentionally outrank older component-local declarations. */
+#codex-overleaf-panel .run-stream-text.run-stream-text,
+#codex-overleaf-panel .run-final-answer.run-final-answer {
+  min-width: 0;
+  max-width: 100%;
+  color: var(--tl-fg-2);
+  font-size: 14px;
+  line-height: 1.6;
+  overflow-wrap: anywhere;
+  word-break: normal;
+}
+
+#codex-overleaf-panel :is(.run-stream-text, .run-final-answer) > :first-child {
+  margin-top: 0;
+}
+
+#codex-overleaf-panel :is(.run-stream-text, .run-final-answer) > :last-child {
+  margin-bottom: 0;
+}
+
+#codex-overleaf-panel :is(.run-stream-text, .run-final-answer) p {
+  margin: 0.58em 0;
+}
+
+#codex-overleaf-panel :is(.run-stream-text, .run-final-answer) :is(h1, h2, h3, h4, h5, h6) {
+  margin: 1.05em 0 0.45em;
+  color: var(--tl-fg-1);
+  font-weight: 720;
+  line-height: 1.3;
+}
+
+#codex-overleaf-panel :is(.run-stream-text, .run-final-answer) h1 { font-size: 1.35em; }
+#codex-overleaf-panel :is(.run-stream-text, .run-final-answer) h2 { font-size: 1.22em; }
+#codex-overleaf-panel :is(.run-stream-text, .run-final-answer) h3 { font-size: 1.12em; }
+#codex-overleaf-panel :is(.run-stream-text, .run-final-answer) :is(h4, h5, h6) { font-size: 1em; }
+
+#codex-overleaf-panel :is(.run-stream-text, .run-final-answer) :is(ul, ol) {
+  margin: 0.55em 0;
+  padding-inline-start: 1.55em;
+}
+
+#codex-overleaf-panel :is(.run-stream-text, .run-final-answer) :is(ul, ol) :is(ul, ol) {
+  margin: 0.2em 0;
+}
+
+#codex-overleaf-panel :is(.run-stream-text, .run-final-answer) li {
+  margin: 0.2em 0;
+}
+
+#codex-overleaf-panel :is(.run-stream-text, .run-final-answer) .run-markdown-quote {
+  margin: 0.7em 0;
+  padding: 0.12em 0 0.12em 0.9em;
+  border-inline-start: 3px solid var(--tl-accent, #79b8f2);
+  color: var(--tl-fg-3);
+}
+
+#codex-overleaf-panel :is(.run-stream-text, .run-final-answer) .run-markdown-table {
+  width: 100%;
+  margin: 0.75em 0;
+  border-collapse: collapse;
+  font-size: 0.94em;
+}
+
+#codex-overleaf-panel :is(.run-stream-text, .run-final-answer) .run-markdown-table :is(th, td) {
+  padding: 0.42em 0.58em;
+  border: 1px solid var(--tl-border);
+  text-align: start;
+  vertical-align: top;
+}
+
+#codex-overleaf-panel :is(.run-stream-text, .run-final-answer) .run-markdown-table th {
+  background: var(--tl-surface-2);
+  color: var(--tl-fg-1);
+  font-weight: 700;
+}
+
+#codex-overleaf-panel :is(.run-stream-text, .run-final-answer) .is-align-center { text-align: center; }
+#codex-overleaf-panel :is(.run-stream-text, .run-final-answer) .is-align-right { text-align: right; }
+#codex-overleaf-panel :is(.run-stream-text, .run-final-answer) .is-align-left { text-align: left; }
+
+#codex-overleaf-panel :is(.run-stream-text, .run-final-answer) hr {
+  margin: 1em 0;
+  border: 0;
+  border-top: 1px solid var(--tl-border);
+}
+
+#codex-overleaf-panel .run-math--display.run-math--display {
+  display: block;
+  max-width: 100%;
+  margin: 14px 0;
+  padding: 2px 0 5px;
+  overflow-x: auto;
+  overflow-y: hidden;
+  scrollbar-width: thin;
+}
+
+#codex-overleaf-panel :is(.run-stream-text, .run-final-answer) .katex-display {
+  margin: 0;
+}
+
+#codex-overleaf-panel :is(.run-stream-text, .run-final-answer) .katex .text.text {
+  font-family: KaTeX_Main, "Times New Roman", serif !important;
+}
+
+#codex-overleaf-panel .codex-custom-instructions-panel .codex-custom-instructions-head {
+  display: grid;
+  grid-template-columns: 24px minmax(0, 1fr);
+  gap: 10px;
+  align-items: start;
+  justify-content: initial;
+}
+
+#codex-overleaf-panel .codex-custom-instructions-panel .codex-custom-instructions-head > div {
+  min-width: 0;
+}
+
+#codex-overleaf-panel .codex-project-settings-panel .codex-provider-settings-entry {
+  display: grid;
+  grid-template-columns: minmax(0, 1fr);
+  gap: 12px;
+  align-items: stretch;
+}
+
+#codex-overleaf-panel .codex-project-settings-panel .codex-provider-settings-entry .codex-set-btn,
+#codex-overleaf-panel .codex-project-settings-panel [data-update-settings] button {
+  width: 100%;
+  justify-content: center;
+}
+
 /* v2.1 provider profiles: detailed configuration lives in a viewport modal. */
 .codex-provider-settings-entry {
   display: flex;
@@ -2181,17 +2311,40 @@
   min-width: 0;
 }
 
-#codex-overleaf-panel .run-prompt {
+#codex-overleaf-panel .run-prompt,
+#codex-overleaf-panel .run-guidance-message {
   box-sizing: border-box;
+  width: fit-content;
+  max-width: 100%;
+  margin-left: auto;
   border: 1px solid var(--tl-border-strong);
   border-radius: 8px;
   background: var(--tl-surface-1);
   color: var(--tl-fg-1);
   padding: 7px 9px;
   white-space: pre-wrap;
+  overflow-wrap: anywhere;
   word-break: break-word;
 }
 
+#codex-overleaf-panel .run-guidance-list:empty {
+  display: none;
+}
+
+#codex-overleaf-panel .run-guidance-message {
+  display: block;
+  border-top: 2px solid var(--tl-accent, #55b9f3);
+  margin: 7px 0 4px auto;
+  animation: tl-slide-in 140ms ease-out;
+}
+
+#codex-overleaf-panel .run-guidance-text {
+  min-width: 0;
+  color: var(--tl-fg-1);
+  white-space: pre-wrap;
+  overflow-wrap: anywhere;
+}
+
 #codex-overleaf-panel .run-turn-meta {
   display: flex;
   align-items: center;
@@ -2301,6 +2454,12 @@
   margin-top: 2px;
 }
 
+/* The process disclosure owns machine activity. User Guidance messages live
+   beside the prompt, outside this collapsible activity region. */
+#codex-overleaf-panel .run-process:not([open]) + .run-activity-list {
+  display: none;
+}
+
 #codex-overleaf-panel .run-activity {
   display: grid;
   grid-template-columns: 14px minmax(0, 1fr);
@@ -2475,30 +2634,55 @@
 }
 
 #codex-overleaf-panel .run-math {
-  max-width: 100%;
   color: inherit;
-  font-size: 1.02em;
+  font-size: 1em;
 }
 
 #codex-overleaf-panel .run-math--inline {
-  display: inline-block;
-  overflow-x: auto;
-  overflow-y: hidden;
-  vertical-align: -0.15em;
+  display: inline;
+  max-width: none;
+  overflow: visible;
+  vertical-align: baseline;
+  white-space: nowrap;
+}
+
+#codex-overleaf-panel .run-math--inline .katex {
+  display: inline;
+  overflow-wrap: normal;
+  word-break: normal;
+  white-space: nowrap;
 }
 
 #codex-overleaf-panel .run-math--display {
+  box-sizing: border-box;
   display: block;
+  width: 100%;
+  max-width: 100%;
   overflow-x: auto;
   overflow-y: hidden;
-  margin: 8px 0;
-  padding: 2px 0 4px;
+  margin: 10px 0;
+  padding: 4px 2px 7px;
+  overscroll-behavior-inline: contain;
+  scrollbar-width: thin;
 }
 
 #codex-overleaf-panel .run-math--display .katex-display {
-  min-width: max-content;
+  box-sizing: border-box;
+  width: max-content;
+  min-width: 100%;
   margin: 0;
-  text-align: left;
+  text-align: center;
+}
+
+#codex-overleaf-panel .run-math .katex {
+  overflow-wrap: normal;
+  word-break: normal;
+}
+
+#codex-overleaf-panel .run-math .katex .text,
+#codex-overleaf-panel .run-math .katex .text * {
+  font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", sans-serif;
+  font-size: 0.94em;
 }
 
 #codex-overleaf-panel .run-math--fallback {
@@ -3498,21 +3682,16 @@
   transition: background 120ms ease, filter 120ms ease;
 }
 
-#codex-overleaf-panel .codex-composer-toolbar [data-run]:hover {
-  filter: brightness(1.1);
-}
-
-#codex-overleaf-panel[data-running="true"] .codex-composer-toolbar [data-run] {
+#codex-overleaf-panel .codex-composer-toolbar [data-run][data-action="cancel"] {
   color: transparent;
 }
 
-/* While running, the button is the cancel control — hovering signals "stop". */
-#codex-overleaf-panel[data-running="true"] .codex-composer-toolbar [data-run]:hover {
+#codex-overleaf-panel .codex-composer-toolbar [data-run][data-action="cancel"]:hover {
   background: var(--tl-fail);
   filter: none;
 }
 
-#codex-overleaf-panel[data-running="true"] .codex-composer-toolbar [data-run]::after {
+#codex-overleaf-panel .codex-composer-toolbar [data-run][data-action="cancel"]::after {
   content: "";
   position: absolute;
   top: 50%;
@@ -3523,8 +3702,12 @@
   border: 2px solid rgba(255, 255, 255, 0.35);
   border-top-color: #ffffff;
   border-radius: 50%;
-  animation: codex-run-spin 800ms linear infinite;
   transform: translate(-50%, -50%);
+  animation: codex-run-spin 800ms linear infinite;
+}
+
+#codex-overleaf-panel .codex-composer-toolbar [data-run]:hover {
+  filter: brightness(1.1);
 }
 
 @keyframes codex-run-spin {
@@ -3533,6 +3716,106 @@
   }
 }
 
+#codex-overleaf-panel .codex-pending-inputs {
+  display: grid;
+  gap: 6px;
+  padding: 0 6px 7px;
+}
+
+#codex-overleaf-panel .codex-pending-inputs[hidden] {
+  display: none;
+}
+
+#codex-overleaf-panel .codex-pending-input {
+  display: grid;
+  grid-template-columns: minmax(0, 1fr) auto;
+  align-items: center;
+  gap: 8px;
+  min-width: 0;
+  padding: 8px 9px;
+  border: 1px solid var(--tl-border);
+  border-radius: 9px;
+  background: color-mix(in srgb, var(--tl-surface-1) 86%, var(--tl-accent) 14%);
+}
+
+#codex-overleaf-panel .codex-pending-input[data-status="paused"] {
+  background: color-mix(in srgb, var(--tl-surface-1) 90%, var(--tl-warn) 10%);
+}
+
+#codex-overleaf-panel .codex-pending-input-copy {
+  display: grid;
+  min-width: 0;
+  gap: 2px;
+}
+
+#codex-overleaf-panel .codex-pending-input-status {
+  color: var(--tl-fg-3);
+  font-size: 10px;
+  font-weight: 700;
+  letter-spacing: 0.06em;
+  text-transform: uppercase;
+}
+
+#codex-overleaf-panel .codex-pending-input-text {
+  color: var(--tl-fg-1);
+  font-size: 12px;
+  line-height: 1.35;
+  overflow-wrap: anywhere;
+  white-space: pre-wrap;
+}
+
+#codex-overleaf-panel .codex-pending-input-actions {
+  display: inline-flex;
+  gap: 4px;
+}
+
+#codex-overleaf-panel .codex-pending-input-actions button {
+  min-height: 24px;
+  padding: 0 8px;
+  border-radius: 6px;
+  color: var(--tl-fg-2);
+  background: var(--tl-surface-2);
+  font-size: 11px;
+}
+
+#codex-overleaf-panel .codex-pending-input-actions button:hover {
+  color: var(--tl-fg-1);
+  background: var(--tl-hover);
+}
+
+#codex-overleaf-panel .codex-pending-input-actions button:disabled {
+  opacity: 0.45;
+}
+
+#codex-overleaf-panel .codex-pending-input-actions .codex-pending-input-icon {
+  display: inline-grid;
+  place-items: center;
+  width: 26px;
+  min-width: 26px;
+  min-height: 26px;
+  padding: 0;
+  border-color: transparent;
+  background: transparent;
+}
+
+#codex-overleaf-panel .codex-pending-input-icon svg {
+  width: 16px;
+  height: 16px;
+  fill: none;
+  stroke: currentColor;
+  stroke-width: 1.6;
+  stroke-linecap: round;
+  stroke-linejoin: round;
+}
+
+#codex-overleaf-panel .codex-pending-input-icon[data-action="guide"]:hover {
+  color: var(--tl-accent);
+}
+
+#codex-overleaf-panel .codex-pending-input-icon[data-action="remove"]:hover {
+  color: var(--tl-fail);
+}
+
 #codex-overleaf-panel .codex-composer-toolbar [data-add-context][data-active="true"],
 #codex-overleaf-panel .codex-composer-toolbar [data-add-context][data-has-focus="true"] {
   background: var(--tl-hover);
@@ -4739,6 +5022,22 @@
   text-overflow: ellipsis;
 }
 
+#codex-overleaf-panel .codex-update-notice-recovery {
+  margin-top: 5px;
+  color: var(--tl-fg-2, #d5dad6);
+  font-size: 10.5px;
+  font-weight: 700;
+}
+
+#codex-overleaf-panel .codex-update-notice-command {
+  display: block;
+  max-width: 100%;
+  overflow-wrap: anywhere;
+  color: #c5d9ec;
+  font: 10px/1.45 ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, monospace;
+  user-select: text;
+}
+
 #codex-overleaf-panel .codex-update-notice-actions {
   display: flex;
   gap: 6px;