codex-overleaf-link 2.5.0 → 2.5.1

package/extension/src/content/otWarmMirrorController.js

@@ -1,10 +1,10 @@
 (function initCodexOverleafOtWarmMirrorController(root, factory) {
   if (typeof module === 'object' && module.exports) {
-    module.exports = factory();
+    module.exports = factory(require('../shared/projectFiles'));
   } else {
-    root.CodexOverleafOtWarmMirrorController = factory();
+    root.CodexOverleafModuleRegistry.define('OtWarmMirrorController', ['ProjectFiles'], factory);
   }
-})(typeof window !== 'undefined' ? window : globalThis, function otWarmMirrorControllerFactory() {
+})(typeof window !== 'undefined' ? window : globalThis, function otWarmMirrorControllerFactory(projectFiles) {
   'use strict';
 
   const OT_POLL_INTERVAL_MS = 1000;
@@ -17,6 +17,7 @@
   const OT_MAX_BATCH_BYTES = 2 * 1024 * 1024;
   const encoder = typeof TextEncoder === 'function' ? new TextEncoder() : null;
   const PAUSE_STATES = new Set(['running', 'writing', 'undoing', 'compiling']);
+  const normalizeLiteralPath = projectFiles.normalizeSafeProjectPath;
 
   function buildPatchFilesRequest({ projectId, events, nativeCompatibility } = {}) {
     const files = [];
@@ -24,8 +25,8 @@
       if (files.length >= OT_MAX_PATCH_BATCH) {
         break;
       }
-      const filePath = normalizePath(event?.path);
-      if (!isSafeRelativePath(filePath) || typeof event?.baseHash !== 'string') {
+      const filePath = normalizeLiteralPath(event?.path);
+      if (!filePath || typeof event?.baseHash !== 'string') {
         continue;
       }
       const baseHash = event.baseHash.trim();
@@ -73,7 +74,7 @@
     return { pause: false };
   }
 
-  function canUseOtWarmStart({ enabled, focusFiles, mirrorStatus, now = Date.now() } = {}) {
+  function canUseOtWarmStart({ enabled, focusFiles, focusFilesAreLiteral = false, mirrorStatus, now = Date.now() } = {}) {
     if (!enabled) {
       return { ok: false, reason: 'disabled' };
     }
@@ -82,7 +83,10 @@
     }
     if (mirrorStatus.dirty === true) return { ok: false, reason: 'mirror_dirty' };
 
-    const normalizedFocusFiles = normalizePaths(focusFiles);
+    if (focusFilesAreLiteral === true && Array.isArray(focusFiles) && focusFiles.some(path => !normalizeLiteralPath(path))) {
+      return { ok: false, reason: 'invalid_focus_paths' };
+    }
+    const normalizedFocusFiles = normalizePaths(focusFiles, focusFilesAreLiteral === true);
     if (!normalizedFocusFiles.length) {
       return { ok: false, reason: 'no_focus_files' };
     }
@@ -94,7 +98,7 @@
       }
       const age = now - Date.parse(file.observedAt ?? file.lastPatchAt ?? '');
       if (!Number.isFinite(age) || age < 0 || age > OT_FRESHNESS_MAX_AGE_MS) continue;
-      const filePath = normalizePath(file.path);
+      const filePath = normalizeLiteralPath(file.path);
       if (filePath) {
         freshFiles.add(filePath);
       }
@@ -124,9 +128,9 @@
     let bytes = next.reduce((sum, event) => sum + patchBytes(event), 0);
     if (next.length > OT_MAX_PENDING_EVENTS || bytes > OT_MAX_PENDING_BYTES) return { ok: false, reason: 'ot_queue_limit' };
     for (const input of events) {
-      const path = normalizePath(input?.path);
+      const path = normalizeLiteralPath(input?.path);
       const time = typeof input?.observedAt === 'number' ? input.observedAt : Date.parse(input?.observedAt || '');
-      if (!isSafeRelativePath(path) || path.length > 1024 || typeof input?.nextContent !== 'string' ||
+      if (!path || path.length > 1024 || typeof input?.nextContent !== 'string' ||
           typeof input.baseHash !== 'string' || !input.baseHash || input.baseHash.length > 128) {
         return { ok: false, reason: 'ot_event_invalid' };
       }
@@ -165,7 +169,7 @@
     }
     if (!events.length || Number(result.appliedCount) !== events.length || !Array.isArray(result.appliedFiles) ||
         result.appliedFiles.length !== events.length || !result.appliedFiles.every((file, index) =>
-          normalizePath(file?.path) === events[index].path && (!events[index].nextHash || file.hash === events[index].nextHash))) {
+          normalizeLiteralPath(file?.path) === events[index].path && (!events[index].nextHash || file.hash === events[index].nextHash))) {
       return { ok: false, reason: 'mirror_patch_invalid_result' };
     }
     if (events.some(event => { const time = Date.parse(event.observedAt);
@@ -220,11 +224,11 @@
       .replace(/^\/+/, '');
   }
 
-  function normalizePaths(value) {
+  function normalizePaths(value, literal = false) {
     const seen = new Set();
     const paths = [];
     for (const item of Array.isArray(value) ? value : []) {
-      const filePath = normalizePath(item);
+      const filePath = literal ? normalizeLiteralPath(item) : normalizePath(item);
       if (!filePath || seen.has(filePath)) {
         continue;
       }
@@ -234,13 +238,6 @@
     return paths;
   }
 
-  function isSafeRelativePath(filePath) {
-    if (!filePath) {
-      return false;
-    }
-    return !filePath.split('/').some(part => part === '.' || part === '..');
-  }
-
   function isPrimitiveMetadata(value) {
     return ['string', 'number', 'boolean'].includes(typeof value);
   }

package/extension/src/content/pageBridgeClient.js

@@ -21,14 +21,17 @@
     ['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/ownedDirectoryCleanup.js', 'codex-overleaf-owned-directory-cleanup-script', true],
     ['src/page/textFileCreator.js', 'codex-overleaf-text-file-creator-script', true],
     ['src/page/binaryAssetUploader.js', 'codex-overleaf-binary-asset-uploader-script', true],
     ['src/page/snapshotRouter.js', 'codex-overleaf-snapshot-router-script'],
     ['src/page/referenceProjects.js', 'codex-overleaf-reference-projects-script', true],
+    ['src/page/fileMover.js', 'codex-overleaf-file-mover-script', true],
     ['src/page/writeGuard.js', 'codex-overleaf-write-guard-script', true],
     ['src/page/trackedChangeOwnership.js', 'codex-overleaf-tracked-change-ownership-script', true],
     ['src/page/trackedChangeCapture.js', 'codex-overleaf-tracked-change-capture-script', true],
     ['src/page/trackedChangeReplay.js', 'codex-overleaf-tracked-change-replay-script', true],
+    ['src/page/reviewContext.js', 'codex-overleaf-review-context-script', true],
     ['src/page/trackedChangesLifecycle.js', 'codex-overleaf-tracked-changes-lifecycle-script', true],
     ['src/page/writebackRouter.js', 'codex-overleaf-writeback-router-script', true],
     ['src/page/writebackReceiptJournal.js', 'codex-overleaf-writeback-receipt-script', true],
@@ -75,6 +78,11 @@
         const requestTimeoutMs = Number.isFinite(Number(policy.timeoutMs))
           ? Number(policy.timeoutMs)
           : Contract.resolveTimeoutMs(method, timeoutOverrides);
+        // Review preparation and its nested writes share the transport budget.
+        if (Contract.getMethod(method)?.timeoutClass === 'lifecycle') {
+          params = { ...params, deadlineAt: params?.deadlineAt == null ? now() + requestTimeoutMs
+            : Number.isFinite(params.deadlineAt) ? Math.min(params.deadlineAt, now() + requestTimeoutMs) : params.deadlineAt };
+        }
         const remainingMs = params?.deadlineAt == null ? Infinity
           : Number.isFinite(params.deadlineAt) ? params.deadlineAt - now() : 0;
         if (remainingMs <= 0) {
@@ -84,7 +92,7 @@
         }
         const timeoutMs = Math.min(requestTimeoutMs, remainingMs);
         const cancellable = policy.cancellation === 'content_abort';
-        let settled = false;
+        let settled = false, dispatched = false;
         let timeout = null;
         function cleanup() {
           if (timeout !== null) windowRef.clearTimeout(timeout);
@@ -107,8 +115,13 @@
           const error = new Error('Codex run was cancelled by the user');
           error.code = 'codex_cancelled';
           error.cancelled = true;
+          error.requestDispatched = dispatched;
+          error.changedDocument = dispatched && Contract.getMethod(method)?.mutation === 'document';
+          if (dispatched && method === 'applyOperations') { error.requestId = id; error.rpcMethod = method; }
           rejectOnce(error);
         }
+        // Cancellation stops new requests; receipt settlement has its own non-cancellable policy.
+        if (cancellable && options.isCancellationRequested?.()) { cancelRequest(); return; }
         timeout = windowRef.setTimeout(() => {
           resolveOnce({ ok: false, error: 'Page bridge timed out',
             ...(method === 'applyOperations' ? { code: 'page_bridge_timeout', rpcMethod: method, requestId: id } : {}) });
@@ -126,11 +139,11 @@
         }
         if (cancellable) {
           activeCancellationHandlers.set(id, cancelRequest);
-          if (options.isCancellationRequested?.()) windowRef.queueMicrotask(cancelRequest);
         }
         windowRef.addEventListener('message', onMessage);
         // Every low-level request remains one attempt. Higher layers must opt
         // into replay so a document mutation is never duplicated implicitly.
+        dispatched = true;
         windowRef.postMessage({
           source: 'codex-overleaf/content',
           id,

package/extension/src/content/panelMaintenance.js

@@ -24,6 +24,7 @@
       openCustomInstructionsSettings,
       onHistoryRowJump,
       resetProjectNameCache,
+      clearHistoryComposer,
       getPanel,
       getState,
       setState,
@@ -110,27 +111,54 @@
     if (!confirmed) {
       return;
     }
+    if (getCurrentRunView()) {
+      showPluginToast(tx('A run started while confirmation was open. Finish or cancel it before clearing history.', '确认期间有任务开始运行，请先完成或取消任务后再清理历史。'));
+      return;
+    }
+    let historyClearedAt;
     try {
-      await StorageDb?.clearAllStores?.();
+      await StorageDb.clearAllStores();
+      historyClearedAt = Date.now();
       historyView.invalidate();
-      // v1.8.1: the dashboard's project-name cache lives in
-      // chrome.storage.local, outside the IndexedDB stores — clear it too so
-      // no (potentially sensitive) project titles outlive the wipe.
-      await resetProjectNameCache?.();
     } catch (error) {
       showPluginToast(tx(`Could not clear history: ${error.message}`, `清空历史失败：${error.message}`));
       return;
     }
-    // Reset the in-getPanel() getState() to match the emptied store and re-render
-    // EXPLICITLY. startNewSession() is unusable here: its empty-session reuse
-    // guard matches the fresh session that normalization mints and returns
-    // before applyStateToPanel(), leaving the deleted cards on screen.
-    setState(normalizePanelState({ ...getState(), sessions: [], runs: [], activeSessionId: '' }));
-    await saveState();
+    const cleanupErrors = [];
+    try {
+      // Project names live outside the history store. Failure here must not
+      // leave deleted history in memory for a later autosave to replay.
+      await resetProjectNameCache?.();
+    } catch (error) {
+      cleanupErrors.push(error.message);
+    }
+    // Clear the compatibility mirror as well as the session list; otherwise
+    // normalization can reconstruct old summary runs and the Native thread.
+    const clearedState = normalizePanelState({
+      ...getState(), session: null, sessions: [], runs: [], activeSessionId: '',
+      task: '', focusFiles: [], selectionContext: null, composerAttachments: []
+    });
+    const freshSession = clearedState.sessions[0];
+    // The shared store rejects createdAt <= its clear marker. A new session
+    // in the same millisecond needs the next tick, at most 1 ms ahead of now.
+    freshSession.createdAt = freshSession.updatedAt = new Date(Math.max(Date.now(), historyClearedAt + 1)).toISOString();
+    setState(clearedState);
+    try {
+      clearHistoryComposer?.();
+      if (await saveState({ requireDurable: true }) !== true) {
+        throw new Error(tx('The blank session save was not confirmed.', '空白会话的保存结果尚未确认。'));
+      }
+    } catch (error) {
+      cleanupErrors.push(error.message);
+    }
+    // The store has already been cleared, including when the fresh-session
+    // save fails. Always remove old cards and draft inputs from the panel.
     applyStateToPanel();
     refreshStorageUsageSummary();
     void renderAuditHistoryPanel();
-    showPluginToast(tx('Local history cleared. Overleaf files are unchanged.', '本地历史已清理，Overleaf 文件保持不变。'));
+    showPluginToast(cleanupErrors.length
+      ? tx(`Saved history was removed, but cleanup or blank-session saving needs attention: ${cleanupErrors.join('; ')}`, `已删除保存的历史，但清理或空白会话保存仍有问题：${cleanupErrors.join('；')}`)
+      : tx('Local history cleared. Overleaf files are unchanged.', '本地历史已清理，Overleaf 文件保持不变。'));
     getPanel()?.querySelector('[data-task]')?.focus();
   }
 

package/extension/src/content/panelRenderer.js

@@ -117,6 +117,12 @@
       sessionSlot: instance.sessionSlot,
       composerSlot: instance.composerSlot,
       setView: view => { panelEl.dataset.view = view; },
+      setLocale: labels => {
+        launcherEl.title = labels.launcher;
+        launcherEl.setAttribute('aria-label', labels.launcher);
+        const close = panelEl.querySelector('[data-close-panel]');
+        if (close) { close.title = labels.close; close.setAttribute('aria-label', labels.close); }
+      },
       destroy: () => destroy(instance),
       _instance: instance
     };

package/extension/src/content/projectProviderSelection.js

@@ -2,12 +2,20 @@
   'use strict';
 
   function create(deps = {}) {
-    async function confirmSwitch({ providerName } = {}) {
+    function assertSwitchAllowed() {
       if ((deps.getRunningSessionIds?.() || []).length) {
-        deps.showToast?.(deps.tx(
+        throw Object.assign(new Error(deps.tx(
           'Wait for the running task to finish before switching providers.',
           '请等待正在运行的任务结束后再切换模型服务。'
-        ), { status: 'warning' });
+        )), { code: 'provider_switch_running' });
+      }
+    }
+
+    async function confirmSwitch({ providerName } = {}) {
+      try {
+        assertSwitchAllowed();
+      } catch (error) {
+        deps.showToast?.(error.message, { status: 'warning' });
         return false;
       }
       return deps.showConfirm?.({
@@ -33,6 +41,7 @@
       const providerConfigurationChanged = nextProviderId === (state.providerId || 'builtin')
         && nextProviderRevision !== Number(state.providerRevision || 0);
       const resetProviderThread = providerChanged || providerConfigurationChanged;
+      if (resetProviderThread) assertSwitchAllowed();
       const sessions = (state.sessions || []).map(session => ({
         ...session,
         providerId: nextProviderId,
@@ -53,7 +62,7 @@
       deps.applyStateToPanel?.();
     }
 
-    return { confirmSwitch, commit };
+    return { assertSwitchAllowed, confirmSwitch, commit };
   }
 
   window.CodexOverleafProjectProviderSelection = { create };

package/extension/src/content/projectSessionCleanup.js

@@ -6,6 +6,7 @@
   function create(deps = {}) {
     const {
       tr,
+      tx = en => en,
       getAccountScopeId,
       showPluginConfirm,
       showPluginToast,
@@ -22,79 +23,125 @@
       return !Number.isFinite(touched) || (Date.now() - touched) <= FRESH_RUNNING_WINDOW_MS;
     }
 
-    async function clearProjectSessions(projectId, projectName) {
+    async function clearProjectSessions(projectId, projectName, options = {}) {
       const StorageDb = deps.StorageDb;
       const SessionState = deps.SessionState;
       if (!StorageDb || !SessionState) {
         return;
       }
-      const scope = getAccountScopeId();
-      const records = (await StorageDb.getAllByIndex('sessions', 'projectId', projectId))
-        .filter(record => record && (!scope || record.accountScopeId === scope));
-      if (!records.length) {
-        await renderRecentProjectsVariant();
-        return;
-      }
-      if (records.some(record => isFreshRunningRecord(StorageDb, record))) {
-        showPluginToast(tr('recentProjects_clearProject_running'), { status: 'warning', sticky: true });
-        return;
-      }
-      const approved = await showPluginConfirm({
-        title: tr('recentProjects_clearProject_title', { project: projectName }),
-        message: tr('recentProjects_clearProject_message', { count: String(records.length), project: projectName }),
-        confirmLabel: tr('recentProjects_clearProject_confirm'),
-        cancelLabel: tr('confirmDefaultCancel'),
-        destructive: true
-      });
-      if (!approved) {
-        return;
-      }
-      const Migration = deps.StorageMigration;
-      if (Migration?.addSessionTombstones) {
-        await Migration.addSessionTombstones(projectId, records.map(record => record.id));
-      }
+      const scope = options.accountScopeId ?? getAccountScopeId();
+      const scopeChanged = error => error?.code === 'history_cleanup_scope_changed'
+        || error?.code === 'account_scope_unavailable';
+      const assertCurrent = () => {
+        if (!scope || getAccountScopeId() !== scope || options.isCurrent?.() === false
+          || options.generation !== undefined && deps.getViewGeneration?.() !== options.generation) {
+          throw Object.assign(new Error('History cleanup identity changed.'), { code: 'history_cleanup_scope_changed' });
+        }
+      };
+      const readRecords = async () => {
+        assertCurrent();
+        const records = await StorageDb.getAllByIndex('sessions', 'projectId', projectId);
+        assertCurrent();
+        return records.filter(record => record && record.accountScopeId === scope);
+      };
       try {
-        await mutateProjectPanelState(projectId, state => records.reduce(
-          (nextState, record) => SessionState.deleteSession(nextState, record.id),
-          state
-        ));
-      } catch (_error) { /* IndexedDB deletion remains authoritative for the dashboard. */ }
-
-      let removed = 0;
-      let historyFailures = 0;
-      for (const record of records) {
-        try {
-          await StorageDb.deleteRecord('sessions', record.id);
-          removed++;
-        } catch (_error) { /* The remaining record stays visible and can be retried. */ }
+        let records = await readRecords();
+        if (!records.length) {
+          await renderRecentProjectsVariant();
+          return;
+        }
+        if (records.some(record => isFreshRunningRecord(StorageDb, record))) {
+          showPluginToast(tr('recentProjects_clearProject_running'), { status: 'warning', sticky: true });
+          return;
+        }
+        const approved = await showPluginConfirm({
+          title: tr('recentProjects_clearProject_title', { project: projectName }),
+          message: tr('recentProjects_clearProject_message', { count: String(records.length), project: projectName }),
+          confirmLabel: tr('recentProjects_clearProject_confirm'),
+          cancelLabel: tr('confirmDefaultCancel'),
+          destructive: true
+        });
+        if (!approved) {
+          return;
+        }
+        // Re-read after the destructive dialog: another tab can have started a
+        // run or added a conversation while the original count was displayed.
+        const approvedIds = new Set(records.map(record => record.id));
+        const latest = await readRecords();
+        if (latest.some(record => isFreshRunningRecord(StorageDb, record))) {
+          showPluginToast(tr('recentProjects_clearProject_running'), { status: 'warning', sticky: true });
+          return;
+        }
+        records = latest.filter(record => approvedIds.has(record.id));
+        if (!records.length) { await renderRecentProjectsVariant(); return; }
+        const Migration = deps.StorageMigration;
+        if (Migration?.addSessionTombstones) {
+          assertCurrent();
+          await Migration.addSessionTombstones(projectId, records.map(record => record.id));
+          assertCurrent();
+        }
         try {
-          const response = await sendBackgroundNative({
-            method: 'codex.history.clearPlugin',
-            params: { sessionId: record.id, threadId: record.codexThreadId || '' }
-          });
-          if (!response || !response.ok) {
+          assertCurrent();
+          await mutateProjectPanelState(projectId, state => records.reduce(
+            (nextState, record) => SessionState.deleteSession(nextState, record.id),
+            state
+          ), { assertCurrent });
+          assertCurrent();
+        } catch (error) {
+          if (scopeChanged(error)) throw error;
+          assertCurrent(); // Other legacy-blob failures do not replace shared deletion.
+        }
+
+        let removed = 0;
+        let historyFailures = 0;
+        for (const record of records) {
+          try {
+            assertCurrent();
+            await StorageDb.deleteRecord('sessions', record.id, { accountScopeId: scope, projectId });
+            assertCurrent();
+            removed++;
+          } catch (error) {
+            if (scopeChanged(error)) throw error;
+            assertCurrent(); // The remaining record can be retried in the same scope.
+          }
+          try {
+            assertCurrent();
+            const response = await sendBackgroundNative({
+              method: 'codex.history.clearPlugin',
+              params: { sessionId: record.id, threadId: record.codexThreadId || '' }
+            });
+            assertCurrent();
+            if (!response || !response.ok) {
+              historyFailures++;
+            }
+          } catch (error) {
+            if (scopeChanged(error)) throw error;
+            assertCurrent();
             historyFailures++;
           }
-        } catch (_error) {
-          historyFailures++;
         }
+        if (removed < records.length) {
+          showPluginToast(tr('recentProjects_clearProject_partial', {
+            removed: String(removed),
+            count: String(records.length)
+          }), { status: 'warning', sticky: true });
+        } else if (historyFailures) {
+          showPluginToast(tr('recentProjects_clearProject_historyPartial', {
+            count: String(historyFailures)
+          }), { status: 'warning', sticky: true });
+        } else {
+          showPluginToast(tr('recentProjects_clearProject_done', {
+            count: String(removed),
+            project: projectName
+          }), { status: 'completed' });
+        }
+        await renderRecentProjectsVariant();
+      } catch (error) {
+        if (!scopeChanged(error)) throw error;
+        showPluginToast(tx('History view or account changed. Reopen the history list before deleting sessions.',
+          '历史视图或账号已变化，请重新打开历史列表后再清理会话。'), { status: 'warning', sticky: true });
+        return false;
       }
-      if (removed < records.length) {
-        showPluginToast(tr('recentProjects_clearProject_partial', {
-          removed: String(removed),
-          count: String(records.length)
-        }), { status: 'warning', sticky: true });
-      } else if (historyFailures) {
-        showPluginToast(tr('recentProjects_clearProject_historyPartial', {
-          count: String(historyFailures)
-        }), { status: 'warning', sticky: true });
-      } else {
-        showPluginToast(tr('recentProjects_clearProject_done', {
-          count: String(removed),
-          project: projectName
-        }), { status: 'completed' });
-      }
-      await renderRecentProjectsVariant();
     }
 
     return { clearProjectSessions };

package/extension/src/content/projectSettingsCoordinator.js

@@ -140,9 +140,13 @@
       if (!settingsPanelInstance) {
         return;
       }
-      const summary = getSkillLoadingSettings().loadCodexOverleafSkills === false
+      const settings = getSkillLoadingSettings();
+      const localCount = settings.loadCodexLocalSkills === false ? 0
+        : (deps.getCodexLocalSkills?.() || []).filter(skill => isCodexLocalSkillEnabled(skill.id, skill)).length;
+      const overleafCount = settings.loadCodexOverleafSkills === false ? 0 : countEnabledCodexOverleafSkills();
+      const summary = settings.loadCodexLocalSkills === false && settings.loadCodexOverleafSkills === false
         ? tr('codexOverleafSkillsSummaryOff')
-        : tr('codexOverleafSkillsSummaryCount', { count: countEnabledCodexOverleafSkills() });
+        : tr('codexOverleafSkillsSummaryCount', { count: localCount + overleafCount });
       SettingsPanel.setSkillsSummary(settingsPanelInstance, summary);
     }
 
@@ -296,6 +300,36 @@
       deps.updateGlobalPreferences?.({ codexOverleafSkillEnabled: { [skillId]: Boolean(enabled) } })?.catch(() => {});
     }
 
+    function getCodexLocalSkillEnabled() {
+      const map = getState()?.codexLocalSkillEnabled;
+      return map && typeof map === 'object' && !Array.isArray(map) ? map : {};
+    }
+
+    function isCodexLocalSkillEnabled(skillId, skill) {
+      const map = getCodexLocalSkillEnabled();
+      return Object.prototype.hasOwnProperty.call(map, skillId) ? map[skillId] !== false : skill?.enabled !== false;
+    }
+
+    function setCodexLocalSkillEnabled(skillId, enabled) {
+      if (deps.updateGlobalPreferences) {
+        try {
+          const pending = deps.updateGlobalPreferences({ codexLocalSkillEnabled: { [skillId]: Boolean(enabled) } });
+          Promise.resolve(pending).then(() => saveStateSoon()).catch(() => {
+            renderLocalSkillList();
+            setProjectSettingsStatus(tx('Could not save the local skill selection. Try again.', '无法保存本地技能选择，请重试。'), 'failed');
+          });
+        } catch (_error) {
+          renderLocalSkillList();
+          setProjectSettingsStatus(tx('Could not save the local skill selection. Try again.', '无法保存本地技能选择，请重试。'), 'failed');
+        }
+      } else {
+        setState({ ...getState(), codexLocalSkillEnabled: { ...getCodexLocalSkillEnabled(), [skillId]: Boolean(enabled) } });
+        saveStateSoon();
+        renderLocalSkillList();
+      }
+      deps.onSkillsChange?.();
+    }
+
     function readSkillLoadingSettingsFromSettings() {
       return SettingsPanel.readState(getSettingsPanelInstance()).skillToggles;
     }
@@ -337,6 +371,9 @@
       closeCustomInstructionsSettings,
       closeSkillsView,
       getCodexOverleafSkillEnabled,
+      getCodexLocalSkillEnabled,
+      isCodexLocalSkillEnabled,
+      setCodexLocalSkillEnabled,
       getCustomInstructionsForCurrentProject,
       getGovernanceRulesForCurrentProject,
       getSkillLoadingSettings,