codex-overleaf-link 2.1.5 → 2.2.0

package/native-host/src/taskRunnerRuntime.js

@@ -34,6 +34,7 @@ const { version: PACKAGE_VERSION } = require('../../package.json');
 
 const activeProjectLocks = new Map();
 const activeRunControllers = new Map();
+const activeRunEntries = new Map();
 // Parallel index of active runs by projectKey so codex.cancel can find a
 // controller even when the original request id is unknown (e.g. after the
 // Overleaf tab was reloaded — the requestId lived in content-side JS state
@@ -106,6 +107,10 @@ async function handleRequest(request, env = process.env, emit = () => {}) {
     return handleCodexRun(request, env, emit);
   }
 
+  if (request.method === 'codex.steer') {
+    return handleCodexSteer(request);
+  }
+
   if (request.method === 'codex.cancel') {
     return handleCodexCancel(request);
   }
@@ -170,9 +175,16 @@ async function handleCodexRun(request, env, emit) {
     return errorResponse(request.id, 'project_locked', `Project ${projectKey} is currently in use by codex.run`);
   }
   const abortController = new AbortController();
+  const activeEntry = {
+    id: request.id || '',
+    projectKey,
+    controller: abortController,
+    control: null
+  };
   if (request.id) {
     activeRunControllers.set(request.id, abortController);
-    activeRunByProject.set(projectKey, { id: request.id, controller: abortController });
+    activeRunEntries.set(request.id, activeEntry);
+    activeRunByProject.set(projectKey, activeEntry);
   }
   let providerResolution;
   try {
@@ -232,6 +244,9 @@ async function handleCodexRun(request, env, emit) {
       emit,
       rootDir: env.CODEX_OVERLEAF_MIRROR_ROOT,
       providerLaunch: providerResolution.providerLaunch,
+      onControlReady: control => {
+        activeEntry.control = control;
+      },
       signal: abortController.signal
     });
     const syncChanges = Array.isArray(result.syncChanges) ? result.syncChanges : [];
@@ -265,6 +280,9 @@ async function handleCodexRun(request, env, emit) {
     if (request.id && activeRunControllers.get(request.id) === abortController) {
       activeRunControllers.delete(request.id);
     }
+    if (request.id && activeRunEntries.get(request.id) === activeEntry) {
+      activeRunEntries.delete(request.id);
+    }
     if (activeRunByProject.get(projectKey)?.controller === abortController) {
       activeRunByProject.delete(projectKey);
     }
@@ -272,6 +290,55 @@ async function handleCodexRun(request, env, emit) {
   }
 }
 
+async function handleCodexSteer(request) {
+  const params = request.params || {};
+  const entry = findActiveRunEntry(params);
+  if (!entry?.control) {
+    return errorResponse(request.id, 'codex_turn_not_ready', 'The active Codex turn is not ready for guidance.');
+  }
+  const expectedThreadId = String(params.threadId || '');
+  const expectedTurnId = String(params.expectedTurnId || params.turnId || '');
+  if ((expectedThreadId && expectedThreadId !== entry.control.threadId)
+    || (expectedTurnId && expectedTurnId !== entry.control.turnId)) {
+    return errorResponse(request.id, 'codex_turn_mismatch', 'The active Codex turn changed before the guidance was delivered.');
+  }
+  const inputText = String(
+    params.text
+      || (Array.isArray(params.input)
+        ? params.input.filter(item => item?.type === 'text').map(item => item.text || '').join('\n')
+        : '')
+  ).trim();
+  if (!inputText) {
+    return errorResponse(request.id, 'codex_steer_empty', 'Guidance input is empty.');
+  }
+  if (inputText.length > 12000) {
+    return errorResponse(request.id, 'codex_steer_too_large', 'Guidance input exceeds the 12000 character limit.');
+  }
+  try {
+    await entry.control.steer({
+      input: [{ type: 'text', text: inputText }],
+      clientUserMessageId: String(params.clientUserMessageId || '').slice(0, 160) || undefined
+    });
+    return okResponse(request.id, {
+      accepted: true,
+      requestId: entry.id,
+      threadId: entry.control.threadId,
+      turnId: entry.control.turnId
+    });
+  } catch (error) {
+    return errorResponse(request.id, 'codex_steer_failed', truncateText(error.message, 4000));
+  }
+}
+
+function findActiveRunEntry(params = {}) {
+  const targetId = String(params.requestId || params.id || '');
+  if (targetId && activeRunEntries.has(targetId)) {
+    return activeRunEntries.get(targetId);
+  }
+  const projectKey = String(params.projectKey || '');
+  return projectKey ? activeRunByProject.get(projectKey) : null;
+}
+
 // Cancel paths, in priority order:
 //   1. By requestId (legacy + primary, when the caller still has it)
 //   2. By projectKey (after page refresh — requestId is lost but projectKey
@@ -1207,12 +1274,24 @@ function errorResponse(id, code, message, details = {}) {
 function getActiveNativeWorkState() {
   return {
     projectLocks: activeProjectLocks.size,
-    runControllers: activeRunControllers.size
+    runControllers: activeRunControllers.size,
+    activeTurnControls: Array.from(activeRunEntries.values()).filter(entry => entry.control).length
   };
 }
 
+function abortAllActiveOperations(reason = 'Native messaging transport disconnected.') {
+  const error = new Error(String(reason || 'Native messaging transport disconnected.'));
+  error.code = 'native_transport_closed';
+  for (const controller of activeRunControllers.values()) {
+    if (controller && !controller.signal?.aborted) {
+      controller.abort(error);
+    }
+  }
+}
+
 module.exports = {
   NATIVE_REQUEST_QUOTAS,
+  abortAllActiveOperations,
   buildDefaultTaskResult,
   getActiveNativeWorkState,
   handleRequest,

package/native-host/src/updateArchive.js

@@ -176,11 +176,12 @@ function isAllowedUpdatePath(value) {
   return entryPath === 'extension-runtime/runtime-manifest.json'
     || /^extension-runtime\/src\/.+/.test(entryPath)
     || /^extension-runtime\/styles\/.+/.test(entryPath)
-    || /^extension-runtime\/vendor\/katex\/(?:LICENSE|VERSION|katex\.min\.(?:css|js)|fonts\/[A-Za-z0-9_.-]+\.(?:ttf|woff2?))$/.test(entryPath)
+    || /^extension-runtime\/vendor\/.+/.test(entryPath)
+    || /^extension-runtime\/assets\/.+/.test(entryPath)
     || entryPath === 'native-runtime/package.json'
-    || /^native-runtime\/native-host\/src\/.+/.test(entryPath)
+    || /^native-runtime\/native-host\/.+/.test(entryPath)
     || /^native-runtime\/extension\/src\/shared\/.+/.test(entryPath)
-    || /^native-runtime\/scripts\/(?:codex-json-agent|install-native-host|uninstall-native-host)\.mjs$/.test(entryPath);
+    || /^native-runtime\/scripts\/.+/.test(entryPath);
 }
 
 function safeArchiveTarget(root, entryPath) {

package/native-host/src/updateManager.js

@@ -20,7 +20,11 @@ const JOURNAL_FILE = 'transaction.json';
 const CANDIDATE_FILE = 'candidate.json';
 const COOLDOWN_FILE = 'cooldowns.json';
 const AUTHORIZATION_FILE = 'authorization.json';
+const MUTATION_LOCK_FILE = 'mutation.lock';
 const AUTHORIZATION_TTL_MS = 2 * 60 * 60 * 1000;
+const MUTATION_LOCK_WAIT_MS = 10 * 1000;
+const MUTATION_LOCK_STALE_MS = 15 * 60 * 1000;
+const ACTIVATION_DELAY_MS = 125;
 const CONSENT_MIGRATION_TARGET_VERSION = '1.9.4';
 const UPDATE_METHODS = new Set([
   'update.status',
@@ -29,10 +33,19 @@ const UPDATE_METHODS = new Set([
   'update.stage',
   'update.canApply',
   'update.apply',
+  'update.activate',
   'update.confirm',
   'update.rollback',
   'update.revoke'
 ]);
+const LAYOUT_GATED_METHODS = new Set([
+  'update.check',
+  'update.authorize',
+  'update.stage',
+  'update.apply',
+  'update.activate',
+  'update.confirm'
+]);
 const RELEASE_ASSET_HOSTS = new Set([
   'github.com',
   'objects.githubusercontent.com',
@@ -53,25 +66,30 @@ async function handleUpdateRequest(request, options = {}) {
     if (!context.managed) {
       throw updateError('update_not_managed', 'Run install-managed once to enable coordinated automatic updates.');
     }
+    if (LAYOUT_GATED_METHODS.has(request.method)) {
+      assertManagedLayout(context);
+    }
     switch (request.method) {
       case 'update.status':
-        return okResponse(request.id, await withUpdateMutex(() => recoverAndReadStatus(context)));
+        return okResponse(request.id, await withUpdateMutex(context, () => recoverAndReadStatus(context)));
       case 'update.check':
-        return okResponse(request.id, await withUpdateMutex(() => checkForUpdate(context, request.params || {}, options)));
+        return okResponse(request.id, await withUpdateMutex(context, () => checkForUpdate(context, request.params || {}, options)));
       case 'update.authorize':
-        return okResponse(request.id, await withUpdateMutex(() => authorizeUpdate(context, request.params || {})));
+        return okResponse(request.id, await withUpdateMutex(context, () => authorizeUpdate(context, request.params || {})));
       case 'update.stage':
-        return okResponse(request.id, await withUpdateMutex(() => stageCandidate(context, options)));
+        return okResponse(request.id, await withUpdateMutex(context, () => stageCandidate(context, options)));
       case 'update.canApply':
         return okResponse(request.id, getApplyGate(options));
       case 'update.apply':
-        return okResponse(request.id, await withUpdateMutex(() => applyStagedUpdate(context, request.params || {}, options)));
+        return okResponse(request.id, await withUpdateMutex(context, () => applyStagedUpdate(context, request.params || {}, options)));
+      case 'update.activate':
+        return okResponse(request.id, await withUpdateMutex(context, () => scheduleStagedActivation(context, request.params || {}, options)));
       case 'update.confirm':
-        return okResponse(request.id, await withUpdateMutex(() => confirmUpdate(context, request.params || {})));
+        return okResponse(request.id, await withUpdateMutex(context, () => confirmUpdate(context, request.params || {})));
       case 'update.rollback':
-        return okResponse(request.id, await withUpdateMutex(() => rollbackUpdate(context, request.params || {})));
+        return okResponse(request.id, await withUpdateMutex(context, () => rollbackUpdate(context, request.params || {})));
       case 'update.revoke':
-        return okResponse(request.id, await withUpdateMutex(() => revokeUpdate(context, request.params || {})));
+        return okResponse(request.id, await withUpdateMutex(context, () => revokeUpdate(context, request.params || {})));
       default:
         throw updateError('unknown_update_method', 'Unknown managed update method.');
     }
@@ -80,12 +98,82 @@ async function handleUpdateRequest(request, options = {}) {
   }
 }
 
-function withUpdateMutex(action) {
-  const result = updateMutationTail.then(action, action);
+function withUpdateMutex(context, action) {
+  const guardedAction = () => withUpdateFileLock(context, action);
+  const result = updateMutationTail.then(guardedAction, guardedAction);
   updateMutationTail = result.catch(() => {});
   return result;
 }
 
+async function withUpdateFileLock(context, action) {
+  const lock = await acquireUpdateFileLock(context);
+  try {
+    return await action();
+  } finally {
+    releaseUpdateFileLock(lock);
+  }
+}
+
+async function acquireUpdateFileLock(context) {
+  const lockPath = path.join(context.updatesRoot, MUTATION_LOCK_FILE);
+  const deadline = Date.now() + MUTATION_LOCK_WAIT_MS;
+  const token = crypto.randomUUID();
+  while (Date.now() <= deadline) {
+    try {
+      const descriptor = fs.openSync(lockPath, 'wx', 0o600);
+      try {
+        fs.writeFileSync(descriptor, JSON.stringify({
+          token,
+          pid: process.pid,
+          createdAt: Date.now(),
+          expiresAt: Date.now() + MUTATION_LOCK_STALE_MS
+        }) + '\n');
+      } finally {
+        fs.closeSync(descriptor);
+      }
+      return { lockPath, token };
+    } catch (error) {
+      if (error?.code !== 'EEXIST') throw error;
+      if (removeStaleUpdateFileLock(lockPath)) continue;
+      await delay(75);
+    }
+  }
+  throw updateError('update_transaction_locked', 'Another Native Host process is already changing the managed update state.');
+}
+
+function removeStaleUpdateFileLock(lockPath) {
+  const owner = readJsonSafe(lockPath, null);
+  const expired = !owner || Number(owner.expiresAt || 0) <= Date.now();
+  const abandoned = Number.isInteger(Number(owner?.pid)) && !isProcessAlive(Number(owner.pid));
+  if (!expired && !abandoned) return false;
+  try {
+    fs.rmSync(lockPath, { force: true });
+    return true;
+  } catch (_error) {
+    return false;
+  }
+}
+
+function releaseUpdateFileLock(lock) {
+  if (!lock?.lockPath || !lock.token) return;
+  const owner = readJsonSafe(lock.lockPath, null);
+  if (owner?.token === lock.token) fs.rmSync(lock.lockPath, { force: true });
+}
+
+function isProcessAlive(pid) {
+  if (!Number.isInteger(pid) || pid <= 0) return false;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    return error?.code === 'EPERM';
+  }
+}
+
+function delay(milliseconds) {
+  return new Promise(resolve => setTimeout(resolve, milliseconds));
+}
+
 async function checkForUpdate(context, params = {}, options = {}) {
   const fetchImpl = options.fetch || globalThis.fetch;
   if (typeof fetchImpl !== 'function') {
@@ -105,6 +193,27 @@ async function checkForUpdate(context, params = {}, options = {}) {
     redirect: 'follow'
   }, 12000);
   if (releaseResponse.status === 304) {
+    const candidate = readJsonSafe(path.join(context.updatesRoot, CANDIDATE_FILE), null);
+    if (candidate?.manifestBase64 && candidate?.signatureBase64) {
+      try {
+        const manifest = verifySignedReleaseManifest(
+          Buffer.from(candidate.manifestBase64, 'base64'),
+          Buffer.from(candidate.signatureBase64, 'base64')
+        );
+        if (isNewerStableVersion(manifest.version, currentVersion)) {
+          return {
+            managed: true,
+            available: true,
+            currentVersion,
+            latestVersion: manifest.version,
+            etag: params.etag || candidate.etag || '',
+            cached: true
+          };
+        }
+      } catch (_error) {
+        // Invalid cached candidates are treated as cache misses.
+      }
+    }
     return { managed: true, available: false, reason: 'not_modified', currentVersion, etag: params.etag || '' };
   }
   if (!releaseResponse.ok) {
@@ -116,10 +225,15 @@ async function checkForUpdate(context, params = {}, options = {}) {
   }
   const latestVersion = releaseTag.slice(1);
   if (!isNewerStableVersion(latestVersion, currentVersion)) {
+    const activeMarker = readJsonSafe(path.join(context.extensionRoot, EXTENSION_MARKER), null);
+    const equalVersionPrerelease = compareSemver(latestVersion, currentVersion) === 0
+      && activeMarker?.releaseChannel === 'prerelease';
     return {
       managed: true,
       available: false,
-      reason: compareSemver(latestVersion, currentVersion) === 0 ? 'up_to_date' : 'downgrade_rejected',
+      reason: equalVersionPrerelease
+        ? 'prerelease_promotion_requires_manual_update'
+        : (compareSemver(latestVersion, currentVersion) === 0 ? 'up_to_date' : 'downgrade_rejected'),
       currentVersion,
       latestVersion,
       etag: releaseResponse.headers.get('etag') || ''
@@ -243,6 +357,7 @@ async function stageCandidate(context, options = {}) {
       throw updateError('update_consent_mismatch', 'Staged transaction does not match the active authorization.');
     }
     try {
+      verifyStagedArchive(existingJournal);
       verifyStagedPair(existingJournal.payloadRoot, manifest.version);
       bindAuthorization(context, authorization, existingJournal.id);
       return {
@@ -251,11 +366,18 @@ async function stageCandidate(context, options = {}) {
         state: existingJournal.state,
         reused: true
       };
-    } catch (_error) {
+    } catch (error) {
       cleanupStage(existingJournal.stageRoot);
+      removeJournal(context);
+      settleAuthorization(context, authorization.id, 'revoked');
+      throw updateError(
+        safeErrorCode(error) || 'update_staged_payload_invalid',
+        'The previously staged update is no longer valid. Choose Update now to download it again.',
+        { cause: error }
+      );
     }
   }
-  if (existingJournal && ['applying', 'awaiting_health'].includes(existingJournal.state)) {
+  if (existingJournal && ['activation_pending', 'applying', 'awaiting_health'].includes(existingJournal.state)) {
     throw updateError('update_transaction_in_progress', 'A managed update transaction is already being applied.');
   }
   if (authorization.state === 'bound') {
@@ -288,6 +410,9 @@ async function stageCandidate(context, options = {}) {
       targetVersion: manifest.version,
       stageRoot,
       payloadRoot,
+      archivePath,
+      bundleSize: manifest.updateBundle.size,
+      bundleSha256: manifest.updateBundle.sha256,
       manifestSha256: crypto.createHash('sha256').update(manifestBytes).digest('hex'),
       createdAt: new Date().toISOString(),
       updatedAt: new Date().toISOString()
@@ -315,13 +440,67 @@ function getApplyGate(options = {}) {
   return { idle: blockers.length === 0, blockers, workState: state };
 }
 
-function applyStagedUpdate(context, params = {}, options = {}) {
+function scheduleStagedActivation(context, params = {}, options = {}) {
   const gate = getApplyGate(options);
   if (!gate.idle) {
     throw updateError('update_native_busy', 'Native host is still processing a Codex task.');
   }
+  assertManagedLayout(context);
   const journal = readJournal(context);
   if (!journal || journal.state !== 'staged') {
+    throw updateError('update_not_staged', 'No verified update is ready to activate.');
+  }
+  if (params.transactionId && params.transactionId !== journal.id) {
+    throw updateError('update_transaction_mismatch', 'Update transaction id does not match the staged update.');
+  }
+  const authorization = requireAuthorization(context, journal.targetVersion, ['bound']);
+  if (journal.authorizationId !== authorization.id || authorization.transactionId !== journal.id) {
+    throw updateError('update_consent_mismatch', 'Activation transaction does not match the bound authorization.');
+  }
+  const pending = {
+    ...journal,
+    state: 'activation_pending',
+    activationRequestedAt: new Date().toISOString(),
+    updatedAt: new Date().toISOString()
+  };
+  writeJournal(context, pending);
+  setTimeout(() => {
+    void withUpdateMutex(context, () => applyStagedUpdate(context, {
+      transactionId: pending.id
+    }, {
+      ...options,
+      allowActivationPending: true
+    })).catch(error => recordScheduledActivationFailure(context, pending, error));
+  }, ACTIVATION_DELAY_MS);
+  return {
+    transactionId: pending.id,
+    targetVersion: pending.targetVersion,
+    state: pending.state
+  };
+}
+
+function recordScheduledActivationFailure(context, pending, error) {
+  const current = readJournal(context);
+  if (!current || current.id !== pending.id || ['awaiting_health', 'rolled_back'].includes(current.state)) return;
+  writeJournal(context, {
+    ...current,
+    state: 'rolled_back',
+    reasonCode: safeErrorCode(error),
+    rolledBackAt: new Date().toISOString(),
+    updatedAt: new Date().toISOString()
+  });
+  settleAuthorization(context, pending.authorizationId, 'revoked');
+}
+
+function applyStagedUpdate(context, params = {}, options = {}) {
+  const gate = getApplyGate(options);
+  if (!gate.idle) {
+    throw updateError('update_native_busy', 'Native host is still processing a Codex task.');
+  }
+  assertManagedLayout(context);
+  const journal = readJournal(context);
+  const allowedStates = options.allowActivationPending ? ['activation_pending'] : ['staged'];
+  if (!journal || !allowedStates.includes(journal.state)) {
     throw updateError('update_not_staged', 'No verified update is ready to apply.');
   }
   if (params.transactionId && params.transactionId !== journal.id) {
@@ -331,15 +510,42 @@ function applyStagedUpdate(context, params = {}, options = {}) {
   if (journal.authorizationId !== authorization.id || authorization.transactionId !== journal.id) {
     throw updateError('update_consent_mismatch', 'Apply transaction does not match the bound authorization.');
   }
+  const verifiedPayloadRoot = path.join(journal.stageRoot, 'payload-apply');
+  try {
+    verifyStagedArchive(journal);
+    fs.rmSync(verifiedPayloadRoot, { recursive: true, force: true });
+    extractVerifiedUpdateBundle({
+      archivePath: journal.archivePath,
+      destinationRoot: verifiedPayloadRoot
+    });
+    verifyStagedPair(verifiedPayloadRoot, journal.targetVersion);
+  } catch (error) {
+    cleanupStage(journal.stageRoot);
+    writeJournal(context, {
+      ...journal,
+      state: 'rolled_back',
+      reasonCode: safeErrorCode(error) || 'update_staged_payload_invalid',
+      rolledBackAt: new Date().toISOString(),
+      updatedAt: new Date().toISOString()
+    });
+    settleAuthorization(context, journal.authorizationId, 'revoked');
+    throw error;
+  }
   assertManagedMarkers(context);
   const extensionRuntime = path.join(context.extensionRoot, 'runtime');
   const previousRuntime = path.join(context.extensionRoot, 'slots', 'previous', 'runtime');
-  const stagedExtension = path.join(journal.payloadRoot, 'extension-runtime');
-  const stagedNative = path.join(journal.payloadRoot, 'native-runtime');
+  const stagedExtension = path.join(verifiedPayloadRoot, 'extension-runtime');
+  const stagedNative = path.join(verifiedPayloadRoot, 'native-runtime');
   const targetNative = path.join(context.nativeRoot, 'versions', journal.targetVersion);
   const manifestPath = path.join(context.extensionRoot, 'manifest.json');
   const previousManifest = fs.readFileSync(manifestPath, 'utf8');
-  writeJournal(context, { ...journal, state: 'applying', previousManifest, updatedAt: new Date().toISOString() });
+  writeJournal(context, {
+    ...journal,
+    payloadRoot: verifiedPayloadRoot,
+    state: 'applying',
+    previousManifest,
+    updatedAt: new Date().toISOString()
+  });
 
   try {
     fs.rmSync(path.dirname(previousRuntime), { recursive: true, force: true });
@@ -354,11 +560,20 @@ function applyStagedUpdate(context, params = {}, options = {}) {
     syncManagedMarkerVersions(context, journal.targetVersion);
   } catch (error) {
     rollbackFiles(context, { ...journal, previousManifest });
+    writeJournal(context, {
+      ...journal,
+      previousManifest,
+      state: 'rolled_back',
+      reasonCode: 'update_apply_failed',
+      rolledBackAt: new Date().toISOString(),
+      updatedAt: new Date().toISOString()
+    });
     settleAuthorization(context, journal.authorizationId, 'revoked');
     throw updateError('update_apply_failed', 'Managed update could not be applied atomically.', { cause: error });
   }
   const awaiting = {
     ...journal,
+    payloadRoot: verifiedPayloadRoot,
     previousManifest,
     state: 'awaiting_health',
     appliedAt: new Date().toISOString(),
@@ -436,7 +651,7 @@ function revokeUpdate(context, params = {}) {
   }
   const journal = readJournal(context);
   if (journal?.targetVersion === targetVersion &&
-      ['applying', 'awaiting_health', 'committed'].includes(journal.state)) {
+      ['activation_pending', 'applying', 'awaiting_health', 'committed'].includes(journal.state)) {
     throw updateError('update_revoke_too_late', 'The update is already being applied.');
   }
   const authorization = readAuthorization(context);
@@ -528,6 +743,10 @@ function cleanupOrphanStageRoots(updatesRoot, retainedRoots = []) {
 
 function recoverAndReadStatus(context) {
   let journal = readJournal(context);
+  if (journal?.state === 'activation_pending') {
+    journal = { ...journal, state: 'staged', reasonCode: 'update_activation_interrupted', updatedAt: new Date().toISOString() };
+    writeJournal(context, journal);
+  }
   if (journal?.state === 'applying') {
     rollbackFiles(context, journal);
     journal = { ...journal, state: 'rolled_back', reasonCode: 'update_interrupted', updatedAt: new Date().toISOString() };
@@ -582,8 +801,36 @@ function assertManagedMarkers(context) {
   if (!context.managed) throw updateError('update_not_managed', 'Managed installation markers are missing.');
 }
 
+function assertManagedLayout(context) {
+  assertManagedMarkers(context);
+  const activeVersion = readVersionPointer(context.nativeRoot, 'active-version');
+  const nativeMarker = readJsonSafe(path.join(context.nativeRoot, NATIVE_MARKER), null);
+  const extensionMarker = readJsonSafe(path.join(context.extensionRoot, EXTENSION_MARKER), null);
+  const manifest = readJsonSafe(path.join(context.extensionRoot, 'manifest.json'), null);
+  const requiredFiles = [
+    path.join(context.extensionRoot, 'bootstrap', 'background.js'),
+    path.join(context.extensionRoot, 'runtime', 'runtime-manifest.json')
+  ];
+  const valid = Boolean(
+    parseSemver(activeVersion) &&
+    nativeMarker?.version === activeVersion &&
+    extensionMarker?.version === activeVersion &&
+    manifest?.version === activeVersion &&
+    manifest?.manifest_version === 3 &&
+    manifest?.background?.service_worker === 'bootstrap/background.js' &&
+    requiredFiles.every(filePath => fs.existsSync(filePath) && fs.statSync(filePath).isFile())
+  );
+  if (!valid) {
+    throw updateError(
+      'update_managed_layout_invalid',
+      'Managed extension files do not match the active Native Host. Run install-managed for the latest stable version, then reload the Chrome extension and Overleaf.'
+    );
+  }
+  return activeVersion;
+}
+
 function isManagedMarker(marker, kind) {
-  return marker?.managedBy === 'codex-overleaf-link' && marker?.kind === kind && marker?.bootstrapProtocol === 1;
+  return marker?.managedBy === 'codex-overleaf-link' && marker?.kind === kind && marker?.bootstrapProtocol === 2;
 }
 
 function verifyStagedPair(payloadRoot, targetVersion) {
@@ -597,6 +844,43 @@ function verifyStagedPair(payloadRoot, targetVersion) {
   if (match?.[1] !== targetVersion) {
     throw updateError('update_extension_version_mismatch', 'Staged extension runtime version does not match the signed release.');
   }
+  const extensionRuntimeRoot = path.join(payloadRoot, 'extension-runtime');
+  const runtimeManifest = readJsonSafe(path.join(extensionRuntimeRoot, 'runtime-manifest.json'), null);
+  const runtimeFiles = [
+    ...(Array.isArray(runtimeManifest?.js) ? runtimeManifest.js : []),
+    ...(Array.isArray(runtimeManifest?.css) ? runtimeManifest.css : [])
+  ];
+  if (!runtimeFiles.length) {
+    throw updateError('update_runtime_manifest_invalid', 'Staged runtime manifest does not declare any runtime files.');
+  }
+  for (const relativePath of runtimeFiles) {
+    const normalized = String(relativePath || '').replace(/\\/g, '/');
+    if (!normalized || normalized.startsWith('/') ||
+        normalized.split('/').some(part => !part || part === '.' || part === '..')) {
+      throw updateError('update_runtime_manifest_invalid', 'Staged runtime manifest contains an invalid file path.');
+    }
+    const filePath = path.resolve(extensionRuntimeRoot, ...normalized.split('/'));
+    const relative = path.relative(extensionRuntimeRoot, filePath);
+    if (!relative || relative.startsWith('..') || path.isAbsolute(relative) ||
+        !fs.existsSync(filePath) || !fs.statSync(filePath).isFile()) {
+      throw updateError('update_runtime_asset_missing', 'Staged runtime manifest references a missing file: ' + normalized);
+    }
+  }
+}
+
+function verifyStagedArchive(journal) {
+  if (!journal?.archivePath || !Number.isSafeInteger(journal.bundleSize) ||
+      !/^[0-9a-f]{64}$/.test(String(journal.bundleSha256 || ''))) {
+    throw updateError('update_staged_archive_invalid', 'Staged update archive metadata is incomplete. Download the update again.');
+  }
+  const bytes = fs.readFileSync(journal.archivePath);
+  if (bytes.length !== journal.bundleSize) {
+    throw updateError('update_bundle_size_mismatch', 'Staged update bundle size changed after verification.');
+  }
+  const hash = crypto.createHash('sha256').update(bytes).digest('hex');
+  if (hash !== journal.bundleSha256) {
+    throw updateError('update_bundle_hash_mismatch', 'Staged update bundle changed after verification.');
+  }
 }
 
 function normalizeCurrentVersion(value, context) {
@@ -672,6 +956,7 @@ function publicTransaction(journal) {
     sourceVersion: journal.sourceVersion,
     targetVersion: journal.targetVersion,
     createdAt: journal.createdAt,
+    activationRequestedAt: journal.activationRequestedAt,
     appliedAt: journal.appliedAt,
     confirmedAt: journal.confirmedAt,
     rolledBackAt: journal.rolledBackAt,
@@ -816,6 +1101,7 @@ function errorResponse(id, code, message) {
 module.exports = {
   GITHUB_LATEST_URL,
   applyStagedUpdate,
+  assertManagedLayout,
   authorizeUpdate,
   checkForUpdate,
   cleanupOrphanStageRoots,
@@ -826,6 +1112,7 @@ module.exports = {
   isUpdateMethod,
   revokeUpdate,
   rollbackUpdate,
+  scheduleStagedActivation,
   stageCandidate,
   syncManagedMarkerVersions
 };

package/native-host/src/updateTrust.js

@@ -5,7 +5,7 @@ const crypto = require('node:crypto');
 const UPDATE_REPOSITORY = 'Ghqqqq/codex-overleaf-link';
 const UPDATE_CHANNEL = 'stable';
 const UPDATE_MANIFEST_SCHEMA = 2;
-const BOOTSTRAP_PROTOCOL = 1;
+const BOOTSTRAP_PROTOCOL = 2;
 const TRUSTED_UPDATE_KEYS = Object.freeze({
   'release-2026-01': [
     '-----BEGIN PUBLIC KEY-----',

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codex-overleaf-link",
-  "version": "2.1.5",
+  "version": "2.2.0",
   "description": "Cross-platform Chrome bridge that connects Codex to the active Overleaf project.",
   "license": "MIT",
   "type": "commonjs",
@@ -20,6 +20,8 @@
     "smoke:extension": "node scripts/smoke-extension.mjs",
     "verify:release": "node scripts/verify-release.mjs",
     "verify:release-artifacts": "node scripts/verify-release-artifacts.mjs",
+    "verify:update-boundary": "node scripts/verify-update-boundary.mjs",
+    "verify:update-hop": "node scripts/verify-update-hop.mjs",
     "build:release": "node scripts/build-release.mjs",
     "sign:release": "node scripts/sign-release-manifest.mjs",
     "install:managed": "node scripts/install-managed.mjs",