codex-overleaf-link 1.9.1 → 1.9.3

package/README.md

@@ -3,7 +3,7 @@
   <h1>Codex Overleaf Link</h1>
   <p><strong>Empower Overleaf with Codex.</strong></p>
   <p>
-    <img src="https://img.shields.io/badge/version-1.9.1-blue" alt="version">
+    <img src="https://img.shields.io/badge/version-1.9.3-blue" alt="version">
     <img src="https://img.shields.io/badge/platform-macOS%20%2F%20Windows%20%2F%20Linux-lightgrey" alt="platform">
     <img src="https://img.shields.io/badge/chrome-MV3-green" alt="chrome manifest v3">
     <img src="https://img.shields.io/badge/node-%3E%3D20-brightgreen" alt="node version">
@@ -33,33 +33,33 @@ Either way, the final **Load unpacked** click is manual — Chrome does not let
 
 ### Option A — installer script (recommended)
 
-One command installs the native host **and** sets up the extension: the script registers the native host, places the extension folder at `~/Codex Overleaf Link Extension`, copies that path to your clipboard, and opens `chrome://extensions` for you.
+One command installs the managed native host **and** managed extension runtime. On macOS/Linux it also creates the visible `~/Codex Overleaf Link Extension` shortcut pointing to the managed extension, copies that path to your clipboard, and opens `chrome://extensions` for you. Future signed stable updates target this same managed directory.
 
 macOS / Linux:
 
 ```bash
-CODEX_OVERLEAF_REF=v1.9.1 bash -c "$(curl -fsSL https://raw.githubusercontent.com/Ghqqqq/codex-overleaf-link/v1.9.1/install.sh)"
+CODEX_OVERLEAF_REF=v1.9.3 bash -c "$(curl -fsSL https://raw.githubusercontent.com/Ghqqqq/codex-overleaf-link/v1.9.3/install.sh)"
 ```
 
 Windows PowerShell:
 
 ```powershell
-iwr https://raw.githubusercontent.com/Ghqqqq/codex-overleaf-link/v1.9.1/install.ps1 -OutFile install.ps1
-$env:CODEX_OVERLEAF_REF='v1.9.1'
+iwr https://raw.githubusercontent.com/Ghqqqq/codex-overleaf-link/v1.9.3/install.ps1 -OutFile install.ps1
+$env:CODEX_OVERLEAF_REF='v1.9.3'
 powershell -ExecutionPolicy Bypass -File install.ps1
 ```
 
 Then, in the `chrome://extensions` tab the script opened: enable **Developer mode**, click **Load unpacked**, and choose the prepared extension folder (its path is already on your clipboard). That is the only manual step.
 
-### Option B — npm (native host only)
+### Option B — npm managed install
 
-`npm exec` installs and updates the **native host only** — it does not include the Chrome extension. Use it if you prefer a pinned npm package to a source checkout.
+`npm exec` installs the same managed native host and extension runtime without keeping a source checkout. Use it if you prefer a pinned npm package.
 
 ```bash
-npm exec --yes codex-overleaf-link@1.9.1 -- install-managed
+npm exec --yes codex-overleaf-link@1.9.3 -- install-managed
 ```
 
-Then add the extension yourself: download `codex-overleaf-link-extension-v1.9.1.zip` from the [v1.9.1 GitHub Release](https://github.com/Ghqqqq/codex-overleaf-link/releases/tag/v1.9.1), unzip it to a stable folder, and in `chrome://extensions` enable **Developer mode**, click **Load unpacked**, and select that folder.
+Then, in `chrome://extensions`, enable **Developer mode**, click **Load unpacked**, and select the managed extension path printed by the command. The Release extension zip remains available for explicitly unmanaged/manual installations.
 
 ### Open Overleaf
 
@@ -80,31 +80,31 @@ Then load `extension/` as an unpacked extension in Chrome. If Chrome assigns a d
 
 </details>
 
-## npm Native Host CLI
+## npm Managed CLI
 
-npm installs, updates, uninstalls, and diagnoses the native host only. npm does not install the Chrome extension; install the Chrome extension separately from the release source checkout or extension zip.
+npm installs, updates, and uninstalls the coordinated managed extension/native pair. Diagnostics still target the native host. The legacy `install-native` command remains available only for explicitly unmanaged extension directories.
 
 | Action | Command |
 |--------|---------|
-| Install / update | `npm exec --yes codex-overleaf-link@1.9.1 -- install-managed` |
-| Diagnose | `npm exec --yes codex-overleaf-link@1.9.1 -- doctor` |
-| Uninstall | `npm exec --yes codex-overleaf-link@1.9.1 -- uninstall-managed` |
+| Install / update | `npm exec --yes codex-overleaf-link@1.9.3 -- install-managed` |
+| Diagnose | `npm exec --yes codex-overleaf-link@1.9.3 -- doctor` |
+| Uninstall | `npm exec --yes codex-overleaf-link@1.9.3 -- uninstall-managed` |
 
 Use `--extension-id <chrome-extension-id>` only for a custom/dev unpacked extension id that differs from the official bundled id.
 
 ## Update
 
-To update, re-run any of the [native host installers](#install) — they install and update the same way. This is also the native mismatch recovery command shown by the popup and panel when they report **Native host update required**; it fixes extension/native version mismatch and native protocol mismatch. After updating, reload the extension in `chrome://extensions` and refresh the Overleaf page.
+Managed installations discover signed stable updates automatically and apply them only while all Overleaf tabs and the native host are idle. Re-run `install-managed` only for recovery or migration, including when the panel reports **Native host update required**. Explicitly unmanaged installations still require a manual extension/native update. After recovery, reload the extension in `chrome://extensions` and refresh Overleaf.
 
 ## GitHub Release Artifacts
 
-The v1.9.1 GitHub Release contains:
+The v1.9.3 GitHub Release contains:
 
-- `codex-overleaf-link-extension-v1.9.1.zip`: loadable Chrome extension package for manual unpacked installation.
-- `codex-overleaf-native-host-v1.9.1.tar.gz`: native host runtime files used by the installer and release verification.
-- `codex-overleaf-link-1.9.1.tgz`: npm native host CLI package for pinned install, doctor, and uninstall flows.
-- `install.sh`: release-pinned macOS / Linux installer that defaults to `v1.9.1` when run directly from the release artifact.
-- `install.ps1`: release-pinned Windows PowerShell installer that defaults to `v1.9.1` when run directly from the release artifact.
+- `codex-overleaf-link-extension-v1.9.3.zip`: loadable Chrome extension package for manual unpacked installation.
+- `codex-overleaf-native-host-v1.9.3.tar.gz`: native host runtime files used by the installer and release verification.
+- `codex-overleaf-link-1.9.3.tgz`: npm native host CLI package for pinned install, doctor, and uninstall flows.
+- `install.sh`: release-pinned macOS / Linux installer that defaults to `v1.9.3` when run directly from the release artifact.
+- `install.ps1`: release-pinned Windows PowerShell installer that defaults to `v1.9.3` when run directly from the release artifact.
 - `uninstall-native-host.mjs`: native host uninstaller that removes the Chrome Native Messaging manifest, bridge executable, and runtime copy.
 - `nativeHostPlatform.js`, `manifest.js`, `runtimeInstaller.js`: helper files required by the loose uninstaller asset.
 - `SHA256SUMS` and `release-manifest.json`: checksum and artifact metadata for release verification.
@@ -115,7 +115,7 @@ The v1.9.1 GitHub Release contains:
 Remove the native host (use `--browser chromium` on Linux Chromium):
 
 ```bash
-npm exec --yes codex-overleaf-link@1.9.1 -- uninstall-managed
+npm exec --yes codex-overleaf-link@1.9.3 -- uninstall-managed
 ```
 
 The same command works on Windows PowerShell. If you installed from a manual checkout or source installer, you can also run `npm run uninstall:native` inside the repo, use `node ~/.codex-overleaf/source/scripts/uninstall-native-host.mjs` on macOS / Linux, or use `node $env:LOCALAPPDATA\CodexOverleaf\source\scripts\uninstall-native-host.mjs` on Windows PowerShell.
@@ -150,13 +150,13 @@ Then remove the extension from `chrome://extensions`. To delete local data: on m
 Linux Chromium install or update:
 
 ```bash
-CODEX_OVERLEAF_REF=v1.9.1 bash -c "$(curl -fsSL https://raw.githubusercontent.com/Ghqqqq/codex-overleaf-link/v1.9.1/install.sh)" -- --browser chromium
+CODEX_OVERLEAF_REF=v1.9.3 bash -c "$(curl -fsSL https://raw.githubusercontent.com/Ghqqqq/codex-overleaf-link/v1.9.3/install.sh)" -- --browser chromium
 ```
 
 Linux Chromium uninstall:
 
 ```bash
-npm exec --yes codex-overleaf-link@1.9.1 -- uninstall-managed --browser chromium
+npm exec --yes codex-overleaf-link@1.9.3 -- uninstall-managed --browser chromium
 ```
 
 ## Features
@@ -291,7 +291,7 @@ Composer attachments are turn-scoped Codex context. Limits are 8 attachments per
 Re-run any [native host installer](#install), reload the extension in `chrome://extensions`, then refresh the Overleaf tab. This also fixes extension/native version mismatch and native protocol mismatch.
 
 ```bash
-npm exec --yes codex-overleaf-link@1.9.1 -- install-managed
+npm exec --yes codex-overleaf-link@1.9.3 -- install-managed
 ```
 
 **The Windows popup or panel shows a Bash recovery command**
@@ -340,8 +340,8 @@ Use this matrix for release-candidate signoff and compatibility reports. Record
 | Browser/channel/version | Google Chrome channel and version. | Google Chrome channel and version. | Google Chrome channel and version. | Chromium channel/package and version. |
 | Install mode | Manual unpacked extension from GitHub Release zip or checkout. | Manual unpacked extension from GitHub Release zip or checkout. | Manual unpacked extension from GitHub Release zip or checkout. | Manual unpacked extension from GitHub Release zip or checkout; native host installed with `--browser chromium`. |
 | Extension id | Bundled id `illdpneeeopfffmiepaejglgmhpmdhdc`, or actual custom id passed with `--extension-id`. | Bundled id `illdpneeeopfffmiepaejglgmhpmdhdc`, or actual custom id passed with `--extension-id`. | Bundled id `illdpneeeopfffmiepaejglgmhpmdhdc`, or actual custom id passed with `--extension-id`. | Bundled id `illdpneeeopfffmiepaejglgmhpmdhdc`, or actual custom id passed with `--extension-id`. |
-| Installer/update command | `npm exec --yes codex-overleaf-link@1.9.1 -- install-managed` | `npm exec --yes codex-overleaf-link@1.9.1 -- install-managed` | `npm exec --yes codex-overleaf-link@1.9.1 -- install-managed` | `npm exec --yes codex-overleaf-link@1.9.1 -- install-managed --browser chromium` |
-| Uninstall command | `npm exec --yes codex-overleaf-link@1.9.1 -- uninstall-managed` | `npm exec --yes codex-overleaf-link@1.9.1 -- uninstall-managed` | `npm exec --yes codex-overleaf-link@1.9.1 -- uninstall-managed` | `npm exec --yes codex-overleaf-link@1.9.1 -- uninstall-managed --browser chromium` |
+| Installer/update command | `npm exec --yes codex-overleaf-link@1.9.3 -- install-managed` | `npm exec --yes codex-overleaf-link@1.9.3 -- install-managed` | `npm exec --yes codex-overleaf-link@1.9.3 -- install-managed` | `npm exec --yes codex-overleaf-link@1.9.3 -- install-managed --browser chromium` |
+| Uninstall command | `npm exec --yes codex-overleaf-link@1.9.3 -- uninstall-managed` | `npm exec --yes codex-overleaf-link@1.9.3 -- uninstall-managed` | `npm exec --yes codex-overleaf-link@1.9.3 -- uninstall-managed` | `npm exec --yes codex-overleaf-link@1.9.3 -- uninstall-managed --browser chromium` |
 | Manifest/registry path | `~/Library/Application Support/Google/Chrome/NativeMessagingHosts/com.codex.overleaf.json` | `HKCU\Software\Google\Chrome\NativeMessagingHosts\com.codex.overleaf` -> `%LOCALAPPDATA%\CodexOverleaf\native-host-runtime\com.codex.overleaf.json` | `~/.config/google-chrome/NativeMessagingHosts/com.codex.overleaf.json` | `~/.config/chromium/NativeMessagingHosts/com.codex.overleaf.json` |
 | Bridge/runtime/source path | Bridge `~/.codex-overleaf/codex-overleaf-bridge`; runtime `~/.codex-overleaf/native-host-runtime`; source `~/.codex-overleaf/source`. | Bridge `%LOCALAPPDATA%\CodexOverleaf\codex-overleaf-bridge.cmd`; runtime `%LOCALAPPDATA%\CodexOverleaf\native-host-runtime`; source `%LOCALAPPDATA%\CodexOverleaf\source`. | Bridge `~/.codex-overleaf/codex-overleaf-bridge`; runtime `~/.codex-overleaf/native-host-runtime`; source `~/.codex-overleaf/source`. | Bridge `~/.codex-overleaf/codex-overleaf-bridge`; runtime `~/.codex-overleaf/native-host-runtime`; source `~/.codex-overleaf/source`. |
 | Node/Git/Codex/TeX | Node.js >= 20; Git; Codex CLI installed and logged in; TeX optional. | Node.js >= 20; Git; Codex CLI installed and logged in; TeX optional. | Node.js >= 20; Git; Codex CLI installed and logged in; TeX optional. | Node.js >= 20; Git; Codex CLI installed and logged in; TeX optional. |
@@ -377,7 +377,7 @@ Contributions are welcome. Please open an issue before submitting large changes
 The recommended v1.9 installation owns one stable unpacked-extension directory and a versioned native-host directory:
 
 ```bash
-npm exec --yes codex-overleaf-link@1.9.1 -- install-managed
+npm exec --yes codex-overleaf-link@1.9.3 -- install-managed
 ```
 
 Load the printed extension path once from `chrome://extensions`. Starting with the next signed stable release, Codex Overleaf Link checks GitHub Releases automatically, downloads and verifies the coordinated extension/native-host bundle, waits until every connected Overleaf tab is saved and idle, and then updates both components together. A failed health check restores the previous version automatically.
@@ -387,11 +387,11 @@ The stable updater ignores drafts and prereleases, performs no telemetry, and ca
 The legacy native-only installer remains available for source or unmanaged extension directories:
 
 ```bash
-npm exec --yes codex-overleaf-link@1.9.1 -- install-native
+npm exec --yes codex-overleaf-link@1.9.3 -- install-native
 ```
 
 Legacy native-only installations can be removed with:
 
 ```bash
-npm exec --yes codex-overleaf-link@1.9.1 -- uninstall-native
+npm exec --yes codex-overleaf-link@1.9.3 -- uninstall-native
 ```

package/extension/bootstrap/background.js

@@ -16,6 +16,7 @@ let runtimeLoadError = null;
 try {
   globalThis.__CODEX_OVERLEAF_RUNTIME_BASE__ = 'runtime';
   importScripts(
+    chrome.runtime.getURL('bootstrap/updateStatus.js'),
     chrome.runtime.getURL('runtime/src/shared/compatibility.js'),
     chrome.runtime.getURL('runtime/src/background.js')
   );
@@ -118,10 +119,13 @@ async function checkAndStage(options = {}) {
   if (APPLYING_STATES.has(current.state)) {
     return current;
   }
+  if (['staged', 'waiting_for_idle'].includes(current.state) && current.transactionId) {
+    return tryApplyStagedUpdate();
+  }
   if (!options.manual && Number(current.postponeUntil || 0) > Date.now()) {
     return current;
   }
-  await setUpdateState({ ...current, state: 'checking', code: '', message: '' });
+  await setUpdateState({ ...current, state: 'checking', blocker: '', blockers: [], code: '', message: '' });
   const checked = await requestInternal({
     method: 'update.check',
     params: {
@@ -170,7 +174,9 @@ async function checkAndStage(options = {}) {
     currentVersion: chrome.runtime.getManifest().version,
     latestVersion: staged.result.targetVersion,
     transactionId: staged.result.transactionId,
-    stagedAt: Date.now()
+    stagedAt: Date.now(),
+    blocker: '',
+    blockers: []
   });
   await broadcastUpdateState('staged');
   chrome.alarms.create(IDLE_ALARM, { delayInMinutes: 0.1 });
@@ -187,20 +193,25 @@ async function tryApplyStagedUpdate() {
   }
   const tabs = await chrome.tabs.query({ url: OVERLEAF_MATCHES });
   const probes = await Promise.all(tabs.map(tab => probeTabIdle(tab)));
-  const tabBlocker = probes.find(probe => probe.idle !== true);
-  const nativeGate = await requestInternal({ method: 'update.canApply', params: {} });
-  if (tabBlocker || !nativeGate?.ok || nativeGate.result?.idle !== true) {
+  const nativeGate = await requestInternal({ method: 'update.canApply', params: {} }).catch(error => ({
+    ok: false,
+    error: { code: safeCode(error), message: safeMessage(error) }
+  }));
+  const blockers = globalThis.CodexOverleafUpdateStatus?.collectBlockers(probes, nativeGate)
+    || ['busy'];
+  if (blockers.length) {
     const waiting = await setUpdateState({
       ...state,
       state: 'waiting_for_idle',
-      blocker: tabBlocker?.blockers?.[0] || nativeGate?.result?.blockers?.[0] || 'busy'
+      blocker: blockers[0],
+      blockers
     });
     chrome.alarms.create(IDLE_ALARM, { delayInMinutes: 1 });
     return waiting;
   }
 
   await chrome.storage.local.set({ [UPDATE_RELOAD_TABS_KEY]: tabs.map(tab => tab.id).filter(Number.isInteger) });
-  await setUpdateState({ ...state, state: 'applying', blocker: '' });
+  await setUpdateState({ ...state, state: 'applying', blocker: '', blockers: [] });
   await broadcastUpdateState('applying');
   const applied = await requestInternal({
     method: 'update.apply',
@@ -353,6 +364,9 @@ async function getUpdateState() {
 }
 
 async function setUpdateState(next) {
+  const blockers = globalThis.CodexOverleafUpdateStatus?.normalizeBlockers(
+    Array.isArray(next.blockers) ? next.blockers : (next.blocker ? [next.blocker] : [])
+  ) || [];
   const value = {
     state: next.state || 'idle',
     managed: next.managed !== false,
@@ -363,7 +377,8 @@ async function setUpdateState(next) {
     stagedAt: Number(next.stagedAt || 0),
     postponeUntil: Number(next.postponeUntil || 0),
     transactionId: next.transactionId || '',
-    blocker: next.blocker || '',
+    blocker: blockers[0] || '',
+    blockers,
     code: next.code || '',
     message: String(next.message || '').slice(0, 300)
   };

package/extension/bootstrap/manifest.template.json

@@ -1,7 +1,7 @@
 {
   "manifest_version": 3,
   "name": "Codex Overleaf Link",
-  "version": "1.9.1",
+  "version": "1.9.3",
   "description": "Connect the active Overleaf project to a local Codex bridge.",
   "icons": {
     "16": "assets/icons/icon16.png",

package/extension/bootstrap/popup.html

@@ -33,6 +33,7 @@
     </div>
     <script src="../runtime/src/shared/compatibility.js"></script>
     <script src="../runtime/src/popup.js"></script>
+    <script src="updateStatus.js"></script>
     <script src="popup.js"></script>
   </body>
 </html>

package/extension/bootstrap/popup.js

@@ -5,6 +5,7 @@ const updateVersions = document.getElementById('update-versions');
 const updateDetail = document.getElementById('update-detail');
 const checkButton = document.getElementById('check-update');
 const postponeButton = document.getElementById('postpone-update');
+const UpdateStatus = globalThis.CodexOverleafUpdateStatus;
 
 checkButton.addEventListener('click', async () => {
   checkButton.disabled = true;
@@ -33,7 +34,10 @@ async function refreshUpdateState() {
   if (state.managed === false) {
     updateDetail.textContent = 'Run install-managed once to enable automatic extension and native-host updates.';
   } else if (state.state === 'waiting_for_idle') {
-    updateDetail.textContent = 'Downloaded and verified. Waiting until every Overleaf tab is saved and idle.';
+    const blockerDetail = UpdateStatus?.formatBlockers(state.blockers || [state.blocker]) || '';
+    updateDetail.textContent = blockerDetail
+      ? `Downloaded and verified. ${blockerDetail}`
+      : 'Downloaded and verified. Waiting until every Overleaf tab is saved and idle.';
   } else if (state.state === 'rolled_back') {
     updateDetail.textContent = 'The previous version was restored after a failed health check.';
   } else if (state.state === 'committed') {

package/extension/bootstrap/updateStatus.js

@@ -0,0 +1,78 @@
+(function initCodexOverleafUpdateStatus(root) {
+  'use strict';
+
+  const BLOCKER_MESSAGES = Object.freeze({
+    run: 'A Codex run is still active.',
+    cancelling: 'A Codex cancellation is still settling.',
+    storage: 'Extension state is still being saved.',
+    reviewAction: 'An Accept or Undo action is still running.',
+    dialog: 'A confirmation dialog is still open.',
+    save_state_unverified: 'Overleaf has not confirmed that the document is saved.',
+    recent_user_activity: 'Recent editor activity must be idle for 30 seconds.',
+    save_state_not_stable: 'The saved state must remain stable for 3 seconds.',
+    idle_probe_failed: 'The Overleaf idle check failed.',
+    tab_unavailable: 'An Overleaf tab is unavailable.',
+    tab_probe_timeout: 'An Overleaf tab did not answer the idle check in time.',
+    tab_probe_unavailable: 'Reload an Overleaf tab so the updater can verify that it is idle.',
+    tab_not_idle: 'An Overleaf tab is still busy.',
+    native_project_locked: 'The native host still holds a project lock.',
+    native_run_active: 'The native host is still processing a Codex run.',
+    native_gate_unavailable: 'The native host could not report whether it is idle.',
+    native_not_idle: 'The native host is still busy.',
+    busy: 'An update safety check is still busy.'
+  });
+
+  function normalizeBlockers(values = []) {
+    const result = [];
+    const seen = new Set();
+    const visit = value => {
+      if (Array.isArray(value)) {
+        value.forEach(visit);
+        return;
+      }
+      const code = String(value || '').trim();
+      if (!code || seen.has(code)) return;
+      seen.add(code);
+      result.push(code);
+    };
+    visit(values);
+    return result;
+  }
+
+  function collectBlockers(probes = [], nativeGate = null) {
+    const blockers = [];
+    for (const probe of probes || []) {
+      if (probe?.idle === true) continue;
+      if (Array.isArray(probe?.blockers) && probe.blockers.length) {
+        blockers.push(probe.blockers);
+      } else {
+        blockers.push('tab_not_idle');
+      }
+    }
+    if (!nativeGate?.ok) {
+      blockers.push(nativeGate?.error?.code || 'native_gate_unavailable');
+    } else if (nativeGate.result?.idle !== true) {
+      blockers.push(nativeGate.result?.blockers?.length ? nativeGate.result.blockers : 'native_not_idle');
+    }
+    return normalizeBlockers(blockers);
+  }
+
+  function describeBlocker(code) {
+    const normalized = String(code || '').trim();
+    if (!normalized) return '';
+    return BLOCKER_MESSAGES[normalized]
+      || `Update is waiting on: ${normalized.replaceAll('_', ' ')}.`;
+  }
+
+  function formatBlockers(blockers = []) {
+    return normalizeBlockers(blockers).map(describeBlocker).filter(Boolean).join(' ');
+  }
+
+  root.CodexOverleafUpdateStatus = Object.freeze({
+    BLOCKER_MESSAGES,
+    collectBlockers,
+    describeBlocker,
+    formatBlockers,
+    normalizeBlockers
+  });
+})(typeof window !== 'undefined' ? window : globalThis);

package/extension/src/shared/compatibility.js

@@ -12,7 +12,7 @@
   const MIN_NATIVE_VERSION = '1.0.0';
   const MIN_COMPATIBLE_NATIVE_VERSION = '1.0.0';
   const MIN_COMPATIBLE_EXTENSION_VERSION = '1.0.0';
-  const BUILD_TARGET_VERSION = '1.9.1';
+  const BUILD_TARGET_VERSION = '1.9.3';
   const DEFAULT_CHROME_EXTENSION_ID = 'illdpneeeopfffmiepaejglgmhpmdhdc';
   const REQUIRED_CAPABILITIES = Object.freeze([
     'bridgePing',

package/native-host/src/codexSessionRunner.js

@@ -1125,8 +1125,8 @@ function isAllowedLocalCommand(params = {}) {
   }
 
   const allowed = new Set([
-    'rg', 'grep', 'cat', 'sed', 'head', 'tail', 'nl', 'find', 'ls',
-    'wc', 'diff', 'sort', 'tr', 'awk', 'printf', 'cut', 'uniq',
+    'rg', 'grep', 'cat', 'head', 'tail', 'nl', 'find', 'ls',
+    'wc', 'diff', 'sort', 'tr', 'printf', 'cut', 'uniq',
     'stat', 'file', 'basename', 'dirname', 'realpath',
     'shasum', 'md5', 'md5sum',
     'latexmk', 'pdflatex', 'xelatex', 'lualatex', 'bibtex', 'biber',
@@ -1201,13 +1201,34 @@ function isUnsafeShellToken(token) {
 function hasDisallowedCommandArguments(executable, args = []) {
   const flags = args.map(String);
   if (executable === 'find') {
-    return flags.some(flag => ['-exec', '-execdir', '-delete', '-ok', '-okdir'].includes(flag));
-  }
-  if (executable === 'sed') {
-    return flags.some(flag => flag === '-i' || /^-i[^a-zA-Z0-9]?/.test(flag));
-  }
-  if (executable === 'awk') {
-    return flags.some((flag, index) => flag === '-i' && flags[index + 1] === 'inplace');
+    return flags.some(flag => [
+      '-exec', '-execdir', '-delete', '-ok', '-okdir',
+      '-fprint', '-fprint0', '-fprintf', '-fls'
+    ].includes(flag));
+  }
+  if (executable === 'rg') {
+    return flags.some(flag => flag === '--pre' || flag.startsWith('--pre='));
+  }
+  if (executable === 'sort') {
+    return flags.some(flag => flag === '-o'
+      || flag.startsWith('-o')
+      || flag === '--output'
+      || flag.startsWith('--output=')
+      || flag === '-T'
+      || flag.startsWith('-T')
+      || flag === '--temporary-directory'
+      || flag.startsWith('--temporary-directory='));
+  }
+  if (executable === 'latexmk') {
+    return !flags.includes('-norc')
+      || flags.some(isUnsafeLatexmkArgument)
+      || flags.some(isUnsafeTexEngineArgument);
+  }
+  if (['pdflatex', 'xelatex', 'lualatex'].includes(executable)) {
+    if (executable === 'lualatex' && !flags.some(flag => flag === '--safer' || flag === '-safer')) {
+      return true;
+    }
+    return flags.some(isUnsafeTexEngineArgument);
   }
   if (executable === 'shasum' || executable === 'md5sum') {
     return flags.some(flag => flag === '-c' || flag === '--check');
@@ -1215,6 +1236,28 @@ function hasDisallowedCommandArguments(executable, args = []) {
   return false;
 }
 
+function isUnsafeLatexmkArgument(value) {
+  const flag = String(value || '').toLowerCase();
+  return /^-(?:e|r)(?:$|=)/.test(flag)
+    || /^-(?:usepretex|useposttex)(?:$|=)/.test(flag)
+    || /^-(?:pdflatex|xelatex|lualatex|latex|bibtex|biber|makeindex|dvi_filter|ps_filter|pdf_previewer)(?:$|=)/.test(flag);
+}
+
+function isUnsafeTexEngineArgument(value) {
+  const flag = String(value || '').toLowerCase();
+  if (/(?:shell-escape|shell-restricted|write18)/.test(flag)) {
+    return true;
+  }
+  if (/^--?(?:output-directory|aux-directory|outdir|auxdir)(?:$|=)/.test(flag)) {
+    return true;
+  }
+  if (flag === '-jobname' || flag === '--jobname') {
+    return true;
+  }
+  const jobName = flag.match(/^--?jobname=(.*)$/)?.[1] || '';
+  return Boolean(jobName && (jobName.includes('..') || /[\\/]/.test(jobName)));
+}
+
 function pathBasename(value) {
   return String(value || '').split(/[\\/]/).pop();
 }

package/native-host/src/mirrorWorkspace.js

@@ -42,8 +42,13 @@ async function syncOverleafToMirror({ projectId, project, rootDir }) {
   const previous = readBaseline(mirror.baselinePath);
   const fullProjectSnapshot = project?.capabilities?.fullProjectSnapshot !== false;
 
+  const mirrorRoot = path.dirname(mirror.projectRoot);
+  assertSafeMirrorPathBeforeCreate(mirror.workspacePath, mirrorRoot);
+  assertSafeMirrorPathBeforeCreate(mirror.metadataPath, mirrorRoot);
   fs.mkdirSync(mirror.workspacePath, { recursive: true });
   fs.mkdirSync(mirror.metadataPath, { recursive: true });
+  assertSafeMirrorPathBeforeCreate(mirror.workspacePath, mirrorRoot);
+  assertSafeMirrorPathBeforeCreate(mirror.metadataPath, mirrorRoot);
 
   if (fullProjectSnapshot) {
     for (const filePath of listWorkspaceFiles(mirror.workspacePath)) {
@@ -52,6 +57,7 @@ async function syncOverleafToMirror({ projectId, project, rootDir }) {
       }
       const target = resolveWorkspacePath(mirror.workspacePath, filePath);
       if (fs.existsSync(target)) {
+        assertSafeWorkspaceTarget(mirror.workspacePath, target, filePath);
         fs.rmSync(target, { force: true });
         removeEmptyParents(path.dirname(target), mirror.workspacePath);
       }
@@ -63,6 +69,7 @@ async function syncOverleafToMirror({ projectId, project, rootDir }) {
 
   for (const file of files) {
     const target = resolveWorkspacePath(mirror.workspacePath, file.path);
+    assertSafeWorkspaceTarget(mirror.workspacePath, target, file.path);
     const prev = previousByPath.get(file.path);
     const nextHash = hashProjectFile(file);
     if (prev && prev.hash === nextHash && workspaceFileMatchesBaseline(target, prev)) {
@@ -530,6 +537,9 @@ function listWorkspaceFiles(workspacePath) {
       }
       const relative = prefix ? `${prefix}/${entry.name}` : entry.name;
       const absolute = path.join(dir, entry.name);
+      if (entry.isSymbolicLink()) {
+        throw new Error(`Unsafe mirror symlink: ${relative}`);
+      }
       if (entry.isDirectory()) {
         walk(absolute, relative);
       } else if (entry.isFile()) {
@@ -753,6 +763,7 @@ async function applyFileOverlays({ projectId, overlays, rootDir }) {
     }
     const normalizedPath = normalizeRelativePath(overlay.path);
     const target = resolveWorkspacePath(mirror.workspacePath, normalizedPath);
+    assertSafeWorkspaceTarget(mirror.workspacePath, target, normalizedPath);
     fs.mkdirSync(path.dirname(target), { recursive: true });
     fs.writeFileSync(target, overlay.content, 'utf8');
 
@@ -803,6 +814,9 @@ async function confirmWritebackFiles({ projectId, paths, rootDir }) {
     } catch (error) {
       return { ok: false, reason: 'unsafe_path', path: normalizedPath };
     }
+    if (!isSafeWorkspaceWriteTarget(mirror.workspacePath, target)) {
+      return { ok: false, reason: 'unsafe_path', path: normalizedPath };
+    }
     let content;
     try {
       content = fs.readFileSync(target, 'utf8');
@@ -1017,6 +1031,34 @@ function isSafeWorkspaceWriteTarget(workspacePath, target) {
   }
 }
 
+function assertSafeWorkspaceTarget(workspacePath, target, filePath = '') {
+  if (!isSafeWorkspaceWriteTarget(workspacePath, target)) {
+    throw new Error(`Unsafe mirror path: ${filePath || target}`);
+  }
+}
+
+function assertSafeMirrorPathBeforeCreate(target, boundary) {
+  const root = path.resolve(boundary);
+  const resolvedTarget = path.resolve(target);
+  if (resolvedTarget === root || !resolvedTarget.startsWith(root + path.sep)) {
+    throw new Error(`Unsafe mirror root path: ${target}`);
+  }
+  let current = root;
+  const parts = path.relative(root, resolvedTarget).split(path.sep).filter(Boolean);
+  for (let index = -1; index < parts.length; index += 1) {
+    if (index >= 0) {
+      current = path.join(current, parts[index]);
+    }
+    if (!fs.existsSync(current)) {
+      continue;
+    }
+    const stat = fs.lstatSync(current);
+    if (stat.isSymbolicLink() || (index < parts.length - 1 && !stat.isDirectory())) {
+      throw new Error(`Unsafe mirror root path: ${current}`);
+    }
+  }
+}
+
 function markMirrorDirty({ projectId, rootDir, reason = 'dirty_mirror' }) {
   const mirror = getProjectMirror(projectId, { rootDir });
   const baseline = readBaseline(mirror.baselinePath);
@@ -1040,6 +1082,9 @@ function verifyWorkspaceMatchesBaseline(workspacePath, baselineFiles = []) {
     if (!fs.existsSync(target)) {
       return { ok: false, reason: 'workspace_mismatch', path: file.path };
     }
+    if (!isSafeWorkspaceWriteTarget(workspacePath, target)) {
+      return { ok: false, reason: 'unsafe_path', path: file.path };
+    }
     if (file.kind === 'binary') {
       if (hashBytes(fs.readFileSync(target)) !== file.hash) {
         return { ok: false, reason: 'workspace_mismatch', path: file.path };

package/native-host/src/updateManager.js

@@ -172,6 +172,23 @@ async function stageCandidate(context, options = {}) {
   if (!isNewerStableVersion(manifest.version, activeVersion)) {
     throw updateError('update_candidate_stale', 'The staged update is no longer newer than the active version.');
   }
+  const existingJournal = readJournal(context);
+  if (existingJournal?.state === 'staged' && existingJournal.targetVersion === manifest.version) {
+    try {
+      verifyStagedPair(existingJournal.payloadRoot, manifest.version);
+      return {
+        transactionId: existingJournal.id,
+        targetVersion: existingJournal.targetVersion,
+        state: existingJournal.state,
+        reused: true
+      };
+    } catch (_error) {
+      cleanupStage(existingJournal.stageRoot);
+    }
+  }
+  if (existingJournal && ['applying', 'awaiting_health'].includes(existingJournal.state)) {
+    throw updateError('update_transaction_in_progress', 'A managed update transaction is already being applied.');
+  }
   const transactionId = crypto.randomUUID();
   const stageRoot = path.join(context.updatesRoot, 'staging-' + transactionId);
   fs.mkdirSync(stageRoot, { recursive: true, mode: 0o700 });
@@ -202,6 +219,7 @@ async function stageCandidate(context, options = {}) {
     updatedAt: new Date().toISOString()
   };
   writeJournal(context, journal);
+  cleanupOrphanStageRoots(context.updatesRoot, [stageRoot]);
   return { transactionId, targetVersion: manifest.version, state: journal.state };
 }
 
@@ -247,6 +265,7 @@ function applyStagedUpdate(context, params = {}, options = {}) {
     atomicWriteText(path.join(context.nativeRoot, 'previous-version'), journal.sourceVersion + '\n');
     atomicWriteText(path.join(context.nativeRoot, 'active-version'), journal.targetVersion + '\n');
     rewriteManagedManifestVersion(manifestPath, journal.targetVersion);
+    syncManagedMarkerVersions(context, journal.targetVersion);
   } catch (error) {
     rollbackFiles(context, { ...journal, previousManifest });
     throw updateError('update_apply_failed', 'Managed update could not be applied atomically.', { cause: error });
@@ -282,6 +301,7 @@ function confirmUpdate(context, params = {}) {
   });
   pruneNativeVersions(context.nativeRoot, new Set([journal.targetVersion, journal.sourceVersion]));
   cleanupStage(journal.stageRoot);
+  cleanupOrphanStageRoots(context.updatesRoot);
   return { version: journal.targetVersion, state: 'committed' };
 }
 
@@ -306,6 +326,7 @@ function rollbackUpdate(context, params = {}) {
     previousManifest: undefined
   });
   cleanupStage(journal.stageRoot);
+  cleanupOrphanStageRoots(context.updatesRoot);
   return { version: journal.sourceVersion, state: 'rolled_back' };
 }
 
@@ -329,6 +350,45 @@ function rollbackFiles(context, journal) {
   } else {
     fs.rmSync(path.join(context.nativeRoot, 'previous-version'), { force: true });
   }
+  if (parseSemver(journal.sourceVersion)) {
+    syncManagedMarkerVersions(context, journal.sourceVersion);
+  }
+}
+
+function syncManagedMarkerVersions(context, version) {
+  rewriteManagedMarkerVersion(context.extensionRoot, EXTENSION_MARKER, 'extension', version);
+  rewriteManagedMarkerVersion(context.nativeRoot, NATIVE_MARKER, 'native', version);
+}
+
+function rewriteManagedMarkerVersion(root, filename, kind, version) {
+  const markerPath = path.join(root, filename);
+  const marker = readJsonSafe(markerPath, null);
+  if (!isManagedMarker(marker, kind)) {
+    throw updateError('update_marker_invalid', `The managed ${kind} marker is missing or invalid.`);
+  }
+  atomicWriteJson(markerPath, {
+    ...marker,
+    version,
+    updatedAt: new Date().toISOString()
+  });
+}
+
+function cleanupOrphanStageRoots(updatesRoot, retainedRoots = []) {
+  const resolvedRoot = path.resolve(String(updatesRoot || ''));
+  if (!resolvedRoot || resolvedRoot === path.parse(resolvedRoot).root) return;
+  const retained = new Set((retainedRoots || []).map(value => path.resolve(String(value || ''))));
+  let entries;
+  try {
+    entries = fs.readdirSync(resolvedRoot, { withFileTypes: true });
+  } catch (_error) {
+    return;
+  }
+  for (const entry of entries) {
+    if (!entry.isDirectory() || !/^staging-[0-9a-f-]{36}$/i.test(entry.name)) continue;
+    const candidate = path.join(resolvedRoot, entry.name);
+    if (retained.has(path.resolve(candidate))) continue;
+    fs.rmSync(candidate, { recursive: true, force: true });
+  }
 }
 
 function recoverAndReadStatus(context) {
@@ -539,10 +599,13 @@ module.exports = {
   GITHUB_LATEST_URL,
   applyStagedUpdate,
   checkForUpdate,
+  cleanupOrphanStageRoots,
   confirmUpdate,
   getApplyGate,
   getManagedContext,
   handleUpdateRequest,
   isUpdateMethod,
-  rollbackUpdate
+  rollbackUpdate,
+  stageCandidate,
+  syncManagedMarkerVersions
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codex-overleaf-link",
-  "version": "1.9.1",
+  "version": "1.9.3",
   "description": "Cross-platform Chrome bridge that connects Codex to the active Overleaf project.",
   "license": "MIT",
   "type": "commonjs",