codex-overleaf-link 1.3.0 → 1.3.6

package/extension/src/shared/sessionState.js

@@ -7,6 +7,10 @@
 })(typeof globalThis !== 'undefined' ? globalThis : window, function sessionStateFactory() {
   'use strict';
 
+  const i18n = (typeof module === 'object' && module.exports)
+    ? require('./i18n')
+    : (typeof globalThis !== 'undefined' ? globalThis : window).CodexOverleafI18n;
+
   const DEFAULT_PANEL_STATE = {
     mode: 'confirm',
     model: 'gpt-5.4',
@@ -17,6 +21,7 @@
     autoOpen: true,
     loadCodexLocalSkills: true,
     loadCodexOverleafSkills: true,
+    codexOverleafSkillEnabled: {},
     panelWidth: 380,
     task: '',
     focusFiles: [],
@@ -105,12 +110,14 @@
     state.autoOpen = state.autoOpen !== false;
     state.loadCodexLocalSkills = state.loadCodexLocalSkills !== false;
     state.loadCodexOverleafSkills = state.loadCodexOverleafSkills !== false;
+    state.codexOverleafSkillEnabled = normalizeCodexOverleafSkillEnabled(state.codexOverleafSkillEnabled);
     state.panelWidth = normalizePanelWidth(state.panelWidth);
     state.task = typeof state.task === 'string' ? state.task : '';
     state.model = typeof state.model === 'string' && state.model ? state.model : DEFAULT_PANEL_STATE.model;
     state.customInstructionsByProject = normalizeCustomInstructionsByProject(state.customInstructionsByProject);
-    state.runs = normalizeRuns(state.runs, options);
-    state.sessions = normalizeSessions(state, input, options);
+    const localizedOptions = { ...options, locale: state.locale };
+    state.runs = normalizeRuns(state.runs, localizedOptions);
+    state.sessions = normalizeSessions(state, input, localizedOptions);
     state.activeSessionId = resolveActiveSessionId(state.sessions, input.activeSessionId);
 
     return mirrorActiveSession(state);
@@ -497,12 +504,13 @@
 
   function normalizeRun(run, options = {}) {
     const shouldStopRestoredRun = options.restoreRunningRuns === true && run.status === 'running';
+    const locale = options.locale || i18n.DEFAULT_LOCALE;
     const events = normalizeRunEvents(run.events);
     if (shouldStopRestoredRun) {
       events.push({
-        title: '页面刷新后已停止跟踪这轮任务',
+        title: i18n.t(locale, 'restoredRunStoppedTitle'),
         status: 'failed',
-        detail: '插件重新加载时发现这轮任务还标记为处理中。为了避免继续显示过期状态，已把它标记为中断；可以重新运行任务。',
+        detail: i18n.t(locale, 'restoredRunStoppedDetail'),
         timestamp: new Date().toISOString()
       });
     }
@@ -515,7 +523,7 @@
       reasoningEffort: typeof run.reasoningEffort === 'string' ? run.reasoningEffort : '',
       speedTier: typeof run.speedTier === 'string' ? run.speedTier : '',
       status: shouldStopRestoredRun ? 'failed' : normalizeRunStatus(run.status),
-      statusText: shouldStopRestoredRun ? '页面刷新后已停止跟踪' : sanitizeAssistantVisibleText(run.statusText),
+      statusText: shouldStopRestoredRun ? i18n.t(locale, 'restoredRunStoppedStatus') : sanitizeAssistantVisibleText(run.statusText),
       startedAt: typeof run.startedAt === 'string' ? run.startedAt : '',
       finishedAt: shouldStopRestoredRun ? new Date().toISOString() : typeof run.finishedAt === 'string' ? run.finishedAt : '',
       events: events.slice(-MAX_RUN_EVENTS),
@@ -669,6 +677,23 @@
     return result;
   }
 
+  function normalizeCodexOverleafSkillEnabled(value) {
+    const result = {};
+    if (!value || typeof value !== 'object' || Array.isArray(value)) {
+      return result;
+    }
+    for (const key of Object.keys(value)) {
+      if (typeof key !== 'string' || !key) {
+        continue;
+      }
+      if (typeof value[key] !== 'boolean') {
+        continue;
+      }
+      result[key] = value[key];
+    }
+    return result;
+  }
+
   function normalizeProjectPrefKey(value) {
     const key = typeof value === 'string' ? value.trim() : '';
     if (!key) {
@@ -714,6 +739,7 @@
       autoOpen: source.autoOpen !== false,
       loadCodexLocalSkills: source.loadCodexLocalSkills !== false,
       loadCodexOverleafSkills: source.loadCodexOverleafSkills !== false,
+      codexOverleafSkillEnabled: normalizeCodexOverleafSkillEnabled(source.codexOverleafSkillEnabled),
       panelWidth: normalizePanelWidth(source.panelWidth),
       task: summarizeTextForStorage(active?.task || source.task || '', 'task'),
       focusFiles: normalizeFocusFiles(active?.focusFiles || source.focusFiles),

package/extension/src/shared/storageDb.js

@@ -342,11 +342,31 @@
       experimentalOtByProject: normalizeBooleanMap(state.experimentalOtByProject),
       customInstructionsByProject: normalizeStringMap(state.customInstructionsByProject),
       governanceRulesByProject: normalizeGovernanceRulesMap(state.governanceRulesByProject),
-      selectedLocalSkillIdsByProject: normalizeStringListMap(state.selectedLocalSkillIdsByProject)
+      selectedLocalSkillIdsByProject: normalizeStringListMap(state.selectedLocalSkillIdsByProject),
+      codexOverleafSkillEnabled: normalizeCodexOverleafSkillEnabledMap(state.codexOverleafSkillEnabled)
     };
     return prefs;
   }
 
+  function normalizeCodexOverleafSkillEnabledMap(value) {
+    var result = {};
+    if (!value || typeof value !== 'object' || Array.isArray(value)) {
+      return result;
+    }
+    var keys = Object.keys(value);
+    for (var i = 0; i < keys.length; i++) {
+      var key = keys[i];
+      if (typeof key !== 'string' || !key) {
+        continue;
+      }
+      if (typeof value[key] !== 'boolean') {
+        continue;
+      }
+      result[key] = value[key];
+    }
+    return result;
+  }
+
   function normalizeBooleanMap(value) {
     var result = {};
     if (!value || typeof value !== 'object' || Array.isArray(value)) {

package/extension/src/shared/undoOperations.js

@@ -223,7 +223,15 @@
       if (typeof current !== 'string') {
         return;
       }
-      if (typeof operation.replaceAll === 'string') {
+      // The writeback already verified the editor content it produced. When
+      // that authoritative post-write content is available, trust it instead
+      // of re-deriving the result by re-applying patches: a wide patch's
+      // `expected` spans a whole paragraph, so it silently fails to re-apply
+      // against any base that drifted even slightly from the patch's base,
+      // and the result would otherwise collapse to the un-patched content.
+      if (typeof operation.verifiedContent === 'string') {
+        filesByPath.set(operation.path, operation.verifiedContent);
+      } else if (typeof operation.replaceAll === 'string') {
         filesByPath.set(operation.path, operation.replaceAll);
       } else if (Array.isArray(operation.patches) && operation.patches.length) {
         const patched = applyTextPatches(current, operation.patches);

package/native-host/src/codexHome.js

@@ -7,25 +7,31 @@ const {
   getNativeHostPlatform
 } = require('./nativeHostPlatform');
 const {
+  ensureCodexOverleafSkillInstalled,
   getCodexOverleafSkillsRoot,
-  materializeProjectSkillsAsCodexSkills
+  materializeProjectSkillsAsCodexSkills,
+  OFFICIAL_CODEX_OVERLEAF_SKILL_IDS
 } = require('./localSkills');
 
 const COPIED_USER_CODEX_FILES = [
   'auth.json',
   'config.toml',
-  'AGENTS.md',
   'installation_id',
   'models_cache.json',
   'version.json'
 ];
 
 const LINKED_USER_CODEX_DIRS = [
-  'rules',
-  'memories',
   'vendor_imports'
 ];
 
+// User-global Codex instruction/memory entries that must never enter the plugin
+// Codex home. The extension supplies its own per-project personalization via the
+// prompt; inheriting the user's global Codex guidance here is a leak. The plugin
+// home is reused across runs, so these are removed every prepare to also clear
+// entries left by earlier extension versions.
+const ISOLATED_USER_INSTRUCTION_ENTRIES = ['AGENTS.md', 'rules', 'memories'];
+
 const LOCAL_SKILL_USER_CODEX_DIRS = [
   'plugins',
   'superpowers'
@@ -93,6 +99,18 @@ function preparePluginCodexHome(env = process.env, options = {}) {
     copied.push(fileName);
   }
 
+  // Personalization isolation: the plugin Codex home must never inherit the
+  // user's global Codex instructions/memory. Remove them every run — this also
+  // clears stale entries left by earlier extension versions. This runs after
+  // the samePath early-return above, so it never touches the user's real
+  // ~/.codex when the plugin home and user home are the same directory.
+  for (const entryName of ISOLATED_USER_INSTRUCTION_ENTRIES) {
+    removePluginHomeEntry(pluginHome, entryName, skippedLinks);
+  }
+  if (!isRegularFile(path.join(userHome, 'config.toml'))) {
+    removePluginHomeEntry(pluginHome, 'config.toml', skippedLinks);
+  }
+
   if (!loadCodexLocalSkills) {
     for (const entryName of LOCAL_SKILL_PLUGIN_HOME_ENTRIES) {
       removePluginHomeEntry(pluginHome, entryName, skippedLinks);
@@ -119,6 +137,8 @@ function preparePluginCodexHome(env = process.env, options = {}) {
     linked.push(dirName);
   }
 
+  ensureDefaultCodexOverleafSkills({ env });
+
   const skillsResult = composePluginSkillsDirectory({
     userHome,
     pluginHome,
@@ -137,13 +157,68 @@ function preparePluginCodexHome(env = process.env, options = {}) {
   return { userHome, pluginHome, copied, linked, skippedLinks };
 }
 
+function ensureDefaultCodexOverleafSkills({ env = process.env } = {}) {
+  for (const id of OFFICIAL_CODEX_OVERLEAF_SKILL_IDS) {
+    const src = path.resolve(__dirname, 'skills', id, 'SKILL.md');
+    const content = fs.readFileSync(src, 'utf8');
+    ensureCodexOverleafSkillInstalled({ skillId: id, content, env });
+  }
+}
+
 function copyUserCodexFile(source, target, fileName, options = {}) {
-  if (fileName !== 'config.toml' || options.loadCodexLocalSkills !== false) {
+  if (fileName !== 'config.toml') {
     fs.copyFileSync(source, target);
     return;
   }
-  const content = fs.readFileSync(source, 'utf8');
-  fs.writeFileSync(target, sanitizeCodexConfigForLocalSkillIsolation(content), 'utf8');
+  let content = stripPersonalizationFromCodexConfig(fs.readFileSync(source, 'utf8'));
+  if (options.loadCodexLocalSkills === false) {
+    content = sanitizeCodexConfigForLocalSkillIsolation(content);
+  }
+  fs.writeFileSync(target, content, 'utf8');
+}
+
+// Removes the top-level `personality` key (Codex's built-in "personality"
+// feature) so the plugin Codex home never inherits the user's global
+// personalization. Only the top-level key is removed — a `personality` key
+// inside a [section] is a different key and is preserved. Handles single-line
+// values and both multi-line string forms (""" basic and ''' literal). All
+// other lines pass through unchanged, aside from line endings being normalized to LF.
+function stripPersonalizationFromCodexConfig(content) {
+  const lines = String(content || '').split(/\r?\n/);
+  const output = [];
+  let beforeFirstSection = true;
+  let closingDelimiter = '';
+
+  for (const line of lines) {
+    if (closingDelimiter) {
+      if (line.includes(closingDelimiter)) {
+        closingDelimiter = '';
+      }
+      // Drop every line of the multi-line value, including the one that closes it.
+      continue;
+    }
+    if (parseTomlSectionName(line)) {
+      beforeFirstSection = false;
+      output.push(line);
+      continue;
+    }
+    if (beforeFirstSection) {
+      const match = line.match(/^\s*personality\s*=\s*(.*)$/);
+      if (match) {
+        const value = match[1];
+        const opener = value.startsWith('"""') ? '"""'
+          : value.startsWith("'''") ? "'''"
+            : '';
+        if (opener && value.indexOf(opener, opener.length) === -1) {
+          closingDelimiter = opener;
+        }
+        continue;
+      }
+    }
+    output.push(line);
+  }
+
+  return output.join('\n');
 }
 
 function sanitizeCodexConfigForLocalSkillIsolation(content) {
@@ -532,6 +607,7 @@ module.exports = {
   buildCodexHomeEnv,
   clearPluginCodexHistory,
   composePluginSkillsDirectory,
+  ensureDefaultCodexOverleafSkills,
   getPluginCodexHome,
   getUserCodexHome,
   preparePluginCodexHome

package/native-host/src/codexSessionRunner.js

@@ -68,6 +68,7 @@ async function runCodexSession({ params = {}, env = process.env, emit = () => {}
   const codexSkillInvocationContext = loadCodexSkillInvocationContext({
     skillInvocation,
     loadCodexOverleafSkills: skillLoading.loadCodexOverleafSkills,
+    enabledCodexOverleafSkillIds: params.enabledCodexOverleafSkillIds,
     env,
     emit
   });
@@ -385,6 +386,7 @@ function normalizeSkillLoadingSettings(params = {}) {
 function loadCodexSkillInvocationContext({
   skillInvocation,
   loadCodexOverleafSkills = true,
+  enabledCodexOverleafSkillIds,
   env = process.env,
   emit = () => {}
 } = {}) {
@@ -399,6 +401,7 @@ function loadCodexSkillInvocationContext({
   const result = loadSelectedCodexOverleafSkill({
     skillId: invocation.id,
     loadCodexOverleafSkills,
+    enabledCodexOverleafSkillIds,
     env
   });
   if (result.missing.length) {

package/native-host/src/localSkills.js

@@ -13,6 +13,7 @@ const MAX_SKILL_CONTENT_CHARS = MAX_SKILL_CONTENT_BYTES;
 const MAX_SKILL_PREVIEW_CHARS = 240;
 const PROJECT_SKILL_SCOPE = 'project';
 const CODEX_OVERLEAF_SKILL_SCOPE = 'codex-overleaf';
+const OFFICIAL_CODEX_OVERLEAF_SKILL_IDS = ['annotated-rewrite'];
 
 function listProjectSkills({ projectId, rootDir } = {}) {
   const skillsDir = getProjectSkillsDir(projectId, { rootDir });
@@ -110,13 +111,18 @@ function listCodexOverleafSkills({ env = process.env, skillsRoot } = {}) {
       continue;
     }
     const content = fs.readFileSync(filePath, 'utf8');
-    skills.push(buildSkillMetadata({
-      id: entry.name,
-      content,
-      size: stat.size,
-      updatedAt: stat.mtime.toISOString(),
-      scope: CODEX_OVERLEAF_SKILL_SCOPE
-    }));
+    const isOfficial = OFFICIAL_CODEX_OVERLEAF_SKILL_IDS.includes(entry.name);
+    skills.push({
+      ...buildSkillMetadata({
+        id: entry.name,
+        content,
+        size: stat.size,
+        updatedAt: stat.mtime.toISOString(),
+        scope: CODEX_OVERLEAF_SKILL_SCOPE
+      }),
+      official: isOfficial,
+      removable: !isOfficial
+    });
   }
 
   return { skills: skills.sort((left, right) => left.id.localeCompare(right.id)) };
@@ -147,6 +153,9 @@ function installCodexOverleafSkill({ skillId, content, env = process.env, skills
 
 function removeCodexOverleafSkill({ skillId, env = process.env, skillsRoot } = {}) {
   const id = validateSkillId(skillId);
+  if (OFFICIAL_CODEX_OVERLEAF_SKILL_IDS.includes(id)) {
+    throw new Error(`Cannot remove official skill: ${id}`);
+  }
   const root = getCodexOverleafSkillsRoot({ env, skillsRoot });
   const skillDir = resolveInside(root, id, 'Unsafe Codex Overleaf skill path');
   const removed = fs.existsSync(skillDir);
@@ -156,6 +165,21 @@ function removeCodexOverleafSkill({ skillId, env = process.env, skillsRoot } = {
   return { id, scope: CODEX_OVERLEAF_SKILL_SCOPE, removed };
 }
 
+function ensureCodexOverleafSkillInstalled({ skillId, content, env = process.env } = {}) {
+  const root = getCodexOverleafSkillsRoot({ env });
+  const skillPath = resolveCodexOverleafSkillPath(skillId, { env });
+  if (fs.existsSync(skillPath)) {
+    assertNoSymlinkEscape(skillPath, root, 'Existing official skill path is unsafe');
+    const stat = fs.lstatSync(skillPath);
+    if (stat.isFile()) {
+      return;
+    }
+    // symlink, directory, or other — remove and reinstall
+    fs.rmSync(skillPath, { recursive: true, force: true });
+  }
+  installCodexOverleafSkill({ skillId, content, env });
+}
+
 function loadSelectedProjectSkills({ projectId, selectedSkillIds, rootDir, projectRoot } = {}) {
   const ids = normalizeSelectedSkillIds(selectedSkillIds);
   const skills = [];
@@ -230,6 +254,7 @@ function materializeProjectSkillsAsCodexSkills({
 function loadSelectedCodexOverleafSkill({
   skillId,
   loadCodexOverleafSkills = true,
+  enabledCodexOverleafSkillIds,
   env = process.env,
   skillsRoot
 } = {}) {
@@ -248,6 +273,18 @@ function loadSelectedCodexOverleafSkill({
       }]
     };
   }
+  // Per-skill enable check: if enabledCodexOverleafSkillIds is provided and does not include
+  // this skill, treat it as not available. Absent param = all enabled (backward-safe).
+  if (Array.isArray(enabledCodexOverleafSkillIds) && !enabledCodexOverleafSkillIds.includes(id)) {
+    return {
+      skill: null,
+      missing: [],
+      ignored: [{
+        id,
+        reason: 'codex_overleaf_skill_disabled'
+      }]
+    };
+  }
 
   const filePath = resolveCodexOverleafSkillPath(id, { env, skillsRoot });
   if (!fs.existsSync(filePath)) {
@@ -461,7 +498,9 @@ module.exports = {
   CODEX_OVERLEAF_SKILL_SCOPE,
   MAX_SKILL_CONTENT_BYTES,
   MAX_SKILL_CONTENT_CHARS,
+  OFFICIAL_CODEX_OVERLEAF_SKILL_IDS,
   PROJECT_SKILL_SCOPE,
+  ensureCodexOverleafSkillInstalled,
   getDefaultCodexOverleafSkillsRoot,
   getCodexOverleafSkillsRoot,
   installCodexOverleafSkill,

package/native-host/src/skills/annotated-rewrite/SKILL.md

@@ -0,0 +1,71 @@
+---
+name: annotated-rewrite
+description: >
+  When editing `.tex` files, use this skill as often as possible. When
+  rewriting `.tex` content spanning more than a few words, comment out the
+  original and write the replacement below it so the user can review the
+  before/after diff directly in the source.
+---
+
+# Annotated Rewrite
+
+When rewriting `.tex` file content (paragraphs, sentences, equations, list
+bodies, or any block larger than a few words), preserve the original by
+commenting it out rather than deleting it, then write the replacement below.
+This lets the user review exactly what changed before accepting the edit.
+
+## When to apply
+
+Default to this pattern whenever the replaced content is **more than a short inline phrase** (see the word-level exception below), regardless of content type — prose, equations, lists, environment bodies, or any contiguous block. Use it as often as possible — when in doubt, use it.
+
+A useful guide: if the replaced content is **3 or more source lines**, always apply it. For shorter replacements (1-2 source lines), lean toward applying it unless the change is purely **word-level**: replacing a single word, fixing a typo, or changing a run of 1-5 words within an unbroken clause.
+
+Word-level edits are the only case where skipping the annotated format is clearly appropriate (subject to the structural exceptions in Rule 8).
+
+## Edit format
+
+```tex
+% [original]
+% The proposed method encodes user history as a fixed-length vector,
+% then applies a linear projection before computing dot-product scores.
+% Training uses binary cross-entropy loss over sampled negatives.
+%
+% \begin{equation}
+%   \hat{y}_{ui} = \mathbf{u}_i^\top \mathbf{v}_j
+% \end{equation}
+
+% [revised]
+We encode user history with a transformer encoder, producing a
+context-aware representation that is projected into the item space.
+Training minimises a softmax loss over in-batch negatives.
+
+\begin{equation}
+  \hat{y}_{ui} = \mathrm{softmax}(\mathbf{U}\mathbf{V}^\top)_{ij}
+\end{equation}
+```
+
+## Rules
+
+1. Copy the original lines **verbatim** into the comment block — do not alter them
+2. Include every line of the replaced content verbatim with `%` prepended;
+   blank lines within the block become `%` empty-comment lines (a line
+   containing only `%`). Include `\begin{...}` / `\end{...}` markers only when
+   they are part of the replaced content — do not comment out enclosing
+   environment markers that are not themselves changing
+3. No blank line between `% [original]` and the first commented line
+4. One blank line between the last commented line and `% [revised]`; one blank
+   line before `% [original]` and after the last line of the replacement (to
+   separate the annotated construct from surrounding document text)
+5. The new content after `% [revised]` is normal LaTeX (not commented)
+6. For multiple non-adjacent replaced blocks, apply the pattern independently
+   to each block
+7. **Idempotency**: if the content being edited already contains a
+   `% [original]` / `% [revised]` block, edit only the active content after
+   `% [revised]` — do not re-wrap the existing annotated block or create a new
+   outer annotation around it
+8. **Structure safety**: only apply this pattern at **block level** (paragraph,
+   sentence, equation block, list body, or environment body). Do NOT insert
+   `% [original]` / `% [revised]` inside
+   macro arguments, table rows, math expressions, `\caption{...}`,
+   `\item[...]`, or preamble commands — make minimal direct edits there instead,
+   or ask for confirmation before changing structurally sensitive content