codex-overleaf-link 2.4.1 → 2.5.0

package/extension/src/content/writebackOrchestrator.js

@@ -63,6 +63,8 @@
   let writebackSettlement;
   let injectedWritebackSettlement;
   let assetTransferBroker;
+  let stageWritebackRecovery;
+  let settleWritebackRecovery;
 
   function buildSettlement(input = {}) {
     return writebackSettlement?.settle instanceof Function
@@ -99,6 +101,8 @@
   }
 
   async function applySyncChangesToOverleaf(syncChanges = [], project = {}, options = {}) {
+    const activeRun = getCurrentRunView?.();
+    const saveTarget = { runProjectId: activeRun?.runProjectId || '', recordId: activeRun?.recordId || '', sessionId: activeRun?.sessionId || '' };
     const runMode = options.mode || getState().mode;
     const runRequireReviewing = typeof options.requireReviewing === 'boolean'
       ? options.requireReviewing
@@ -106,6 +110,20 @@
     const assistantMessage = cleanFinalAnswer(options.assistantMessage || getAssistantAnswerForCurrentRun());
     const unsupportedChanges = Array.isArray(options.unsupportedChanges) ? options.unsupportedChanges : [];
     appendUnsupportedLocalChanges(unsupportedChanges);
+    const withheldOnly = unsupportedChanges.filter(change => ['subagent_unfinished_output', 'subagent_unauthorized_edit'].includes(change.reason));
+    if (runMode !== 'ask' && !syncChanges.length && withheldOnly.length) {
+      const skipped = withheldOnly.map(change => ({ operation: { type: 'create', path: change.path }, result: {
+        ok: false, code: change.reason, changedDocument: false,
+        reason: writebackController.formatUnsupportedLocalChangeReason(change, getLocale())
+      } }));
+      const applied = { ok: false, applied: [], skipped };
+      appendCompletionReport({ conclusion: assistantMessage || tx('Some generated files still need review.', '部分生成文件仍需核对。'),
+        status: 'failed', operations: [], applyResults: [applied], mode: runMode,
+        nextStep: tx('The main agent must review and adopt the withheld files before syncing them.', '主代理需核对并接管未同步文件后再写回。') });
+      return { summaryLine: tx('Generated files are awaiting review.', '生成文件待核对。'), hasSkippedOperations: true,
+        applied, settlement: buildSettlement({ operations: [], applyResult: applied }),
+        audit: buildAuditSummaryFromApply({ operations: [], applyResults: [applied], resultStatus: 'completed_with_skips' }) };
+    }
     // Guard on the immutable submitted mode, not the mutable panel state.
     if (options.mode === 'ask' && ((syncChanges || []).length || unsupportedChanges.length)) {
       appendRunEvent({
@@ -312,6 +330,13 @@
         })
       };
     }
+    const writebackActivityId = 'overleaf-writeback:' + Date.now().toString(36);
+    appendRunEvent({
+      title: tx('Syncing approved changes to Overleaf.', '正在将已批准的改动同步到 Overleaf。'),
+      status: 'running',
+      activity: { v: 1, kind: 'sync', id: writebackActivityId, state: 'running', paths: operations.map(operation => operation.path).filter(Boolean) }
+    });
+    await stageWritebackRecovery?.(operations, saveTarget, runRequireReviewing);
     const applied = operations.length
       ? mergeApplyResultSkipped(await assetTransferBroker.applyOperations({
         operations,
@@ -321,10 +346,19 @@
         // Welcome-panel + write-guard:
         // immutable per-run project id, checked by the page-side guard
         // against `_ide.project._id` before any mutation.
-        runProjectId: getCurrentRunView()?.runProjectId || ''
+        runProjectId: getCurrentRunView()?.runProjectId || '',
+        retryCreates: options.retryCreates === true
       }), additionalSkippedEntries)
       : mergeApplyResultSkipped({ ok: true, applied: [], skipped: [] }, additionalSkippedEntries);
     const hasConfirmedApplyResult = hasApplyResultEntries(applied);
+    for (const change of unsupportedChanges.filter(item => ['subagent_unfinished_output', 'subagent_unauthorized_edit'].includes(item.reason))) {
+      const reason = writebackController.formatUnsupportedLocalChangeReason(change, getLocale());
+      applied.skipped.push({ operation: { type: 'create', path: change.path }, result: { ok: false,
+        code: change.reason, reason, changedDocument: false, failure: { code: change.reason,
+          stage: 'preflight', severity: 'blocked', retryable: false, terminalState: 'blocked', changedDocument: false,
+          userMessage: reason, nextAction: 'The main agent must review the withheld file before syncing it.' } } });
+      applied.ok = false;
+    }
     // Record the apply result + undo checkpoint IMMEDIATELY, before any
     // cancellable verify/mirror awaits below. A user-cancel during the
     // post-write save-verify or mirror refresh throws codex_cancelled; if undo
@@ -342,36 +376,37 @@
       renderReadOnlyDiffReview(getAppliedSyncChanges(syncChanges, applied));
     }
     const appliedPaths = getAppliedOperationPaths(applied);
+    appendRunEvent({
+      title: tx('Overleaf writeback returned its result.', 'Overleaf 写回已返回结果。'),
+      status: !hasConfirmedApplyResult || skippedEntries.length ? 'warning' : 'completed',
+      activity: { v: 1, kind: 'sync', id: writebackActivityId,
+        state: !hasConfirmedApplyResult || skippedEntries.length ? 'warning' : 'completed',
+        paths: operations.map(operation => operation.path).filter(Boolean),
+        written: appliedPaths.length, skipped: skippedEntries.length }
+    });
     // Only probe save-state + refresh the mirror when real writes landed. A
     // zero-write run (every operation skipped) has nothing to save-verify, so
     // skip the ~5s probe and its misleading "could not verify saved" warning
     // (v1.6.2).
-    const saveVerification = appliedPaths.length
-      ? await verifyPostWriteSaveState()
-      : {
-        ok: false,
-        state: 'not_checked',
-        reason: 'No applied writeback operations were returned.'
-      };
+    const confirmation = appliedPaths.length
+      ? await verifyPostWriteSaveState(applied, project, saveTarget)
+      : { verification: { ok: false, state: 'not_checked', reason: 'No applied writeback operations were returned.' } };
+    const saveVerification = confirmation.verification;
+    await settleWritebackRecovery?.(applied, project, saveVerification, saveTarget);
     if (appliedPaths.length) {
-      appendPostWriteSaveVerificationWarning(saveVerification);
+      appendPostWriteSaveVerificationWarning(saveVerification, saveTarget);
+      appendRunEvent({ kind: 'technical', title: 'Post-write save confirmation', status: 'info', detail: saveVerification });
     }
     // v1.7.5: the mirror refresh (zip snapshot + mirror.sync, often the
     // slowest post-write step) no longer blocks the completion report. The
     // pending promise is exposed so undoRun and the next runTask barrier on
     // it — a mirror.sync landing AFTER an undo would otherwise push the
     // pre-undo snapshot as the local baseline.
-    const mirrorSettlementTarget = getCurrentRunView?.();
-    pendingMirrorRefresh = refreshProjectMirrorAfterWriteback(project, applied, saveVerification)
-      .catch(error => {
-        appendRunEvent({
-          title: tx(
-            `Overleaf was written, but the background workspace refresh failed: ${error.message}. The next run will reread the project.`,
-            `Overleaf 已写入，但后台刷新本地 workspace 失败：${error.message}。下一轮会重新读取项目。`
-          ),
-          status: 'failed'
-        });
-        return 'failed';
+    const mirrorSettlementTarget = saveTarget;
+    pendingMirrorRefresh = refreshProjectMirrorAfterWriteback(project, applied, saveVerification, { target: saveTarget, snapshot: confirmation.snapshot })
+      .catch(async error => {
+        appendRunRecordEvent(saveTarget.recordId, { kind: 'technical', title: 'Mirror refresh requires a fresh read', status: 'info', detail: { reason: error.message } });
+        return invalidateWritebackMirror(saveTarget);
       })
       .then(state => {
         if (typeof onMirrorRefreshSettled !== 'function') return;
@@ -388,7 +423,8 @@
     const compileSummary = appliedPaths.length
       ? await autoRecompileAfterWriteback(appliedPaths, saveVerification, {
         autoRecompile: options.autoRecompile,
-        mode: runMode
+        mode: runMode,
+        runProjectId: saveTarget.runProjectId
       }).catch(error => {
         appendRunEvent({
           title: tx(`Post-write compile failed: ${error.message}`, `写后编译出错：${error.message}`),
@@ -435,6 +471,7 @@
       compileErrors: compileSummary?.status === 'failed' && Array.isArray(compileSummary.errors)
         ? compileSummary.errors
         : undefined,
+      saveVerification,
       // Promote the primary per-operation skip failure to the run level when
       // the writeback failed outright: target-file and write-stage codes only
       // ever exist inside applied.skipped[], and without this promotion the
@@ -475,57 +512,60 @@
     };
   }
 
-  async function verifyPostWriteSaveState() {
-    try {
-      const result = await callPageBridge('waitForSaveState', {
-        deadlineMs: 5000,
-        requirePositiveSignal: true
-      });
-      if (result?.state === 'verified_saved') {
-        return {
-          ...result,
-          ok: true,
-          state: 'verified_saved'
-        };
-      }
-      if (result?.ok === true && !result?.state) {
-        return {
-          ...result,
-          ok: false,
-          state: 'verified_quiet'
-        };
-      }
-      if (result?.state === 'unknown_timeout' || result?.state === 'unavailable') {
-        return {
-          ...result,
-          ok: false
-        };
-      }
-      return {
-        ...result,
-        ok: false,
-        state: 'unknown_timeout'
-      };
-    } catch (error) {
-      return {
-        ok: false,
-        state: 'unavailable',
-        reason: error.message
-      };
-    }
+  async function verifyPostWriteSaveState(applied, project, target = {}) {
+    return writebackController.confirmPostWriteSave({
+      applied, project, runProjectId: target.runProjectId,
+      assertCurrent() {
+        if (!target.runProjectId || getCurrentProjectId() !== target.runProjectId) {
+          throw Object.assign(new Error('The Overleaf project changed during save confirmation.'), { code: 'aborted_project_changed', changedDocument: true });
+        }
+        if (target.recordId && getCurrentRunView()?.recordId !== target.recordId) {
+          throw Object.assign(new Error('The run stopped during save confirmation.'), { code: 'codex_cancelled', changedDocument: true });
+        }
+      },
+      readSaveState: params => callPageBridge('waitForSaveState', { ...params, runProjectId: target.runProjectId }),
+      readSnapshot: params => callPageBridge('getProjectSnapshot', { ...params, runProjectId: target.runProjectId })
+    });
   }
 
-  function appendPostWriteSaveVerificationWarning(saveVerification = {}) {
-    if (saveVerification?.state === 'verified_saved') {
-      return;
+  function appendPostWriteSaveVerificationWarning(saveVerification = {}, target = {}) {
+    if (saveVerification.state === 'verified_saved') return;
+    // Missing confirmation is represented once in the report, with a check action.
+    if (saveVerification.signal !== 'offline') return;
+    const title = saveVerification.signal === 'offline'
+      ? tx('Overleaf is offline. Keep this page open and reconnect so the changes can be saved.',
+        'Overleaf 当前离线。请保持页面开启，恢复连接后等待改动保存。')
+      : tx('Saving these changes is not yet confirmed. Keep this page open and check Overleaf’s save and connection status.',
+        '尚未确认本次改动已保存。请保持页面开启，检查 Overleaf 的保存和连接状态。');
+    if (target.recordId) appendRunRecordEvent(target.recordId, { title, status: 'warning' });
+    else appendRunEvent({ title, status: 'warning' });
+  }
+
+  async function invalidateWritebackMirror(target = {}) {
+    let invalidated = false;
+    try {
+      if (target.runProjectId) {
+        const response = await sendBackgroundNative({ method: 'mirror.invalidate', params: { projectId: target.runProjectId } });
+        invalidated = response?.ok === true && response.result?.invalidated === true;
+      }
+    } catch (_error) { /* An unavailable host cannot acknowledge invalidation. */ }
+    let pageInvalidated = getCurrentProjectId() !== target.runProjectId;
+    if (!pageInvalidated) {
+      resetContextProject();
+      try {
+        const response = await callPageBridge('invalidateProjectSnapshot', { invalidateFileList: true, runProjectId: target.runProjectId });
+        pageInvalidated = response?.ok === true;
+      } catch (_error) { /* Leave the failure visible if both caches cannot be fenced. */ }
     }
-    appendRunEvent({
-      title: tx(
-        'Files were written or attempted in Overleaf, but Codex could not verify that Overleaf saved them. Local mirror refresh was skipped.',
-        '文件已写入或尝试写入 Overleaf，但 Codex 未能确认 Overleaf 已保存；已跳过本地 mirror 刷新。'
-      ),
+    if (invalidated && pageInvalidated) return 'not-attempted';
+    const event = {
+      title: tx('The local project cache could not be reset. Check the local connection before starting another task.',
+        '本地项目缓存未能重置。请检查本地连接后再开始下一轮任务。'),
       status: 'warning'
-    });
+    };
+    if (target.recordId) appendRunRecordEvent(target.recordId, event);
+    else appendRunEvent(event);
+    return 'failed';
   }
 
   // v1.8.0: text-only writebacks confirm the mirror in place. The written
@@ -537,7 +577,7 @@
   // method — falls back to the full zip resync below.
   const MIRROR_CONFIRMABLE_OPERATION_TYPES = new Set(['edit']);
 
-  async function tryConfirmMirrorWriteback(applied) {
+  async function tryConfirmMirrorWriteback(applied, runProjectId) {
     const entries = Array.isArray(applied?.applied) ? applied.applied : [];
     if (!entries.length) {
       return false;
@@ -554,7 +594,7 @@
       const response = await sendBackgroundNative({
         method: 'mirror.confirmWriteback',
         params: {
-          projectId: getCurrentProjectId(),
+          projectId: runProjectId,
           paths: Array.from(new Set(paths))
         }
       });
@@ -564,15 +604,16 @@
     }
   }
 
-  async function refreshProjectMirrorAfterWriteback(project = {}, applied = {}, saveVerification = {}) {
+  async function refreshProjectMirrorAfterWriteback(project = {}, applied = {}, saveVerification = {}, confirmation = {}) {
+    const target = confirmation.target || {};
     if (saveVerification?.state !== 'verified_saved') {
-      return 'not-attempted';
+      return invalidateWritebackMirror(target);
     }
     if (!Array.isArray(applied?.applied) || !applied.applied.length) {
       return 'not-attempted';
     }
 
-    if (await tryConfirmMirrorWriteback(applied)) {
+    if (!confirmation.snapshot && await tryConfirmMirrorWriteback(applied, target.runProjectId)) {
       appendRunEvent({
         title: tx(
           'Local Codex workspace confirmed in place (no project re-download needed). The next run starts from the latest content.',
@@ -588,10 +629,13 @@
       status: 'running'
     });
 
-    await callPageBridge('invalidateProjectSnapshot', {
+    if (!target.runProjectId || getCurrentProjectId() !== target.runProjectId) return invalidateWritebackMirror(target);
+    if (!confirmation.snapshot) await callPageBridge('invalidateProjectSnapshot', {
+      runProjectId: target.runProjectId,
       invalidateFileList: true
     });
-    const freshProject = sanitizeRunProjectSnapshot(await callPageBridge('getProjectSnapshot', {
+    const freshProject = confirmation.snapshot || sanitizeRunProjectSnapshot(await callPageBridge('getProjectSnapshot', {
+      runProjectId: target.runProjectId,
       force: true,
       maxAgeMs: 0,
       preferLightweight: true,
@@ -603,23 +647,18 @@
       zipTimeoutMs: RUN_SNAPSHOT_ZIP_TIMEOUT_MS,
       focusFiles: getAppliedOperationPaths(applied)
     }));
-    if (!freshProject?.files?.length || freshProject?.capabilities?.fullProjectSnapshot === false) {
-      appendRunEvent({
-        title: tx(
-          'Overleaf was written, but the full project was not read. The local Codex workspace baseline was not refreshed; the next run will reread it.',
-          'Overleaf 已写入，但没有读到完整项目；暂不刷新本地 Codex workspace baseline，下一轮会重新读取。'
-        ),
-        status: 'failed'
-      });
-      return 'failed';
+    if (getCurrentProjectId() !== target.runProjectId || freshProject?.id !== target.runProjectId
+      || !freshProject?.files?.length || freshProject?.capabilities?.fullProjectSnapshot === false
+      || freshProject?.capabilities?.skipped?.length) {
+      return invalidateWritebackMirror(target);
     }
 
-    const syncedProject = mergeVerifiedAppliedFiles(freshProject, project, applied);
+    const syncedProject = confirmation.snapshot || mergeVerifiedAppliedFiles(freshProject, project, applied);
     resetContextProject();
     const response = await sendBackgroundNative({
       method: 'mirror.sync',
       params: {
-        projectId: getCurrentProjectId(),
+        projectId: target.runProjectId,
         project: syncedProject
       }
     });
@@ -631,15 +670,7 @@
       return 'complete';
     }
 
-    const message = response?.error?.message || tx('native host did not respond', 'native host 没有响应');
-    appendRunEvent({
-      title: tx(
-        `Overleaf was written, but refreshing the local workspace failed: ${message}`,
-        `Overleaf 已写入，但刷新本地 workspace 失败：${message}`
-      ),
-      status: 'failed'
-    });
-    return 'failed';
+    return invalidateWritebackMirror(target);
   }
 
   function mergeVerifiedAppliedFiles(freshProject = {}, originalProject = {}, applied = {}) {
@@ -660,6 +691,8 @@
     return writebackController.formatUnsupportedLocalChangeSummary(changes, getLocale());
   }
 
+  const serverProvenSave = verification => ['overleaf-zip', 'server-receipts'].includes(verification?.source);
+
   async function autoRecompileAfterWriteback(writtenPaths = [], saveVerification = {}, options = {}) {
     if (options.autoRecompile === false
       || (options.autoRecompile === undefined && getState().autoRecompile === false)) return null;
@@ -671,7 +704,10 @@
     const hasCompilableFile = writtenPaths.some(filePath => CompileAdapter.isCompilableFile(filePath));
     if (!hasCompilableFile) return null;
 
+    const compileActivityId = 'overleaf-compile:' + Date.now().toString(36);
+    const activity = (state, output = '') => ({ v: 1, kind: 'compile', id: compileActivityId, state, target: 'Overleaf', output });
     appendRunEvent({
+      activity: activity('running'),
       title: saveVerification?.state !== 'verified_saved'
         ? tx(
           'Post-write compile: Overleaf save was not verified, but Auto Compile is on. Triggering Overleaf Recompile and letting Overleaf wait for the latest save.',
@@ -687,9 +723,10 @@
     try {
       const result = await callPageBridge('triggerCompile', {
         preferUiClick: true,
-        waitForSaveMs: 5000,
-        requireVerifiedSave: saveVerification?.state === 'verified_saved',
-        runProjectId: getCurrentRunView()?.runProjectId || getCurrentProjectId()
+        // Server-side proof (ZIP or save receipts) already settles the save; don't also demand the UI indicator.
+        waitForSaveMs: serverProvenSave(saveVerification) ? 0 : 5000,
+        requireVerifiedSave: saveVerification?.state === 'verified_saved' && !serverProvenSave(saveVerification),
+        runProjectId: options.runProjectId || getCurrentRunView()?.runProjectId || getCurrentProjectId()
       });
       if (result?.ok) {
         let logResult = null;
@@ -698,64 +735,34 @@
             triggerIfStale: false,
             maxAgeMs: 30000,
             waitForSaveMs: 0,
-            runProjectId: getCurrentRunView()?.runProjectId || getCurrentProjectId()
+            runProjectId: options.runProjectId || getCurrentRunView()?.runProjectId || getCurrentProjectId()
           });
         } catch (_error) {
           logResult = null;
         }
         const compile = result.compile;
         if (compile?.status === 'success') {
-          appendRunEvent({ title: tx('Compile succeeded.', '编译成功。'), status: 'completed' });
+          appendRunEvent({ title: tx('Compile succeeded.', '编译成功。'), status: 'completed',
+            activity: activity('completed', [...(logResult?.errors || []), ...(logResult?.warnings || [])].slice(0, 5).map(CompileAdapter.formatCompileDiagnosticForSummary).join('\n')) });
         } else if (compile?.status === 'triggered') {
-          appendRunEvent({ title: tx('Overleaf compile was triggered. The page will continue showing progress.', '已触发 Overleaf 编译；页面会继续显示编译进度。'), status: 'completed' });
+          appendRunEvent({ title: tx('Overleaf compile was triggered. The page will continue showing progress.', '已触发 Overleaf 编译；页面会继续显示编译进度。'), status: 'completed', activity: activity('triggered') });
         } else {
-          appendRunEvent({ title: tx(`Compile finished with status: ${compile?.status || 'unknown'}`, `编译完成，状态：${compile?.status || '未知'}`), status: 'completed' });
+          appendRunEvent({ title: tx(`Compile finished with status: ${compile?.status || 'unknown'}`, `编译完成，状态：${compile?.status || '未知'}`), status: 'completed', activity: activity(compile?.status === 'failed' ? 'failed' : 'unknown') });
         }
         return buildPostWriteCompileSummary({ result, logResult });
       } else {
         const reason = result?.reason || tx('unknown reason', '未知原因');
-        appendRunEvent({ title: tx(`Post-write compile did not succeed: ${reason}`, `写后编译未成功：${reason}`), status: 'failed' });
+        appendRunEvent({ title: tx(`Post-write compile did not succeed: ${reason}`, `写后编译未成功：${reason}`), status: 'failed', activity: activity('failed', reason) });
         return buildPostWriteCompileSummary({ result });
       }
     } catch (error) {
-      appendRunEvent({ title: tx(`Post-write compile failed: ${error.message}`, `写后编译出错：${error.message}`), status: 'failed' });
+      appendRunEvent({ title: tx(`Post-write compile failed: ${error.message}`, `写后编译出错：${error.message}`), status: 'failed', activity: activity('failed', error.message) });
       return buildPostWriteCompileSummary({ error });
     }
   }
 
-  function buildPostWriteCompileSummary({ result = null, logResult = null, error = null } = {}) {
-    const logAvailable = logResult?.ok === true;
-    const errors = logAvailable && Array.isArray(logResult.errors)
-      ? logResult.errors.slice(0, 5).map(formatCompileDiagnosticForSummary)
-      : [];
-    const warnings = logAvailable && Array.isArray(logResult.warnings)
-      ? logResult.warnings.slice(0, 5).map(formatCompileDiagnosticForSummary)
-      : [];
-    if (error) {
-      return {
-        status: 'failed',
-        reason: error?.message || 'Post-write compile failed.',
-        errors,
-        warnings,
-        logAvailable
-      };
-    }
-    if (!result?.ok) {
-      return {
-        status: 'failed',
-        reason: result?.reason || 'Post-write compile did not succeed.',
-        errors,
-        warnings,
-        logAvailable
-      };
-    }
-    return {
-      status: result.compile?.status || 'triggered',
-      reason: result.reason || '',
-      errors,
-      warnings,
-      logAvailable
-    };
+  function buildPostWriteCompileSummary(input = {}) {
+    return compileAdapter.buildPostWriteCompileSummary(input);
   }
 
   // First structured per-operation failure among the skipped writeback
@@ -813,10 +820,6 @@
     return [conclusion, '', summary].filter(Boolean).join('\n');
   }
 
-  function formatCompileDiagnosticForSummary(value) {
-    const text = String(value || '').replace(/\s+/g, ' ').trim();
-    return text.length > 180 ? `${text.slice(0, 179)}...` : text;
-  }
 
   async function resolveCompileLogContext() {
     try {
@@ -891,6 +894,8 @@
       getCurrentRunView,
     } = deps);
     assetTransferBroker = deps.assetTransferBroker;
+    stageWritebackRecovery = deps.stageWritebackRecovery;
+    settleWritebackRecovery = deps.settleWritebackRecovery;
     onMirrorRefreshSettled = deps.onMirrorRefreshSettled;
     writebackSettlement = deps.writebackSettlement;
     compileAdapter = deps.compileAdapter;