@minhspark/codex-mcp-bridge 1.22.3 → 1.22.5

package/docs/daily-handoffs.md

@@ -27,6 +27,32 @@ session identity, Git root if applicable, and Remote Control state. Compare
 Pin `expectedCwd` and `expectedTaskId` before dispatching production work.
 Reuse this verified parent for subsequent handoffs.
 
+If a saved Claude project's directory has moved, discovery reports a separate
+`relocatedProjects` candidate when the old directory is missing and the workspace
+resolver finds one writable replacement authorized by the shared project policy.
+Revoked original paths, revoked targets, ambiguous replacements and existing old
+directories do not qualify. Hardened deployments do not remap projects.
+
+The candidate can establish the project for an explicitly authorized new Code
+conversation. It cannot resume the old task or authorize a live session: the
+new native task, account, process, actual cwd and initial message must still match.
+Discovery does not rewrite Claude metadata, create grants or clear revocations.
+The saved source and its authorization are rechecked before opening, trusting and
+submitting, including after a pending request is restored.
+
+Native composer creation submits an initial user prompt; it is not a peer
+message and does not establish a native sender label. If a handoff requires the
+recipient's peer sender attribution, use `send_to_claude_session` with a verified
+live task. Do not substitute composer submission or a text header for that route.
+
+Peer messages include the bridge's advertised name through Claude's supported
+`from-name` envelope field. Claude determines the native wording and verifies
+the peer; the bridge does not set trusted-origin flags. Codex Desktop currently
+uses its own fixed `Sent by ... from another chat` label and exposes no sender-name
+override. Keep the actual `[From Claude ...]` or `[From Codex ...]` author header
+in the message. A body header does not rename a native badge, and applications'
+private data must not be patched to make that claim.
+
 If a link was already opened, retain its requestId and inspect its receipt.
 `promptSubmitted=false` with `submissionStatus=not_observed` means submission
 was not verified, not that nothing was delivered. A wrong-directory task can
@@ -50,6 +76,12 @@ new task, account, process, prompt and directory to match.
    deliveryId. For Codex-to-Claude, retain the original msgId and inspect its
    receipt. An unconfirmed acknowledgement is not proof of delivery; observe
    the original receipt instead of resending an uncertain task.
+   Confirmed native acceptance is retained across reconnects. A message injected
+   into an active Codex turn can return that turn's final answer with
+   `responseScope: same_turn_final`; it may cover other peer messages in that
+   turn. The exact dispatch must occur after the saved watermark, and commentary
+   alone is never a final reply. Receipt observation resolves that exact dispatch
+   even after newer turns start; it does not substitute the latest turn's answer.
 5. An `interrupted` receipt ends observation only: task outcome is unknown and
    background work may continue. Inspect the existing task before a scoped
    follow-up; do not repeat card creation or file operations.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@minhspark/codex-mcp-bridge",
-  "version": "1.22.3",
+  "version": "1.22.5",
   "description": "Two-way MCP bridge between Claude and Codex: prompts into a live Codex thread, messages into a running Claude Code session.",
   "keywords": [
     "mcp",

package/plugin.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://agent-plugins.org/schemas/1.0.0/plugin.schema.json",
   "name": "codex-mcp-bridge",
-  "version": "1.22.3",
+  "version": "1.22.5",
   "description": "Connect ChatGPT to your own Codex Desktop projects and conversations.",
   "author": {
     "name": "Bui Dang Minh",

package/scripts/install-native-relay.mjs

@@ -23,7 +23,7 @@ import { enableCodexFullAccess, fullAccessEnabled } from "../src/codex-full-acce
 
 exitForVersionRequest(import.meta.url);
 
-const VERSION = "1.22.3";
+const VERSION = "1.22.5";
 const root = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
 const entry = path.join(root, "src", "mcp-supervisor.mjs");
 const entryArgs = ["native-relay-companion.mjs"];

package/src/claude-bridge.mjs

@@ -26,10 +26,11 @@ import { submitClaudeCodeComposer, trustClaudeCodeComposer } from "./claude-comp
 import { createHardenedRootPolicy } from "./hardened-root-policy.mjs";
 import { AGENT_PROMPT_GUIDANCE, PROMPT_FIELD_HINT } from "./prompt-guidance.mjs";
 import { registerProjectOnboardingTools } from "./project-onboarding-tools.mjs";
+import { discoverClaudeProject } from "./claude-project-discovery.mjs";
 
 exitForVersionRequest(import.meta.url);
 
-const VERSION = "1.22.3";
+const VERSION = "1.22.5";
 void import("./telemetry.mjs").then(({ startUsageReporting }) => startUsageReporting({ version: VERSION })).catch(() => {});
 const FORWARD_MIN_INTERVAL_MS = 5000;
 const FORWARD_MAX_PER_SESSION = 50;
@@ -71,7 +72,8 @@ const creations = new ClaudeSessionCreation({
   submit: submitClaudeCodeComposer,
   trust: trustClaudeCodeComposer,
   settle: () => delay(2500),
-  listTasks: (account) => readClaudeDesktopTasks({ account }).filter((task) => rootPolicy.allows(task.cwd)),
+  listTasks: (account) => readClaudeDesktopTasks({ account }),
+  resolveProject: (task) => discoverClaudeProject(task, { policy: rootPolicy })?.cwd ?? null,
   listSessions: () => listClaudeSessions().filter((session) => rootPolicy.allows(session.cwd)),
   readContext: (session, account) => readClaudeDesktopContext(session, { account }),
   readTranscript: (...args) => {
@@ -254,21 +256,25 @@ async function startClaudeCreation({ requestId, cwd, prompt, autoSubmit = proces
     sender: rootPolicy.capture(sender.cwd, "Codex sender working directory"),
     recipient: rootPolicy.capture(cwd, "Claude creation working directory"),
   } : null;
-  const receipt = await creations.start({ requestId, cwd, prompt, autoSubmit, trustProject, account: accounts.claude, senderThreadId: sender.threadId,
-    beforeOpen: async () => {
-      runtime.assertCurrent();
-      assertAccountIdentity(selectedAccounts);
-      recheckScopeBindings(scopeBindings);
-      if (rootPolicy.enabled && !rootPolicy.same(cwd, scopeBindings.recipient.path)) throw new Error("The Claude creation working directory changed before opening Desktop");
-      const current = await assertSender(meta);
-      if (JSON.stringify(current) !== JSON.stringify(sender)) throw new Error("The calling Codex turn changed before opening Claude Desktop");
-      runtime.assertCurrent();
-      assertAccountIdentity(selectedAccounts);
-      recheckScopeBindings(scopeBindings);
-      if (rootPolicy.enabled && !rootPolicy.same(cwd, scopeBindings.recipient.path)) throw new Error("The Claude creation working directory changed before opening Desktop");
-    },
-  });
-  if (rootPolicy.enabled) creationRootBindings.set(requestId, scopeBindings);
+  let receipt;
+  try {
+    receipt = await creations.start({ requestId, cwd, prompt, autoSubmit, trustProject, account: accounts.claude, senderThreadId: sender.threadId,
+      beforeOpen: async () => {
+        runtime.assertCurrent();
+        assertAccountIdentity(selectedAccounts);
+        recheckScopeBindings(scopeBindings);
+        if (rootPolicy.enabled && !rootPolicy.same(cwd, scopeBindings.recipient.path)) throw new Error("The Claude creation working directory changed before opening Desktop");
+        const current = await assertSender(meta);
+        if (JSON.stringify(current) !== JSON.stringify(sender)) throw new Error("The calling Codex turn changed before opening Claude Desktop");
+        runtime.assertCurrent();
+        assertAccountIdentity(selectedAccounts);
+        recheckScopeBindings(scopeBindings);
+        if (rootPolicy.enabled && !rootPolicy.same(cwd, scopeBindings.recipient.path)) throw new Error("The Claude creation working directory changed before opening Desktop");
+      },
+    });
+  } finally {
+    if (rootPolicy.enabled && creations.requests.has(requestId) && !creationRootBindings.has(requestId)) creationRootBindings.set(requestId, scopeBindings);
+  }
   return { ...textResult(JSON.stringify(receipt, null, 2)), structuredContent: { creation: receipt } };
 }
 
@@ -414,13 +420,18 @@ registerTool(
         if (expectedCwd !== undefined) { try { assertClaudeSessionCwd(task, expectedCwd); } catch { return false; } }
         return true;
       }).map(({ taskId, title, cwd }) => ({ taskId, title, cwd, alive: sessions.some((session) => session.desktop?.taskId === taskId) }));
+      const relocatedProjects = saved.flatMap(task => {
+        const candidate = discoverClaudeProject(task, { policy: rootPolicy });
+        if (!candidate?.relocated || (expectedCwd !== undefined && !rootPolicy.same(candidate.cwd, expectedCwd))) return [];
+        return [{ taskId: task.taskId, originalCwd: candidate.originalCwd, resolvedCwd: candidate.cwd, liveVerified: false, resumable: false }];
+      });
       const summary = sessions.length
         ? `${sessions.length} Claude${desktopOnly ? " Desktop" : ""} session(s):\n\n${sessions.map(formatSessionRow).join("\n")}`
         : discovery.excluded.length
           ? `Found ${discovery.candidateCount} registered Claude Desktop candidate(s) with messaging endpoints, but their Desktop task identities could not be verified. Delivery remains blocked.`
           : desktopOnly ? missingDesktopSession : "No live Claude Code session found.";
-      return { ...textResult([summary, ...discoveryDetails(discovery), ...(savedTasks.length ? [`Saved Desktop tasks (resume unfinished work with target auto and expectedTaskId):\n${JSON.stringify(savedTasks, null, 2)}`] : [])].join("\n")),
-        structuredContent: { account: publicAccountState(account), sessions: sessions.map(({ socket, bridgeSessionId, ...session }) => session), savedTasks, discovery } };
+      return { ...textResult([summary, ...discoveryDetails(discovery), ...(savedTasks.length ? [`Saved Desktop tasks (resume unfinished work with target auto and expectedTaskId):\n${JSON.stringify(savedTasks, null, 2)}`] : []), ...(relocatedProjects.length ? [`Relocated project candidates (new conversation only when authorized; old tasks are not verified or resumable at the new path):\n${JSON.stringify(relocatedProjects, null, 2)}`] : [])].join("\n")),
+        structuredContent: { account: publicAccountState(account), sessions: sessions.map(({ socket, bridgeSessionId, ...session }) => session), savedTasks, relocatedProjects, discovery } };
     } catch (err) {
       return failure(err);
     }

package/src/claude-project-discovery.mjs

@@ -0,0 +1,25 @@
+import fs from "node:fs";
+import path from "node:path";
+import { resolveWorkspacePath } from "./platform.mjs";
+
+export function discoverClaudeProject(task, { policy, resolveWorkspace = resolveWorkspacePath }) {
+  if (!task || task.isArchived !== false || typeof task.taskId !== "string" || !task.taskId || task.fileTaskId !== task.taskId ||
+      typeof task.cwd !== "string" || !path.isAbsolute(task.cwd) || task.cwd.includes("\0")) return null;
+  try {
+    let cwd;
+    let relocated = false;
+    try {
+      cwd = fs.realpathSync.native(task.cwd);
+    } catch (error) {
+      if (error.code !== "ENOENT" || policy.mode !== "project-policy") return null;
+      try { fs.lstatSync(task.cwd); return null; } catch (missing) { if (missing.code !== "ENOENT") return null; }
+      policy.assertDiscoverySource(task.cwd);
+      const candidate = resolveWorkspace(task.cwd, { requireUnique: true });
+      if (!candidate.remapped || !candidate.writable) return null;
+      cwd = fs.realpathSync.native(candidate.path);
+      relocated = true;
+    }
+    const binding = policy.capture(cwd, "Discovered Claude project directory");
+    return { cwd: binding.path, originalCwd: task.cwd, relocated, binding };
+  } catch { return null; }
+}

package/src/claude-session-creation.mjs

@@ -60,7 +60,7 @@ function receipt(request) {
 }
 
 export class ClaudeSessionCreation {
-  constructor({ open, submit, trust, settle = async () => {}, listTasks, listSessions, readContext, readTranscript, readAccount, assertProcess, realpath = (directory) => {
+  constructor({ open, submit, trust, settle = async () => {}, listTasks, listSessions, readContext, readTranscript, readAccount, assertProcess, resolveProject, realpath = (directory) => {
     const canonical = fs.realpathSync.native(directory);
     if (!fs.statSync(canonical).isDirectory()) throw new Error("Not a directory");
     return canonical;
@@ -68,7 +68,7 @@ export class ClaudeSessionCreation {
     for (const [name, dependency] of Object.entries({ open, listTasks, listSessions, readContext, readTranscript, readAccount, assertProcess, realpath })) {
       if (typeof dependency !== "function") throw new TypeError(`${name} must be a function`);
     }
-    Object.assign(this, { open, submit, trust, settle, listTasks, listSessions, readContext, readTranscript, readAccount, assertProcess, realpath, platform });
+    Object.assign(this, { open, submit, trust, settle, listTasks, listSessions, readContext, readTranscript, readAccount, assertProcess, resolveProject, realpath, platform });
     this.requests = new Map();
     this.queue = Promise.resolve();
   }
@@ -83,6 +83,7 @@ export class ClaudeSessionCreation {
   }
 
   sameCwd(left, right) {
+    if (typeof left !== "string" || typeof right !== "string") return false;
     return this.platform === "win32" ? left.toLowerCase() === right.toLowerCase() : left === right;
   }
 
@@ -123,11 +124,14 @@ export class ClaudeSessionCreation {
       if (sameAccount(existing.account, identity) && PENDING.has(existing.status) && !composerReleased) fail("CLAUDE_CREATION_PENDING", "A creation request is already pending for this account; inspect or explicitly abandon that request before opening another project in the shared composer.");
     }
     const tasks = await this.listTasks(account);
-    if (!Array.isArray(tasks) || tasks.length > MAX_TASKS || tasks.some((task) => !string(task?.taskId, 256) || (task.fileTaskId !== undefined && task.fileTaskId !== task.taskId))) fail("CLAUDE_CREATION_TASKS_INVALID", "The existing native task baseline cannot be verified.");
-    let existingProject = false;
+    const validTasks = value => Array.isArray(value) && value.length <= MAX_TASKS && value.every(task => string(task?.taskId, 256) && (task.fileTaskId === undefined || task.fileTaskId === task.taskId)) && new Set(value.map(task => task.taskId)).size === value.length;
+    if (!validTasks(tasks)) fail("CLAUDE_CREATION_TASKS_INVALID", "The existing native task baseline cannot be verified.");
+    const baseline = new Set(tasks.map(task => task.taskId));
+    const projectCwd = async task => this.resolveProject ? this.resolveProject(task) : this.canonical(task.cwd);
+    let existingProject;
     for (const task of tasks) {
       if (task.isArchived !== false) continue;
-      try { if (this.sameCwd(await this.canonical(task.cwd), canonical)) existingProject = true; } catch {}
+      try { if (this.sameCwd(await projectCwd(task), canonical)) { existingProject = task; break; } } catch {}
     }
     if (!existingProject) fail("CLAUDE_CREATION_PROJECT_NOT_FOUND", "The canonical directory must already belong to a nonarchived Claude Desktop task.");
     if (autoSubmit && typeof this.submit !== "function") fail("CLAUDE_CREATION_SUBMIT_UNAVAILABLE", "Native composer submission is not available.");
@@ -139,7 +143,20 @@ export class ClaudeSessionCreation {
       if (typeof beforeOpen !== "function") fail("CLAUDE_CREATION_PREFLIGHT_INVALID", "beforeOpen must be a function.");
       await beforeOpen();
     }
-    const request = { requestId, cwd: canonical, prompt, initialMessage, account: identity, senderThreadId, baseline: [...new Set(tasks.map((task) => task.taskId))], status: "launch_uncertain", reason: "The Desktop launch outcome is uncertain; inspect this request before taking further action." };
+    if (this.resolveProject) {
+      const currentTasks = await this.listTasks(account);
+      if (!validTasks(currentTasks)) fail("CLAUDE_CREATION_TASKS_INVALID", "The current native task baseline cannot be verified.");
+      const matches = currentTasks.filter(task => task.taskId === existingProject.taskId && task.fileTaskId === existingProject.fileTaskId && task.cwd === existingProject.cwd && task.isArchived === false);
+      if (matches.length !== 1 || !this.sameCwd(await projectCwd(matches[0]), canonical)) {
+        fail("CLAUDE_CREATION_PROJECT_NOT_FOUND", "The saved project or its authorized current directory changed before opening Desktop.");
+      }
+      for (const task of currentTasks) baseline.add(task.taskId);
+      if (baseline.size > MAX_TASKS) fail("CLAUDE_CREATION_TASKS_INVALID", "The native task baseline exceeds the creation limit.");
+      if (beforeOpen) await beforeOpen();
+    }
+    const projectSource = this.resolveProject ? { taskId: existingProject.taskId, fileTaskId: existingProject.fileTaskId, cwd: existingProject.cwd } : undefined;
+    const request = { requestId, cwd: canonical, prompt, initialMessage, account: identity, senderThreadId, baseline: [...baseline], ...(projectSource ? { projectSource } : {}), status: "launch_uncertain", reason: "The Desktop launch outcome is uncertain; inspect this request before taking further action." };
+    await this.revalidateProjectSource(request, account);
     this.requests.set(requestId, request);
     try {
       await this.open(url);
@@ -155,11 +172,25 @@ export class ClaudeSessionCreation {
     return receipt(request);
   }
 
+  async revalidateProjectSource(request, account) {
+    if (!this.resolveProject) return;
+    const source = request.projectSource;
+    if (!source) fail("CLAUDE_CREATION_PROJECT_NOT_FOUND", "The original saved project source is unavailable; submission is not authorized.");
+    const tasks = await this.listTasks(account);
+    if (!Array.isArray(tasks) || tasks.length > MAX_TASKS) fail("CLAUDE_CREATION_TASKS_INVALID", "The saved project source cannot be verified.");
+    const matches = tasks.filter(task => task?.taskId === source.taskId);
+    if (matches.length !== 1 || matches[0].fileTaskId !== source.fileTaskId || matches[0].cwd !== source.cwd || matches[0].isArchived !== false ||
+        !this.sameCwd(await this.resolveProject(matches[0]), request.cwd)) {
+      fail("CLAUDE_CREATION_PROJECT_NOT_FOUND", "The original saved project or its authorization changed; submission is not authorized.");
+    }
+  }
+
   async completeRequest(request, { account, senderThreadId, beforeOpen, trustProject }) {
     if (typeof this.submit !== "function") fail("CLAUDE_CREATION_SUBMIT_UNAVAILABLE", "Native composer submission is not available.");
     if (trustProject && typeof this.trust !== "function") fail("CLAUDE_CREATION_TRUST_UNAVAILABLE", "Authorized project trust preparation is not available.");
     await this.checkAccount(account, request.account);
     if (beforeOpen) await beforeOpen();
+    await this.revalidateProjectSource(request, account);
     if (trustProject) {
       const trusted = await this.trust({ cwd: request.cwd, prompt: request.initialMessage });
       if (!["trusted", "absent"].includes(trusted?.status)) {
@@ -171,6 +202,7 @@ export class ClaudeSessionCreation {
     }
     await this.checkAccount(account, request.account);
     if (beforeOpen) await beforeOpen();
+    await this.revalidateProjectSource(request, account);
     request.submissionAttempted = true;
     request.status = "submission_uncertain";
     request.reason = "Native submission was attempted; inspect this request before retrying. The bridge will not press Send again.";
@@ -178,6 +210,7 @@ export class ClaudeSessionCreation {
       const submission = await this.submit({ prompt: request.initialMessage, cwd: request.cwd, beforeSubmit: async () => {
         await this.checkAccount(account, request.account);
         if (beforeOpen) await beforeOpen();
+        await this.revalidateProjectSource(request, account);
       } });
       if (submission?.status === "blocked" && submission.submissionAttempted === false) delete request.submissionAttempted;
       request.status = submission?.status === "submitted" ? "awaiting_session" : submission?.status === "blocked" ? "awaiting_user" : "submission_uncertain";
@@ -263,7 +296,10 @@ export class ClaudeSessionCreation {
       if ((request.status === "awaiting_project_confirmation" || request.observedCwd !== undefined) && (!string(request.observedCwd, 8192) || !paths.isAbsolute(request.observedCwd))) fail("CLAUDE_CREATION_STATE_INVALID", "A retained observed directory is invalid.");
       if (request.status === "awaiting_project_confirmation" && (request.submissionObserved !== true || this.sameCwd(request.cwd, request.observedCwd))) fail("CLAUDE_CREATION_STATE_INVALID", "A pending project confirmation is invalid.");
       if (request.ambiguitySeen !== undefined && typeof request.ambiguitySeen !== "boolean") fail("CLAUDE_CREATION_STATE_INVALID", "A retained ambiguity marker is invalid.");
-      restored.set(request.requestId, structuredClone({ requestId: request.requestId, cwd: request.cwd, prompt: request.prompt, initialMessage: request.initialMessage, account: { fingerprint: request.account.fingerprint, root: request.account.root }, senderThreadId: request.senderThreadId, baseline: request.baseline, status: request.status, reason: request.reason, ...(request.submissionAttempted ? { submissionAttempted: true } : {}), ...(request.ambiguitySeen || request.status === "ambiguous" ? { ambiguitySeen: true } : {}), ...(request.submissionObserved ? { submissionObserved: true } : {}), ...(request.observedCwd ? { observedCwd: request.observedCwd } : {}), ...(hasSession ? { sessionId: request.sessionId, taskId: request.taskId, title: request.title } : {}) }));
+      if (request.projectSource !== undefined && (!string(request.projectSource?.taskId, 256) || !request.baseline.includes(request.projectSource.taskId) ||
+          (request.projectSource.fileTaskId !== undefined && request.projectSource.fileTaskId !== request.projectSource.taskId) ||
+          !string(request.projectSource.cwd, 8192) || !paths.isAbsolute(request.projectSource.cwd))) fail("CLAUDE_CREATION_STATE_INVALID", "A retained project source is invalid.");
+      restored.set(request.requestId, structuredClone({ requestId: request.requestId, cwd: request.cwd, prompt: request.prompt, initialMessage: request.initialMessage, account: { fingerprint: request.account.fingerprint, root: request.account.root }, senderThreadId: request.senderThreadId, baseline: request.baseline, ...(request.projectSource ? { projectSource: { taskId: request.projectSource.taskId, fileTaskId: request.projectSource.fileTaskId, cwd: request.projectSource.cwd } } : {}), status: request.status, reason: request.reason, ...(request.submissionAttempted ? { submissionAttempted: true } : {}), ...(request.ambiguitySeen || request.status === "ambiguous" ? { ambiguitySeen: true } : {}), ...(request.submissionObserved ? { submissionObserved: true } : {}), ...(request.observedCwd ? { observedCwd: request.observedCwd } : {}), ...(hasSession ? { sessionId: request.sessionId, taskId: request.taskId, title: request.title } : {}) }));
     }
     this.requests = restored;
   }

package/src/codex-native-response.mjs

@@ -2,6 +2,7 @@ import crypto from "node:crypto";
 import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
+import { isDeepStrictEqual } from "node:util";
 import { scanRollout } from "./rollout-reader.mjs";
 import { findRolloutSegments, confirmsDesktopTask, isLegacyCliSession, assertRolloutSetStable } from "./rollout-segments.mjs";
 
@@ -81,20 +82,22 @@ function samePathBoundary(expected, current) {
       entry.path === current.ancestors[index].path && entry.dev === current.ancestors[index].dev && entry.ino === current.ancestors[index].ino);
 }
 
-function readStable(found, maxBytes, { threadId, turnId, afterOffset = 0, prefixSize } = {}) {
+function readStable(found, maxBytes, { threadId, turnId, afterOffset = 0, prefixSize, dispatchOutputs, dispatchAfterOffset = afterOffset } = {}) {
   for (let attempt = 0; ; attempt++) {
-    try { return readStableOnce(found, maxBytes, { threadId, turnId, afterOffset, prefixSize }); }
+    try { return readStableOnce(found, maxBytes, { threadId, turnId, afterOffset, prefixSize, dispatchOutputs, dispatchAfterOffset }); }
     catch (error) {
       if (attempt >= 2 || !/changed while (reading|opening)|incomplete final record/.test(error.message)) throw error;
     }
   }
 }
 
-function readStableOnce(found, maxBytes, { threadId, turnId, afterOffset, prefixSize }) {
+function readStableOnce(found, maxBytes, { threadId, turnId, afterOffset, prefixSize, dispatchOutputs, dispatchAfterOffset }) {
   const { file, sessions } = found;
   if (!Number.isSafeInteger(maxBytes) || maxBytes < 1 || maxBytes > MAX_ROLLOUT_BYTES) throw new Error("The Codex rollout read limit is invalid");
   const beforeBoundary = capturePathBoundary(file, sessions);
   const records = [];
+  const dispatches = [];
+  const otherTurnStarts = [];
   const digest = crypto.createHash("sha256");
   let session, latestContext, retainedBytes = 0, turnBeforeWatermark = false;
   const snapshot = scanRollout(file, {
@@ -111,6 +114,19 @@ function readStableOnce(found, maxBytes, { threadId, turnId, afterOffset, prefix
       }
       if (record.type === "turn_context") latestContext = record.payload;
       const entry = { record, start };
+      if (start >= dispatchAfterOffset && dispatchOutputs && record.type === "response_item" && record.payload.type === "function_call_output" &&
+          record.payload.namespace === "codex_app" && record.payload.name === "send_message_to_thread" && dispatchOutputs.includes(record.payload.output)) {
+        const metadata = record.payload.internal_chat_message_metadata_passthrough;
+        const selectedTurnId = record.payload.turn_id ?? record.payload.root_turn_id ?? metadata?.turn_id ?? metadata?.root_turn_id;
+        if (!UUID.test(selectedTurnId) || !recordBelongsToTurn(entry, threadId, selectedTurnId)) throw new Error("The native dispatch has no consistent turn identity");
+        dispatches.push({ turnId: selectedTurnId, start });
+        if (dispatches.length > 1) throw new Error("Multiple post-send native dispatches match the reply receipt");
+      }
+      if (turnId && start >= afterOffset && (record.type === "turn_context" || record.type === "event_msg" && STARTED.has(record.payload.type)) &&
+          !recordBelongsToTurn(entry, threadId, turnId)) {
+        otherTurnStarts.push(start);
+        if (otherTurnStarts.length > 65536) throw new Error("The native turn boundary count exceeds its read limit");
+      }
       if (turnId && recordBelongsToTurn(entry, threadId, turnId)) {
         if (start < afterOffset) { turnBeforeWatermark = true; return; }
         retainedBytes += bytes;
@@ -123,7 +139,7 @@ function readStableOnce(found, maxBytes, { threadId, turnId, afterOffset, prefix
   if (!samePathBoundary(beforeBoundary, afterBoundary) || snapshot.identity.dev !== beforeBoundary.file.dev || snapshot.identity.ino !== beforeBoundary.file.ino) {
     throw new Error("The Codex rollout changed while reading");
   }
-  return { ...snapshot, file, sessions, records, retainedBytes, session, latestContext, turnBeforeWatermark, prefixSha256: digest.digest("hex") };
+  return { ...snapshot, file, sessions, records, dispatches, otherTurnStarts, retainedBytes, session, latestContext, turnBeforeWatermark, prefixSha256: digest.digest("hex") };
 }
 
 function canonicalDirectory(value, label) {
@@ -209,10 +225,11 @@ function completedMemoryCitation(item) {
       !Number.isSafeInteger(entry.lineStart) || entry.lineStart < 1 || !Number.isSafeInteger(entry.lineEnd) || entry.lineEnd < entry.lineStart) ||
       citation.rolloutIds.some((id) => typeof id !== "string" || !UUID.test(id))) return null;
   const entries = citation.entries.map((entry) => `${entry.path}:${entry.lineStart}-${entry.lineEnd}|note=[${entry.note}]`).join("\n");
-  return `<oai-mem-citation>\n<citation_entries>\n${entries}\n</citation_entries>\n<rollout_ids>\n${citation.rolloutIds.join("\n")}\n</rollout_ids>\n</oai-mem-citation>`;
+  const rolloutIds = citation.rolloutIds.join("\n");
+  return `<oai-mem-citation>\n<citation_entries>\n${entries ? `${entries}\n` : ""}</citation_entries>\n<rollout_ids>\n${rolloutIds ? `${rolloutIds}\n` : ""}</rollout_ids>\n</oai-mem-citation>`;
 }
 
-function inspectTurnRecords(records, threadId, turnId, cwd, { requireDispatch } = {}) {
+function inspectTurnRecords(records, threadId, turnId, cwd, { requireDispatch, otherTurnStarts = [] } = {}) {
   const turns = records.filter((entry) => recordBelongsToTurn(entry, threadId, turnId));
   const starts = turns.filter(({ record }) => record.type === "event_msg" && STARTED.has(record.payload.type));
   const contexts = turns.filter(({ record }) => record.type === "turn_context");
@@ -222,26 +239,39 @@ function inspectTurnRecords(records, threadId, turnId, cwd, { requireDispatch }
   const lifecycleError = (check, fields) => validationError("The native turn lifecycle is missing, ambiguous, failed, or out of order", check, fields);
   if (failures.length) throw lifecycleError("lifecycle_failure", { count: failures.length, eventBytes: recordOffsets(failures) });
   for (const [kind, entries] of [["start", starts], ["context", contexts], ["completion", completions]]) {
-    if (entries.length !== 1) throw lifecycleError(`lifecycle_${kind}_count`, { count: entries.length, recordBytes: recordOffsets(entries) });
+    if (entries.length !== 1 && (kind !== "context" || !entries.length)) throw lifecycleError(`lifecycle_${kind}_count`, { count: entries.length, recordBytes: recordOffsets(entries) });
+  }
+  if (contexts.some((entry) => !isDeepStrictEqual(entry.record.payload, contexts[0].record.payload))) {
+    throw lifecycleError("lifecycle_context_changed", { count: contexts.length, recordBytes: recordOffsets(contexts) });
   }
   if (canonicalDirectory(contexts[0].record.payload.cwd, "The observed turn workspace") !== cwd) {
     throw lifecycleError("lifecycle_workspace", { contextByte: contexts[0].start });
   }
-  if (starts[0].start >= contexts[0].start || contexts[0].start >= completions[0].start) {
+  if (contexts.some((entry) => starts[0].start >= entry.start || entry.start >= completions[0].start)) {
     throw lifecycleError("lifecycle_order", { startByte: starts[0].start, contextByte: contexts[0].start, completionByte: completions[0].start });
   }
 
   let dispatch = null;
   if (requireDispatch) {
     const dispatches = turns.filter(({ record }) => record.type === "response_item" && record.payload.type === "function_call_output" &&
-      record.payload.namespace === "codex_app" && record.payload.name === (requireDispatch.operation ?? "send_message_to_thread"));
-    if (dispatches.length !== 1 || !requireDispatch.outputs.includes(dispatches[0].record.payload.output) ||
+      record.payload.namespace === "codex_app" && record.payload.name === (requireDispatch.operation ?? "send_message_to_thread") &&
+      (!requireDispatch.existingTurn || requireDispatch.outputs.includes(record.payload.output)));
+    if (dispatches.length !== 1 || !requireDispatch.outputs.includes(dispatches[0].record.payload.output) || dispatches[0].start < (requireDispatch.afterOffset ?? 0) ||
+        (requireDispatch.existingTurn && contexts[0].start >= requireDispatch.afterOffset) ||
         contexts[0].start >= dispatches[0].start || dispatches[0].start >= completions[0].start) {
       throw validationError("The newly observed turn is not correlated to the exact native dispatch", "dispatch_correlation", {
         count: dispatches.length, dispatchBytes: recordOffsets(dispatches), contextByte: contexts[0].start, completionByte: completions[0].start,
       });
     }
     dispatch = dispatches[0];
+    if (otherTurnStarts.some((start) => start > dispatch.start && start < completions[0].start)) {
+      throw validationError("Another native turn superseded the dispatch before completion", "dispatch_superseded");
+    }
+    if (requireDispatch.existingTurn && turns.some(({ record, start }) => start > dispatch.start &&
+        (record.type === "response_item" && record.payload.type === "message" && record.payload.role === "user" ||
+         record.type === "event_msg" && record.payload.type === "user_message"))) {
+      throw validationError("New user input superseded the native dispatch in the active turn", "dispatch_superseded");
+    }
   }
 
   const allAssistantEntries = turns.filter(({ record }) => record.type === "response_item" && record.payload.type === "message" && record.payload.role === "assistant");
@@ -378,10 +408,52 @@ export function inspectCodexNativeTurn({ threadId, turnId, expectedCwd, desktopE
   }
 }
 
+export function resolveCodexNativeDispatchResponse(binding, { env = process.env, maxRolloutBytes = MAX_ROLLOUT_BYTES } = {}) {
+  const { threadId, expectedCwd, executorThreadId, prompt, watermark, desktopEvidence } = binding;
+  let turnId = null;
+  try {
+    if (!UUID.test(threadId) || !UUID.test(executorThreadId) || typeof prompt !== "string" || !prompt.length) throw new Error("The native dispatch identity is invalid");
+    if (!object(watermark) || watermark.status !== "available" || watermark.threadId !== threadId) throw new Error("No trusted pre-send rollout watermark is available");
+    const cwd = canonicalDirectory(expectedCwd, "The selected native task workspace");
+    if (watermark.cwd !== cwd) throw new Error("The selected native task workspace changed after dispatch");
+    const marks = watermark.segments ?? [watermark];
+    if (!Array.isArray(marks) || !marks.length || marks.length > 64 || new Set(marks.map((mark) => mark.file)).size !== marks.length ||
+        !marks.some((mark) => mark.file === watermark.file && mark.size === watermark.size && mark.prefixSha256 === watermark.prefixSha256) ||
+        marks.some((mark) => !Number.isSafeInteger(mark.size) || mark.size < 1)) throw new Error("The pre-send segment watermarks are invalid");
+    const found = findRollouts(threadId, env);
+    if (marks.some((mark) => !found.some(({ file }) => file === mark.file))) throw new Error("A pre-send rollout segment disappeared after dispatch");
+    const outputs = delegationOutputs(executorThreadId, prompt);
+    const snapshots = found.map((entry) => {
+      const mark = marks.find(({ file }) => file === entry.file);
+      const snapshot = readStable(entry, maxRolloutBytes, { threadId, afterOffset: mark?.size ?? 0, prefixSize: mark?.size, dispatchOutputs: outputs });
+      if (mark) {
+        if (snapshot.identity.dev !== mark.identity?.dev || snapshot.identity.ino !== mark.identity?.ino || snapshot.size < mark.size) throw new Error("The selected native task rollout identity changed after dispatch");
+        if (snapshot.prefixSha256 !== mark.prefixSha256) throw new Error("The pre-send Codex rollout history changed after dispatch");
+      }
+      validateIdentity(snapshot, threadId, cwd, desktopEvidence);
+      return snapshot;
+    });
+    assertRolloutSetStable(snapshots[0].sessions, threadId, snapshots);
+    const matches = snapshots.flatMap((snapshot) => snapshot.dispatches.map((dispatch) => ({ snapshot, dispatch })));
+    if (!matches.length) return { status: "pending", threadId, turnId: null, text: "", assistantItems: [], replySha256: null };
+    if (matches.length !== 1) throw new Error("Multiple post-send native dispatches match the reply receipt");
+    validateSession(matches[0].snapshot, threadId, cwd, desktopEvidence);
+    turnId = matches[0].dispatch.turnId;
+    const result = readCodexNativeTurnResponse({ ...binding, turnId }, { env, maxRolloutBytes });
+    if (result.status === "unavailable" && result.dispatchObserved && /check=lifecycle_completion_count; count=0;/.test(result.reason)) {
+      return { status: "pending", threadId, turnId, dispatchObserved: true, text: "", assistantItems: [], replySha256: null };
+    }
+    return result;
+  } catch (error) {
+    return { ...unavailable(error), threadId, turnId, source: "codex_desktop_rollout", assistantItems: [], text: "", replySha256: null };
+  }
+}
+
 export function readCodexNativeTurnResponse({ threadId, turnId, previousTurnId, expectedCwd, executorThreadId, prompt, watermark, desktopEvidence }, { env = process.env, maxRolloutBytes = MAX_ROLLOUT_BYTES } = {}) {
+  let dispatchObserved = false;
   try {
     if (!UUID.test(threadId) || !UUID.test(turnId) || !UUID.test(executorThreadId)) throw new Error("The native response identity is invalid");
-    if (turnId === previousTurnId) throw new Error("The observed turn was already present before dispatch");
+    const existingTurn = turnId === previousTurnId;
     if (typeof prompt !== "string" || !prompt.length) throw new Error("The exact dispatched prompt is unavailable");
     if (!object(watermark) || watermark.status !== "available" || watermark.threadId !== threadId) throw new Error("No trusted pre-send rollout watermark is available");
     const cwd = canonicalDirectory(expectedCwd, "The selected native task workspace");
@@ -393,10 +465,11 @@ export function readCodexNativeTurnResponse({ threadId, turnId, previousTurnId,
     for (const mark of marks) if (!Number.isSafeInteger(mark.size) || mark.size < 1) throw new Error("The pre-send rollout watermark size is invalid");
     const found = findRollouts(threadId, env);
     if (marks.some((mark) => !found.some(({ file }) => file === mark.file))) throw new Error("A pre-send rollout segment disappeared after dispatch");
+    const outputs = delegationOutputs(executorThreadId, prompt);
     let retainedBytes = 0;
     const snapshots = found.map((entry) => {
       const mark = marks.find(({ file }) => file === entry.file);
-      const snapshot = readStable(entry, maxRolloutBytes, { threadId, turnId, afterOffset: mark?.size ?? 0, prefixSize: mark?.size });
+      const snapshot = readStable(entry, maxRolloutBytes, { threadId, turnId, afterOffset: existingTurn ? 0 : mark?.size ?? 0, prefixSize: mark?.size, dispatchOutputs: outputs, dispatchAfterOffset: mark?.size ?? 0 });
       retainedBytes += snapshot.retainedBytes;
       if (retainedBytes > maxRolloutBytes) throw new Error("The native turn exceeds the retained-record limit across segments");
       if (mark) {
@@ -409,12 +482,20 @@ export function readCodexNativeTurnResponse({ threadId, turnId, previousTurnId,
     });
     assertRolloutSetStable(snapshots[0].sessions, threadId, snapshots);
     const selected = uniqueTurn(snapshots);
+    const matchedDispatches = snapshots.flatMap((snapshot) => snapshot.dispatches);
+    if (matchedDispatches.length !== 1 || matchedDispatches[0].turnId !== turnId) throw new Error("The observed turn is not uniquely correlated to the exact native dispatch");
     validateSession(selected, threadId, cwd, desktopEvidence);
+    const selectedMark = marks.find(({ file }) => file === selected.file);
+    if (existingTurn && !selectedMark) throw new Error("The active native turn has no pre-send rollout watermark");
+    dispatchObserved = selected.records.some(({ record, start }) => start >= (selectedMark?.size ?? 0) &&
+      record.type === "response_item" && record.payload.type === "function_call_output" &&
+      record.payload.namespace === "codex_app" && record.payload.name === "send_message_to_thread" && outputs.includes(record.payload.output));
     const inspected = inspectTurnRecords(selected.records, threadId, turnId, cwd, {
-      requireDispatch: { outputs: delegationOutputs(executorThreadId, prompt) },
+      requireDispatch: { outputs, afterOffset: selectedMark?.size ?? 0, existingTurn },
+      otherTurnStarts: selected.otherTurnStarts,
     });
-    return { ...inspected, observationStatus: inspected.status };
+    return { ...inspected, observationStatus: inspected.status, ...(existingTurn ? { responseScope: "same_turn_final" } : {}) };
   } catch (error) {
-    return { ...unavailable(error), threadId, turnId, source: "codex_desktop_rollout", assistantItems: [], text: "", replySha256: null };
+    return { ...unavailable(error), ...(dispatchObserved ? { dispatchObserved: true } : {}), threadId, turnId, source: "codex_desktop_rollout", assistantItems: [], text: "", replySha256: null };
   }
 }

package/src/desktop-reply-receipts.mjs

@@ -1,6 +1,7 @@
 import fs from "node:fs";
 import path from "node:path";
 import { randomUUID } from "node:crypto";
+import { isDeepStrictEqual } from "node:util";
 import { creationRequestHash, creationIdValid } from "./native-creation-receipts.mjs";
 import { homeDir } from "./platform.mjs";
 
@@ -52,6 +53,33 @@ export class DesktopReplyReceipts {
     return id;
   }
 
+  acknowledge(id, delivered, context) {
+    const previous = this.read(id, context);
+    const acknowledgement = JSON.parse(JSON.stringify(delivered));
+    if (acknowledgement.deliveryStatus !== "accepted" || previous.creationObservation ||
+        !["unconfirmed", "accepted"].includes(previous.deliveryStatus) ||
+        !isDeepStrictEqual({ ...acknowledgement, deliveryStatus: previous.deliveryStatus }, previous)) {
+      throw new Error("Delivery acknowledgement does not match the original reply binding");
+    }
+    if (previous.deliveryStatus === "accepted") return;
+    const file = this.file(id);
+    const bytes = Buffer.from(JSON.stringify({ version: 1, deliveryId: id, owner: owner(context), delivered: acknowledgement }));
+    if (bytes.length > LIMIT) throw new Error("Reply observation binding exceeds the receipt limit");
+    const temporary = `${file}.${randomUUID()}.pending`;
+    const fd = fs.openSync(temporary, "wx", 0o600);
+    try {
+      try { fs.writeFileSync(fd, bytes); fs.fsyncSync(fd); }
+      finally { fs.closeSync(fd); }
+      if (!isDeepStrictEqual(this.read(id, context), previous) || this.file(id) !== file) {
+        throw new Error("Reply receipt changed before acknowledgement");
+      }
+      fs.renameSync(temporary, file);
+    } finally {
+      try { fs.unlinkSync(temporary); }
+      catch (error) { if (error.code !== "ENOENT") throw error; }
+    }
+  }
+
   read(id, context) {
     const file = this.file(id);
     const before = fs.lstatSync(file);

package/src/index.mjs

@@ -40,7 +40,7 @@ import { PROJECT_SETUP_TOOLS, registerProjectOnboardingTools } from "./project-o
 
 exitForVersionRequest(import.meta.url);
 
-const VERSION = "1.22.3";
+const VERSION = "1.22.5";
 void import("./telemetry.mjs").then(({ startUsageReporting }) => startUsageReporting({ version: VERSION })).catch(() => {});
 const log = (msg) => process.stderr.write(`[codex-mcp-bridge] ${msg}\n`);
 
@@ -151,11 +151,12 @@ const failure = (err) => {
 
 function replyResult(delivered, deliveryId, result, notes = []) {
   result = { activity: [], errors: [], ...result };
+  const deliveryStatus = ["completed", "completed_no_reply"].includes(result.responseStatus) ? "accepted" : delivered.deliveryStatus ?? "accepted";
   const pending = result.status === "timeout";
   const continuation = deliveryId ? `deliveryId: ${deliveryId}\n${pending ? "Continue automatically with wait_codex_reply and this deliveryId; it only observes the original send. Do not resend the prompt." : "Keep this deliveryId to inspect the same send after reconnecting."}` : "";
   return {
-    ...textResult([...notes, formatTurn(result, { desktop: true }), continuation].filter(Boolean).join("\n"), result.status === "failed" || result.status === "systemError"),
-    structuredContent: { ...result, threadId: delivered.threadId, deliveryStatus: result.responseStatus === "completed" || result.responseStatus === "completed_no_reply" ? "accepted" : delivered.deliveryStatus ?? "accepted", ...(deliveryId ? { deliveryId } : {}), nextAction: pending && deliveryId ? "wait_codex_reply" : "none" },
+    ...textResult([...notes, `deliveryStatus: ${deliveryStatus}`, formatTurn(result, { desktop: true }), continuation].filter(Boolean).join("\n"), result.status === "failed" || result.status === "systemError"),
+    structuredContent: { ...result, threadId: delivered.threadId, deliveryStatus, ...(deliveryId ? { deliveryId } : {}), nextAction: pending && deliveryId ? "wait_codex_reply" : "none" },
   };
 }
 
@@ -625,6 +626,7 @@ registerTool(
             acceptedDelivery = prepared;
           } });
           acceptedDelivery = delivered;
+          if (delivered.deliveryStatus === "accepted") replyReceipts.acknowledge(deliveryId, delivered, desktopOperation.getStore());
           notes.push(delivered.deliveryStatus === "unconfirmed" ? "Desktop delivery acknowledgement timed out; delivery is unconfirmed. Continue observing this receipt; do not resend." : "sent through Codex Desktop; no external app-server writer", `cwd: ${delivered.cwd}`);
           if (delivered.deliveryStatus === "unconfirmed") return replyResult(delivered, deliveryId, { threadId, status: "timeout", responseStatus: "unavailable", text: "" }, notes);
           if (shouldOpen) {
@@ -694,7 +696,7 @@ registerTool(
         const held = shouldOpen && !shouldRelease && client.holdsThread(threadId) ? writerLockWarning(threadId) : "";
         return textResult(`${notes.length ? `${notes.join("\n")}\n` : ""}${body}${held}`, failed);
       } catch (err) {
-        if (acceptedDelivery?.deliveryStatus === "accepted") return textResult(`threadId: ${threadId}\nTask was accepted, but its reply receipt could not be prepared: ${err.message}. Inspect the existing task; do not resend.`, true);
+        if (acceptedDelivery?.deliveryStatus === "accepted") return textResult(`threadId: ${threadId}\ndeliveryId: ${deliveryId}\nTask was accepted, but its reply receipt could not be updated: ${err.message}. Inspect the existing task; do not resend.`, true);
         return failure(err);
       }
     }, {

package/src/native-relay-companion.mjs

@@ -38,7 +38,7 @@ import { NativeCreationReceipts, creationIdValid } from "./native-creation-recei
 
 exitForVersionRequest(import.meta.url);
 
-const VERSION = "1.22.3";
+const VERSION = "1.22.5";
 const log = (msg) => process.stderr.write(`[native-relay] ${msg}\n`);
 
 function errorResponse(code, message, sent, details) {