codex-overleaf-link 2.6.0 → 2.6.5

package/native-host/src/nativeEnvironment.js

@@ -40,6 +40,11 @@ function buildNativeRuntimeEnv(baseEnv = process.env, options = {}) {
   for (const tool of TOOL_NAMES) {
     env[getToolEnvName(tool)] = resolveExecutable(tool, env.PATH, { ...runtimeOptions, env }) || '';
   }
+  const startupContext = getCodexRuntimeRefreshContext({
+    ...env,
+    CODEX_OVERLEAF_CODEX_PATH: explicitCodexPath || env.CODEX_OVERLEAF_CODEX_PATH,
+    CODEX_OVERLEAF_CODEX_RUNTIME_JSON: ''
+  }, runtimeOptions);
   const codexRuntime = buildCodexRuntimeIdentity({
     selectedPath: explicitCodexPath || env.CODEX_OVERLEAF_CODEX_PATH,
     selectionPolicy: explicitCodexPath ? 'explicit-path' : 'newest-version',
@@ -53,12 +58,20 @@ function buildNativeRuntimeEnv(baseEnv = process.env, options = {}) {
   env.CODEX_OVERLEAF_CODEX_VERSION = codexRuntime.selected?.version || '';
   env.CODEX_OVERLEAF_CODEX_SOURCE = codexRuntime.selected?.source || '';
 
+  const { key, pathValue, signatures } = getCodexRuntimeRefreshContext(env, runtimeOptions);
+  // Selection can reorder candidates, but discovery must not cache changed files.
+  if (pathValue === startupContext.pathValue
+    && signatures.length === startupContext.signatures.length
+    && signatures.every(signature => startupContext.signatures.some(before => JSON.stringify(before) === JSON.stringify(signature)))) {
+    cacheCodexRuntimeIdentity(key, codexRuntime);
+  }
+
   return env;
 }
 
 const codexRuntimeRefreshCache = new Map();
 
-function refreshCodexRuntimeEnv(baseEnv = process.env, options = {}) {
+function getCodexRuntimeRefreshContext(baseEnv, options) {
   const runtimeOptions = { ...options, platform: getNativeRuntimePlatform({ ...options, env: baseEnv }) };
   const previous = getCodexRuntimeIdentityFromEnv(baseEnv);
   const selectedPath = previous.selected?.path || String(baseEnv.CODEX_OVERLEAF_CODEX_PATH || '');
@@ -78,6 +91,18 @@ function refreshCodexRuntimeEnv(baseEnv = process.env, options = {}) {
     } catch (_) { return [candidate, 'missing']; }
   });
   const key = JSON.stringify([runtimeOptions.platform, pinned ? selectedPath : '', pathValue, signatures]);
+  return { runtimeOptions, previous, selectedPath, pinned, pathValue, signatures, key };
+}
+
+function cacheCodexRuntimeIdentity(key, identity) {
+  codexRuntimeRefreshCache.set(key, { identity, createdAt: Date.now() });
+  while (codexRuntimeRefreshCache.size > 4) {
+    codexRuntimeRefreshCache.delete(codexRuntimeRefreshCache.keys().next().value);
+  }
+}
+
+function refreshCodexRuntimeEnv(baseEnv = process.env, options = {}) {
+  const { runtimeOptions, previous, selectedPath, pinned, pathValue, key } = getCodexRuntimeRefreshContext(baseEnv, options);
   const cached = codexRuntimeRefreshCache.get(key);
   let identity = cached?.identity;
   if (options.force || !cached || Date.now() - cached.createdAt > 30000) {
@@ -89,10 +114,7 @@ function refreshCodexRuntimeEnv(baseEnv = process.env, options = {}) {
       env: { ...baseEnv, PATH: pathValue },
       platform: runtimeOptions.platform
     });
-    codexRuntimeRefreshCache.set(key, { identity, createdAt: Date.now() });
-    while (codexRuntimeRefreshCache.size > 4) {
-      codexRuntimeRefreshCache.delete(codexRuntimeRefreshCache.keys().next().value);
-    }
+    cacheCodexRuntimeIdentity(key, identity);
     if (identity.selected?.path !== previous.selected?.path
       || identity.selected?.version !== previous.selected?.version) {
       logDebug('codex.runtime.refreshed', {

package/native-host/src/providerRuntime.js

@@ -237,6 +237,7 @@ function resolveProviderModels(params = {}, env = process.env, resolveBuiltInMod
     providerId: profile.id,
     providerRevision: profile.revision,
     providerName: profile.name,
+    defaultModelId: profile.defaultModelId,
     models: profile.models.map(model => {
       const reasoning = getReasoningControl(profile, model);
       return {

package/native-host/src/skills/reviewer-response/SKILL.md

@@ -0,0 +1,65 @@
+---
+name: reviewer-response
+description: >
+  Use only when the user asks to respond to peer-review or reviewer comments,
+  write a rebuttal or response letter, or plan a revision from reviews.
+---
+
+# Reviewer Response
+
+Map reviewer comments to evidence in the paper, proposed edits, and reply
+drafts. Keep missing evidence visible instead of filling it with assumptions.
+
+## Workflow
+
+1. Split the reviews into atomic comments with stable IDs R<reviewer>.<n>,
+   such as R1.2. Keep the reviewer's own numbering when present; retain the
+   original label when splitting a numbered comment into smaller items.
+2. For each comment, look for evidence in the project files. Cite actual
+   source lines as plain-text path:line or path:start-end, for example
+   main.tex:212-230. Do not wrap references in backticks: the panel turns
+   plain-text references into clickable links. If evidence is absent, write
+   "Not found"; distinguish files not read from files searched without a match.
+3. Output a compact ledger table with these columns:
+
+   ID | Comment | Evidence in the paper | Proposed change | Status
+
+   Keep cells short for the narrow panel, with each Comment at most about
+   12 words. Put necessary explanations below the table. Use only these
+   statuses, adding a short reason:
+   - Ready to edit: the evidence supports a specific local edit.
+   - Needs an experiment: new experimental evidence is required.
+   - Needs author input: facts or a decision must come from the author.
+   - Unresolved: the comment remains open for another stated reason.
+   - No change: explain why the current paper already addresses the comment
+     or why a change is unwarranted.
+
+   Write the table and explanations in the user's language, translating
+   headings, statuses, and "Not found" accordingly. Keep the IDs unchanged.
+4. After the ledger, draft replies only for the comments the user asked
+   about, or for every comment when they requested a full response letter.
+   Write reply drafts in English unless the user asks otherwise. Label each
+   draft with its comment ID and distinguish proposed work from completed work.
+5. Finish with one "Next:" line, localized to the user's language, explaining
+   how to apply approved items. For example: Next: after approving R1.2,
+   switch to Auto and send "Apply R1.2".
+
+## Integrity rules
+
+- Never invent results, numbers, experiments, citations, or completed changes.
+- Anything needed for a response that is not present in the paper or provided
+  by the user must be marked Needs an experiment or Needs author input.
+- Reply drafts must not promise results. State missing evidence or pending
+  author input explicitly; do not describe planned edits as already made.
+- Cite only files and lines actually inspected. User-provided facts are not
+  evidence already in the paper; identify their source separately.
+
+## Editing rules
+
+- In Ask mode, never edit files.
+- In Auto mode, edit only the comment IDs the user explicitly approves.
+  Keep edits minimal and local, leaving unrelated text untouched. An approved
+  ID does not authorize inventing missing evidence or results.
+- After editing, report which IDs changed with plain-text path:line or
+  path:start-end references. Keep pending items separate and do not claim
+  an edit, save, or experiment completed without evidence.

package/native-host/src/taskRunnerRuntime.js

@@ -50,7 +50,7 @@ const activeRunEntries = new Map();
 // Overleaf tab was reloaded — the requestId lived in content-side JS state
 // and is gone, but the native-host-side controller is still running).
 const activeRunByProject = new Map();
-const CODEX_RUN_PASSTHROUGH_ERROR_CODES = new Set(['thread_resume_failed', 'codex_no_usable_result', 'codex_context_limit', 'codex_process_stop_unconfirmed', 'selected_context_unresolved', 'codex_local_skill_unavailable']);
+const CODEX_RUN_PASSTHROUGH_ERROR_CODES = new Set(['thread_resume_failed', 'codex_no_usable_result', 'codex_context_limit', 'codex_process_stop_unconfirmed', 'selected_context_unresolved', 'codex_local_skill_unavailable', 'document_identity_mismatch']);
 
 async function handleRequest(request, env = process.env, emit = () => {}) {
   if (!request || typeof request !== 'object') {
@@ -308,7 +308,7 @@ async function handleCodexRun(request, env, emit) {
       // OT overlays prove that the current page agrees with the trusted OT
       // baseline; they must not rewrite it or supply a replacement hash.
       if (!isOtWarmMirrorReuseRequest(params) && Array.isArray(params.fileOverlays) && params.fileOverlays.length) {
-        await applyFileOverlays({ projectId: projectKey, overlays: params.fileOverlays, rootDir });
+        await applyFileOverlays({ projectId: projectKey, evidenceProjectId: params.projectId, overlays: params.fileOverlays, rootDir });
       }
     } else if (params.operation !== 'compact' && !params.writingStyleBuild && !isSnapshotlessSkillInstallerRun(params) && !hasRunnableProjectSnapshotEvidence(params)) {
       return errorResponse(
@@ -456,6 +456,13 @@ function handleCodexCancel(request, env = process.env) {
     });
   }
 
+  if (targetId != null && !force) {
+    return okResponse(request.id, {
+      cancelled: false,
+      reason: 'request_not_active'
+    });
+  }
+
   if (projectKey) {
     const entry = activeRunByProject.get(projectKey);
     if (entry?.controller) {
@@ -733,6 +740,7 @@ async function handleMirrorSync(request, env) {
   try {
     const result = await syncOverleafToMirror({
       projectId,
+      evidenceProjectId: params.projectId,
       project: params.project || { files: [] },
       rootDir
     });
@@ -769,7 +777,7 @@ async function handleMirrorPatchFiles(request, env) {
     });
     return okResponse(request.id, result);
   } catch (error) {
-    return errorResponse(request.id, 'mirror_patch_files_failed', error.message);
+    return errorResponse(request.id, error.code === 'document_identity_mismatch' ? error.code : 'mirror_patch_files_failed', error.message);
   } finally {
     releaseProjectLock(projectKey, lockToken);
   }

package/native-host/src/updateManager.js

@@ -999,12 +999,19 @@ function rollbackFiles(context, journal, options = {}) {
   const runtime = path.join(context.extensionRoot, 'runtime');
   const previousRuntime = path.join(context.extensionRoot, 'slots', 'previous', 'runtime');
   // An early interrupted apply may still have the source in the current slot.
-  // A missing previous slot is recoverable only when these actual bytes match
-  // the source pair; the source manifest and markers alone are insufficient.
-  const source = readManagedRuntimeEvidence(context, journal.sourceVersion,
-    fs.existsSync(previousRuntime) ? previousRuntime : runtime);
+  // A missing or stale previous slot is recoverable only when these actual
+  // bytes match the source pair; manifest and markers alone are insufficient.
+  let sourceRuntime = fs.existsSync(previousRuntime) ? previousRuntime : runtime;
+  let source;
+  try {
+    source = readManagedRuntimeEvidence(context, journal.sourceVersion, sourceRuntime);
+  } catch (error) {
+    if (journal.state !== 'applying' || sourceRuntime !== previousRuntime) throw error;
+    source = readManagedRuntimeEvidence(context, journal.sourceVersion, runtime);
+    sourceRuntime = runtime;
+  }
   if (journal.bootstrapMigration) BootstrapUpdate.restoreBootstrap(context, journal);
-  if (fs.existsSync(previousRuntime)) {
+  if (sourceRuntime === previousRuntime) {
     fs.rmSync(runtime, { recursive: true, force: true });
     fs.renameSync(previousRuntime, runtime);
     fs.rmSync(path.dirname(previousRuntime), { recursive: true, force: true });
@@ -1122,7 +1129,18 @@ function recoverAndReadStatus(context, params = {}) {
       cleanupStage(journal.stageRoot);
     }
   }
-  return currentStatus(context, journal);
+  const status = currentStatus(context, journal);
+  if (journal?.state === 'rolled_back' && !journal.bootstrapMigration && status.restoredPair) {
+    const authorization = readAuthorization(context);
+    if (['bound', 'consumed'].includes(authorization?.state) && authorization.id === journal.authorizationId
+      && authorization.transactionId === journal.id && authorization.sourceVersion === journal.sourceVersion
+      && authorization.targetVersion === journal.targetVersion) {
+      settleAuthorization(context, journal.authorizationId, 'revoked');
+      status.authorization = publicAuthorization(readAuthorization(context));
+    }
+    cleanupStage(journal.stageRoot);
+  }
+  return status;
 }
 
 function finishSourceActivation(context, journal) {

package/native-host/src/writingStyleRuntime.js

@@ -374,7 +374,7 @@ async function build({ params, env, signal, execute, providerLaunch, onControlRe
       reasoningEffort: params.reasoningEffort || '', speedTier: params.speedTier || 'standard',
       sandboxMode: 'read-only', approvalPolicy: 'never',
       loadCodexLocalSkills: false, loadCodexOverleafSkills: false,
-      disableCodexOverleafSkillIds: ['annotated-rewrite', 'parallel-subagents'],
+      disableCodexOverleafSkillIds: ['annotated-rewrite', 'parallel-subagents', 'reviewer-response'],
       skillInvocation: null, projectLocalSkills: null, providerLaunch, env, signal,
       onControlReady, emit: () => {}
     };

package/package.json

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