codex-overleaf-link 2.5.0 → 2.5.1

package/native-host/src/codexSkillIsolation.js

@@ -0,0 +1,170 @@
+'use strict';
+
+const fs = require('node:fs');
+const path = require('node:path');
+const { getCodexOverleafSkillsRoot } = require('./localSkills');
+const { createCodexLocalSkillIdentity } = require('./codexLocalSkills');
+
+async function applyCodexSkillIsolation({ input = {}, childEnv = process.env, request, emit = () => {} } = {}) {
+  if (input.loadCodexLocalSkills !== false && input.loadCodexOverleafSkills !== false
+    && !Array.isArray(input.enabledCodexOverleafSkillIds) && !Array.isArray(input.disableCodexOverleafSkillIds)
+    && !Array.isArray(input.enabledCodexLocalSkillIds)) {
+    return { disabled: [] };
+  }
+  if (typeof request !== 'function') {
+    throw new Error('Codex skill isolation requires an app-server request function');
+  }
+
+  const listResult = await request('skills/list', {
+    cwd: input.workspacePath,
+    includeDisabled: true,
+    ...(input.workspacePath ? { cwds: [input.workspacePath] } : {}),
+    forceReload: true
+  });
+  if (Array.isArray(input.enabledCodexLocalSkillIds) && (!Array.isArray(listResult?.data)
+    || listResult.data.some(group => !Array.isArray(group?.skills)
+      || (group.errors !== undefined && !Array.isArray(group.errors))))) {
+    throw Object.assign(new Error('Local Codex skills could not be prepared. Refresh the skill list and try again.'),
+      { code: 'codex_local_skill_unavailable' });
+  }
+  const skills = flattenCodexSkillsList(listResult);
+  const disabled = [];
+  const enabled = [];
+  for (const skill of skills) {
+    const localSelection = getLocalSkillSelection(skill, input, childEnv);
+    const shouldDisable = shouldDisableCodexSkillForIsolation(skill, input, childEnv);
+    if (localSelection === true && skill?.enabled === false) {
+      const params = buildSkillDisableParams(skill, { preferPath: true });
+      if (params) {
+        await request('skills/config/write', { ...params, enabled: true });
+        enabled.push(String(skill.name || skill.path || '').trim());
+      }
+      continue;
+    }
+    if (skill?.enabled === false || !shouldDisable) {
+      continue;
+    }
+    const params = buildSkillDisableParams(skill, { preferPath: localSelection !== null });
+    if (!params) {
+      continue;
+    }
+    await request('skills/config/write', params);
+    disabled.push(String(skill.name || skill.path || '').trim());
+  }
+  if (disabled.length) {
+    emitCodexEvent(emit, 'codex.skill_isolation.applied', 'Applied Codex skill loading settings for this turn', {
+      disabledSkillNames: disabled.filter(Boolean)
+    }, 'completed');
+  }
+  return { disabled, enabled };
+}
+
+function getLocalSkillSelection(skill, input, childEnv) {
+  if (!Array.isArray(input.enabledCodexLocalSkillIds)
+    || getOverleafSkillId(skill.path, input, childEnv)) return null;
+  if (isCodexSystemSkill(skill) && isAllowedSystemSkillForIsolation(skill, input)) return true;
+  if (input.loadCodexLocalSkills === false) return false;
+  const id = createCodexLocalSkillIdentity(skill, childEnv);
+  return Boolean(id) && input.enabledCodexLocalSkillIds.includes(id);
+}
+
+function flattenCodexSkillsList(listResult = {}) {
+  const data = Array.isArray(listResult?.data) ? listResult.data : [];
+  return data.flatMap(entry => Array.isArray(entry?.skills) ? entry.skills : []);
+}
+
+function shouldDisableCodexSkillForIsolation(skill = {}, input = {}, childEnv = process.env) {
+  const localSelection = getLocalSkillSelection(skill, input, childEnv);
+  if (localSelection !== null) return !localSelection;
+  if (isCodexSystemSkill(skill)) {
+    return input.loadCodexLocalSkills === false && !isAllowedSystemSkillForIsolation(skill, input);
+  }
+  const id = getOverleafSkillId(skill.path, input, childEnv);
+  if (id && input.installCodexOverleafSkillsTarget !== true) {
+    if (input.loadCodexOverleafSkills === false) return true;
+    if (Array.isArray(input.enabledCodexOverleafSkillIds) && !input.enabledCodexOverleafSkillIds.includes(id)) return true;
+    if (Array.isArray(input.disableCodexOverleafSkillIds) && input.disableCodexOverleafSkillIds.includes(id)) return true;
+  }
+  return input.loadCodexLocalSkills === false && !isAllowedCodexOverleafSkillPath(skill.path, input, childEnv);
+}
+
+function getOverleafSkillId(skillPath, input, childEnv) {
+  if (!skillPath || !path.isAbsolute(String(skillPath))) return '';
+  const roots = [getCodexOverleafSkillsRoot({ env: childEnv })];
+  // A composed home with local inheritance disabled contains only plugin or
+  // explicitly materialized project skills. Real paths identify plugin aliases.
+  if (input.loadCodexLocalSkills === false) roots.push(path.join(String(childEnv.CODEX_HOME || ''), 'skills'));
+  for (const root of roots) for (const base of comparablePaths(root)) for (const candidate of comparablePaths(skillPath)) {
+    const relative = path.relative(base, candidate);
+    if (relative && !relative.startsWith('..') && !path.isAbsolute(relative)) return relative.split(path.sep)[0];
+  }
+  return '';
+}
+
+function isCodexSystemSkill(skill = {}) {
+  return String(skill.scope || '') === 'system' || isSystemSkillPath(skill.path);
+}
+
+function isAllowedSystemSkillForIsolation(skill = {}, input = {}) {
+  return input.installCodexOverleafSkillsTarget === true && String(skill.name || '') === 'skill-installer';
+}
+
+function isAllowedCodexOverleafSkillPath(skillPath, input = {}, childEnv = process.env) {
+  if (input.loadCodexOverleafSkills === false && input.installCodexOverleafSkillsTarget !== true) {
+    return false;
+  }
+  const pathText = String(skillPath || '');
+  if (!pathText || !path.isAbsolute(pathText) || isSystemSkillPath(pathText)) {
+    return false;
+  }
+  const roots = [
+    path.join(String(childEnv.CODEX_HOME || ''), 'skills'),
+    getCodexOverleafSkillsRoot({ env: childEnv })
+  ].filter(Boolean);
+  return roots.some(root => isInsideOrSamePath(pathText, root));
+}
+
+function isSystemSkillPath(skillPath) {
+  return String(skillPath || '').split(path.sep).includes('.system');
+}
+
+function buildSkillDisableParams(skill = {}, { preferPath = false } = {}) {
+  const name = String(skill.name || '').trim();
+  const skillPath = String(skill.path || '').trim();
+  if (preferPath && path.isAbsolute(skillPath)) return { path: skillPath, enabled: false };
+  if (isCodexSystemSkill(skill) && name) {
+    return { name, enabled: false };
+  }
+  if (path.isAbsolute(skillPath)) {
+    return { path: skillPath, enabled: false };
+  }
+  if (name) {
+    return { name, enabled: false };
+  }
+  return null;
+}
+
+function isInsideOrSamePath(target, root) {
+  const targetPaths = comparablePaths(target);
+  const rootPaths = comparablePaths(root);
+  return targetPaths.some(targetPath => rootPaths.some(rootPath => (
+    targetPath === rootPath || targetPath.startsWith(rootPath + path.sep)
+  )));
+}
+
+function comparablePaths(value) {
+  const resolved = path.resolve(String(value || ''));
+  const candidates = [resolved];
+  try {
+    candidates.push(fs.realpathSync.native(resolved));
+  } catch (_) {
+    // Fall back to the lexical path when the file is not present yet.
+  }
+  return Array.from(new Set(candidates));
+}
+
+function emitCodexEvent(emit, type, title, detail = {}, status = 'running') {
+  emit({ type, title, status, detail, timestamp: new Date().toISOString() });
+}
+
+module.exports = { applyCodexSkillIsolation };

package/native-host/src/codexThreadFork.js

@@ -1,5 +1,7 @@
 'use strict';
 
+const { runOwnedNativeHelper } = require('./nativeHelperLifecycle');
+const { stopCodexAppServer, throwIfAborted } = require('./codexSessionTiming');
 const { spawn } = require('node:child_process');
 const { version: PACKAGE_VERSION } = require('../../package.json');
 const { buildCodexHomeEnv } = require('./codexHome');
@@ -7,9 +9,17 @@ const { resolveCodexCommand, shouldUseShellForCommand } = require('./codexComman
 const { buildCodexAppServerArgs } = require('./codexSessionRunner');
 
 function forkCodexThread(params = {}, env = process.env) {
+  return runOwnedNativeHelper(signal => runForkProcess(params, env, signal));
+}
+
+function runForkProcess(params, env, signal) {
+  throwIfAborted(signal);
   const threadId = cleanId(params.threadId, 'threadId');
   const lastTurnId = cleanId(params.lastTurnId, 'lastTurnId');
   const childEnv = buildCodexHomeEnv(env, {
+    isolateRuntimeHome: true,
+    enabledCodexOverleafSkillIds: params.enabledCodexOverleafSkillIds,
+    enabledCodexLocalSkillIds: params.enabledCodexLocalSkillIds,
     loadCodexLocalSkills: params.loadCodexLocalSkills !== false,
     loadCodexOverleafSkills: params.loadCodexOverleafSkills !== false
   });
@@ -23,6 +33,7 @@ function forkCodexThread(params = {}, env = process.env) {
     }), {
       env: childEnv,
       shell: shouldUseShellForCommand(command, childEnv),
+      detached: process.platform !== 'win32',
       stdio: ['pipe', 'pipe', 'pipe']
     });
     const pending = new Map();
@@ -30,6 +41,8 @@ function forkCodexThread(params = {}, env = process.env) {
     let buffer = '';
     let stderr = '';
     let settled = false;
+    const onAbort = () => finish(signal.reason);
+    signal.addEventListener('abort', onAbort, { once: true });
     const timeout = setTimeout(() => finish(codedError('codex_thread_fork_timeout', 'Codex thread fork timed out.')), 30000);
 
     child.stdout.setEncoding('utf8');
@@ -41,12 +54,14 @@ function forkCodexThread(params = {}, env = process.env) {
       for (const line of lines) if (line.trim()) handleMessage(line);
     });
     child.stderr.on('data', chunk => { stderr += chunk; });
+    child.stdin.on('error', finish);
     child.on('error', finish);
     child.on('close', code => {
       if (!settled) finish(codedError('codex_thread_fork_failed', stderr || `Codex app-server exited with code ${code}.`));
     });
 
     (async () => {
+      throwIfAborted(signal);
       await request('initialize', {
         clientInfo: { name: 'codex-overleaf-link', version: PACKAGE_VERSION },
         capabilities: null
@@ -85,11 +100,12 @@ function forkCodexThread(params = {}, env = process.env) {
       if (settled) return;
       settled = true;
       clearTimeout(timeout);
+      signal.removeEventListener('abort', onAbort);
       for (const waiter of pending.values()) waiter.reject(error || codedError('codex_thread_fork_closed', 'Fork process closed.'));
       pending.clear();
-      try { child.stdin.end(); } catch (_error) { /* best effort */ }
-      try { child.kill(); } catch (_error) { /* best effort */ }
-      if (error) reject(error); else resolve(result);
+      stopCodexAppServer(child, { processGroup: process.platform !== 'win32', reason: error }).then(() => {
+        if (error) reject(error); else resolve(result);
+      }, reject);
     }
   });
 }

package/native-host/src/index.js

@@ -4,8 +4,8 @@
 const { decodeInputFrames, encodeOutputFrame } = require('./nativeTransportEnvelope');
 const { logDebug } = require('./debugLog');
 const { handleRequest } = require('./taskRunner');
-const { abortAllActiveOperations, getActiveNativeWorkState } = require('./taskRunnerRuntime');
-const { handleUpdateRequest, isUpdateMethod } = require('./updateManager');
+const { abortAllActiveOperations, quarantineActiveOperations, getActiveNativeWorkState } = require('./taskRunnerRuntime');
+const { handleUpdateRequest, isUpdateMethod, assertBootstrapBusinessAvailable } = require('./updateManager');
 const { buildNativeRuntimeEnv, summarizeNativeEnvironment } = require('./nativeEnvironment');
 
 let buffered = Buffer.alloc(0);
@@ -41,12 +41,14 @@ process.stdin.on('data', chunk => {
 });
 
 async function handleDecodedMessage(message) {
+  if (nativeDisconnectHandled) return;
   try {
     logDebug('request.received', summarizeRequest(message));
+    assertBootstrapBusinessAvailable(message, { env: runtimeEnv });
     const response = isUpdateMethod(message?.method)
       ? await handleUpdateRequest(message, {
           env: runtimeEnv,
-          getWorkState: getActiveNativeWorkState
+          getWorkState: () => getActiveNativeWorkState(runtimeEnv)
         })
       : await handleRequest(message, runtimeEnv, event => {
       writeResponse({
@@ -62,7 +64,7 @@ async function handleDecodedMessage(message) {
       id: message?.id,
       ok: false,
       error: {
-        code: 'internal_error',
+        code: /^[a-z0-9_]{1,80}$/.test(String(error?.code || '')) ? error.code : 'internal_error',
         message: error.message
       }
     };
@@ -145,10 +147,20 @@ function handleNativeDisconnect(source, error) {
     code: error?.code,
     message: error?.message
   });
-  abortAllActiveOperations('Native messaging transport disconnected.');
   process.exitCode = 0;
-  const exitTimer = setTimeout(() => process.exit(0), 1500);
-  exitTimer.unref?.();
+  // Publish protection before stopping: another Host may reconnect while the
+  // old owned process is still inside its interrupt/termination budget.
+  quarantineActiveOperations();
+  const exitTimer = setTimeout(() => {
+    const failures = quarantineActiveOperations();
+    logDebug('native_transport.shutdown_deadline', { persistenceFailures: failures });
+    process.exit(failures.length ? 1 : 0);
+  }, 5000);
+  // Keep the prior grace for other entry points while owned Codex runs drain.
+  Promise.all([
+    abortAllActiveOperations('Native messaging transport disconnected.'),
+    new Promise(resolve => setTimeout(resolve, 1500))
+  ]).then(() => { clearTimeout(exitTimer); process.exit(0); });
 }
 
 function summarizeRequest(message) {

package/native-host/src/managedInstall.js

@@ -18,8 +18,11 @@ const {
   getDefaultManagedRoot,
   getNativeHostRegistrationTarget
 } = require('./nativeHostPlatform');
+const { queryWindowsNativeHostRegistration } = require('./nativeHostRegistration');
 const { buildRuntimeFileManifest } = require('./runtimeInstaller');
 const { BOOTSTRAP_PROTOCOL, parseSemver, updateError } = require('./updateTrust');
+const { createInstallRestorePoint } = require('./managedInstallRecovery');
+const { settleReinstalledUpdate } = require('./updateManager');
 
 const MANAGED_BY = 'codex-overleaf-link';
 const EXTENSION_MARKER = '.codex-overleaf-managed-extension.json';
@@ -61,51 +64,91 @@ function installManagedDistribution(options = {}) {
       version,
       releaseRef,
       releaseChannel,
-      allowedFiles: options.allowedFiles
+      allowedFiles: options.allowedFiles,
+      installIdentity: { managedRoot, browser: browser === 'auto' ? 'chrome' : browser, extensionId, platform }
     });
   } catch (error) {
     safeRemove(extensionStage);
     throw error;
   }
 
-  const previousExtensionMarker = readManagedMarker(extensionRoot, EXTENSION_MARKER);
+  let previousExtensionMarker = readManagedMarker(extensionRoot, EXTENSION_MARKER);
   if (fs.existsSync(extensionRoot) && !isManagedMarker(previousExtensionMarker, 'extension')) {
     safeRemove(extensionStage);
     throw new Error('Refusing to replace an unmarked managed extension root: ' + extensionRoot);
   }
   let extensionRollbackCreated = false;
+  let restorePoint;
+  let previousTransaction;
+  const registration = getNativeHostRegistrationTarget({ platform, browser, env });
+  const bridgePath = getDefaultBridgePath({ platform, browser, env });
+  let previousRegistration = null;
+  let registrationAttempted = false;
   try {
+    const nativeMarker = readManagedMarker(nativeRoot, NATIVE_MARKER);
+    if (fs.existsSync(nativeRoot) && !isManagedMarker(nativeMarker, 'native')) {
+      throw new Error('Refusing to replace an unmarked managed native root: ' + nativeRoot);
+    }
+    restorePoint = createInstallRestorePoint({ nativeRoot, version, files: [
+      path.join(nativeRoot, 'active-version'), path.join(nativeRoot, 'previous-version'),
+      path.join(nativeRoot, NATIVE_MARKER), path.join(nativeRoot, 'bootstrap', 'launcher.js'),
+      path.join(nativeRoot, 'updates', 'transaction.json'), path.join(nativeRoot, 'updates', 'authorization.json'),
+      path.join(managedRoot, '.codex-overleaf-managed.json'), bridgePath, registration.manifestPath
+    ] });
+    previousExtensionMarker = readManagedMarker(extensionRoot, EXTENSION_MARKER);
+    if (fs.existsSync(extensionRoot) && !isManagedMarker(previousExtensionMarker, 'extension')) {
+      throw new Error('Refusing to replace an unmarked managed extension root: ' + extensionRoot);
+    }
+    previousRegistration = registration.kind === 'registry'
+      ? queryWindowsNativeHostRegistration(registration, { env }) : null;
+    previousTransaction = readManagedMarker(path.join(nativeRoot, 'updates'), 'transaction.json');
     if (fs.existsSync(extensionRoot)) {
       fs.renameSync(extensionRoot, extensionRollback);
       extensionRollbackCreated = true;
     }
     fs.renameSync(extensionStage, extensionRoot);
-  } catch (error) {
-    safeRemove(extensionStage);
-    if (extensionRollbackCreated && !fs.existsSync(extensionRoot)) {
-      fs.renameSync(extensionRollback, extensionRoot);
-    }
-    throw error;
-  }
-
-  try {
-    installManagedNativeVersion({ packageRoot, nativeRoot, version, releaseRef, releaseChannel });
+    installManagedNativeVersion({ packageRoot, nativeRoot, version, releaseRef, releaseChannel,
+      allowUnmarkedRoot: !restorePoint.nativeExisted });
     installManagedNativeRegistration({
       browser,
       env,
       extensionId,
       managedRoot,
       nativeRoot,
-      platform
+      platform,
+      onRegistryMutation: () => { registrationAttempted = true; }
     });
-    safeRemove(extensionRollback);
+    settleReinstalledUpdate({ managed: true, nativeRoot, extensionRoot,
+      updatesRoot: path.join(nativeRoot, 'updates'), env }, version, previousTransaction);
   } catch (error) {
-    safeRemove(extensionRoot);
-    if (extensionRollbackCreated && fs.existsSync(extensionRollback)) {
-      fs.renameSync(extensionRollback, extensionRoot);
+    const failures = [];
+    try {
+      safeRemove(extensionStage);
+      if (extensionRollbackCreated && fs.existsSync(extensionRollback)) {
+        safeRemove(extensionRoot);
+        fs.renameSync(extensionRollback, extensionRoot);
+      } else if (!previousExtensionMarker && restorePoint) safeRemove(extensionRoot);
+    } catch (failure) { failures.push(failure); }
+    if (restorePoint) {
+      try { restorePoint.restore(); } catch (failure) { failures.push(failure); }
+      if (registrationAttempted && registration.kind === 'registry') {
+        try {
+          if (!previousRegistration?.registeredManifestPath) throw new Error('Previous browser registration could not be verified.');
+          runRegistry(['add', registration.registryKey, '/ve', '/t', 'REG_SZ', '/d', previousRegistration.registeredManifestPath, '/f']);
+        } catch (failure) { failures.push(failure); }
+      }
+      try { failures.length ? restorePoint.release() : restorePoint.finish(); }
+      catch (failure) { failures.push(failure); }
     }
+    if (failures.length) throw updateError('managed_install_restore_failed',
+      'Managed installation failed and the previous installation could not be fully restored.', { cause: error });
     throw error;
   }
+  // The installed pair is committed. Cleanup errors must not trigger a second
+  // rollback after some of its retained files have already been removed.
+  const warnings = [];
+  try { safeRemove(extensionRollback); } catch (_) { warnings.push('Previous extension cleanup is incomplete.'); }
+  try { restorePoint.finish(); } catch (_) { warnings.push('Previous Native installation cleanup is incomplete.'); }
 
   return {
     ok: true,
@@ -117,7 +160,8 @@ function installManagedDistribution(options = {}) {
     extensionRoot,
     nativeRoot,
     loadUnpackedPath: extensionRoot,
-    allowedOrigin: buildAllowedOrigin(extensionId)
+    allowedOrigin: buildAllowedOrigin(extensionId),
+    ...(warnings.length ? { warning: warnings.join(' ') } : {})
   };
 }
 
@@ -154,6 +198,7 @@ function buildManagedExtensionTree(options = {}) {
   fs.writeFileSync(path.join(targetRoot, EXTENSION_MARKER), JSON.stringify({
     managedBy: MANAGED_BY,
     kind: 'extension',
+    ...(options.installIdentity ? { installIdentity: options.installIdentity } : {}),
     bootstrapProtocol: BOOTSTRAP_PROTOCOL,
     version,
     releaseRef,
@@ -163,9 +208,9 @@ function buildManagedExtensionTree(options = {}) {
   return { targetRoot, version };
 }
 
-function installManagedNativeVersion({ packageRoot, nativeRoot, version, releaseRef = `v${version}`, releaseChannel = 'stable' }) {
+function installManagedNativeVersion({ packageRoot, nativeRoot, version, releaseRef = `v${version}`, releaseChannel = 'stable', allowUnmarkedRoot = false }) {
   const marker = readManagedMarker(nativeRoot, NATIVE_MARKER);
-  if (fs.existsSync(nativeRoot) && !isManagedMarker(marker, 'native')) {
+  if (fs.existsSync(nativeRoot) && !isManagedMarker(marker, 'native') && !allowUnmarkedRoot) {
     throw new Error('Refusing to replace an unmarked managed native root: ' + nativeRoot);
   }
   fs.mkdirSync(path.join(nativeRoot, 'versions'), { recursive: true });
@@ -174,18 +219,21 @@ function installManagedNativeVersion({ packageRoot, nativeRoot, version, release
 
   const stage = path.join(nativeRoot, 'versions', '.' + version + '.staging-' + process.pid + '-' + Date.now());
   const target = path.join(nativeRoot, 'versions', version);
-  for (const entry of buildRuntimeFileManifest({ packageRoot })) {
-    copyFile(entry.sourcePath, path.join(stage, entry.relativePath));
-  }
-  fs.writeFileSync(path.join(stage, '.codex-overleaf-version.json'), JSON.stringify({
-    version,
-    releaseRef,
-    releaseChannel
-  }, null, 2) + '\n');
-  if (fs.existsSync(target)) {
-    safeRemove(target);
+  try {
+    for (const entry of buildRuntimeFileManifest({ packageRoot })) {
+      copyFile(entry.sourcePath, path.join(stage, entry.relativePath));
+    }
+    fs.writeFileSync(path.join(stage, '.codex-overleaf-version.json'), JSON.stringify({
+      version,
+      releaseRef,
+      releaseChannel
+    }, null, 2) + '\n');
+    if (fs.existsSync(target)) safeRemove(target);
+    fs.renameSync(stage, target);
+  } catch (error) {
+    safeRemove(stage);
+    throw error;
   }
-  fs.renameSync(stage, target);
 
   copyFile(
     path.join(packageRoot, 'native-host/src/managedLauncherRuntime.js'),
@@ -205,7 +253,7 @@ function installManagedNativeVersion({ packageRoot, nativeRoot, version, release
   }, null, 2) + '\n', 'utf8');
 }
 
-function installManagedNativeRegistration({ browser, env, extensionId, managedRoot, nativeRoot, platform }) {
+function installManagedNativeRegistration({ browser, env, extensionId, managedRoot, nativeRoot, platform, onRegistryMutation }) {
   const bridgePath = getDefaultBridgePath({ platform, browser, env });
   const platformPath = platform === 'win32' ? path.win32 : path.posix;
   const bootstrapEntry = platformPath.join(nativeRoot, 'bootstrap', 'launcher.js');
@@ -226,6 +274,7 @@ function installManagedNativeRegistration({ browser, env, extensionId, managedRo
   fs.mkdirSync(platformPath.dirname(target.manifestPath), { recursive: true });
   fs.writeFileSync(target.manifestPath, JSON.stringify(manifest, null, 2) + '\n', 'utf8');
   if (target.kind === 'registry') {
+    onRegistryMutation?.();
     runRegistry(['add', target.registryKey, '/ve', '/t', 'REG_SZ', '/d', target.manifestPath, '/f']);
   }
   fs.writeFileSync(path.join(managedRoot, '.codex-overleaf-managed.json'), JSON.stringify({
@@ -255,11 +304,19 @@ function uninstallManagedDistribution(options = {}) {
   }
   const registration = getNativeHostRegistrationTarget({ platform, browser, env });
   const bridgePath = getDefaultBridgePath({ platform, browser, env });
-  if (registration.kind === 'registry') {
+  const bridgeOwned = () => isBridgeForManagedRoot(bridgePath, nativeRoot, platform);
+  const manifestOwned = () => {
+    try {
+      const manifest = readJson(registration.manifestPath);
+      return bridgeOwned() && manifest.name === 'com.codex.overleaf' && manifest.path === bridgePath;
+    } catch (_) { return false; }
+  };
+  if (registration.kind === 'registry' && manifestOwned()
+    && queryWindowsNativeHostRegistration(registration, { env }).verified) {
     runRegistry(['delete', registration.registryKey, '/f'], { allowMissing: true });
   }
-  fs.rmSync(registration.manifestPath, { force: true });
-  fs.rmSync(bridgePath, { force: true });
+  if (manifestOwned()) fs.rmSync(registration.manifestPath, { force: true });
+  if (bridgeOwned()) fs.rmSync(bridgePath, { force: true });
   safeRemove(extensionRoot);
   safeRemove(nativeRoot);
   try {
@@ -272,6 +329,24 @@ function uninstallManagedDistribution(options = {}) {
   return { ok: true, managedRoot, extensionRoot, nativeRoot, removed: true };
 }
 
+// Older installs lack ownership metadata. Compare the existing launcher's
+// exact target argument and agent assignment; the Node executable may change.
+function isBridgeForManagedRoot(bridgePath, nativeRoot, platform) {
+  try {
+    const platformPath = platform === 'win32' ? path.win32 : path.posix;
+    const entry = platformPath.join(nativeRoot, 'bootstrap', 'launcher.js');
+    const expected = buildLauncher({ platform, nodePath: '__node__', bridgeEntryPath: entry, agentPath: entry }).split(/\r?\n/);
+    const actual = fs.readFileSync(bridgePath, 'utf8').split(/\r?\n/);
+    const assignment = expected.find(line => line.includes('CODEX_OVERLEAF_AGENT_ARGS_JSON='));
+    const launch = expected.find(line => platform === 'win32' ? line.startsWith('"__node__" ') : line.startsWith('exec "__node__" '));
+    const target = launch.slice(launch.indexOf('"__node__"') + '"__node__"'.length);
+    const invocation = platform === 'win32' ? /^"(?:[^"]|"")*"/ : /^exec "(?:[^"\\]|\\.)+"/;
+    return actual.includes(assignment) && actual.some(line => {
+      const first = line.match(invocation); return first && line.slice(first[0].length) === target;
+    });
+  } catch (_) { return false; }
+}
+
 function assertSafeManagedRoot(root, options = {}) {
   const platformPath = options.platformPath || path;
   const resolved = platformPath.resolve(root);