@minhspark/codex-mcp-bridge 1.13.2 → 1.13.4

package/scripts/npm-footer.sh

@@ -0,0 +1,81 @@
+_codex_bridge_installed_version() {
+  command node --input-type=module -e 'import fs from "node:fs"; const value = JSON.parse(fs.readFileSync(process.argv[1], "utf8")); if (value.name !== "@minhspark/codex-mcp-bridge" || typeof value.version !== "string" || !/^\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?(?:\+[0-9A-Za-z.-]+)?$/.test(value.version)) process.exit(1); process.stdout.write(value.version);' "$1/@minhspark/codex-mcp-bridge/package.json" 2>/dev/null
+}
+
+npm() {
+  if [ "$#" -eq 0 ]; then command npm; return $?; fi
+  local bridge_command="${1-}" bridge_global=0 bridge_packages=0 bridge_supported=1
+  local bridge_dry_run=auto bridge_root= bridge_before= bridge_after= bridge_install_status=0
+  local bridge_after_root= bridge_mode=unknown bridge_before_verified=1
+  local -a bridge_arguments bridge_context
+  bridge_arguments=("$@")
+  bridge_context=(--global)
+  case "$bridge_command" in
+    install|i) shift ;;
+    *) command npm "${bridge_arguments[@]}"; return $? ;;
+  esac
+  while [ "$#" -gt 0 ]; do
+    case "$1" in
+      -g|--global|--global=true) bridge_global=1 ;;
+      @minhspark/codex-mcp-bridge|@minhspark/codex-mcp-bridge@?*) bridge_packages=$((bridge_packages + 1)) ;;
+      --dry-run|--dry-run=true) bridge_dry_run=true ;;
+      --no-dry-run|--dry-run=false) bridge_dry_run=false ;;
+      --no-fund|--no-audit|--force|--ignore-scripts|--foreground-scripts) ;;
+      --prefix=*)
+        if [ "${#bridge_context[@]}" -ne 1 ] || [ "$1" = --prefix= ]; then bridge_supported=0; break; fi
+        bridge_context+=("$1")
+        ;;
+      --prefix)
+        if [ "$#" -lt 2 ] || [ "${#bridge_context[@]}" -ne 1 ] || [ -z "$2" ]; then bridge_supported=0; break; fi
+        case "$2" in -*) bridge_supported=0; break ;; esac
+        bridge_context+=("$1" "$2")
+        shift
+        ;;
+      *) bridge_supported=0 ;;
+    esac
+    shift
+  done
+  if [ "$bridge_supported" -ne 1 ] || [ "$bridge_global" -ne 1 ] || [ "$bridge_packages" -ne 1 ]; then
+    command npm "${bridge_arguments[@]}"
+    return $?
+  fi
+  if [ "$bridge_dry_run" = auto ]; then
+    bridge_mode="$(command npm config get dry-run "${bridge_context[@]}" 2>/dev/null)" || bridge_mode=unknown
+  else
+    bridge_mode="$bridge_dry_run"
+  fi
+  if [ "$bridge_mode" = false ]; then
+    bridge_root="$(command npm root "${bridge_context[@]}" 2>/dev/null)" || bridge_root=
+    case "$bridge_root" in
+      /*)
+        if [ -e "$bridge_root/@minhspark/codex-mcp-bridge/package.json" ]; then
+          bridge_before="$(_codex_bridge_installed_version "$bridge_root")" || bridge_before_verified=0
+        fi
+        ;;
+      *) bridge_before_verified=0 ;;
+    esac
+  fi
+  command npm "${bridge_arguments[@]}" || bridge_install_status=$?
+  if [ "$bridge_install_status" -ne 0 ]; then
+    printf 'Failed to install: @minhspark/codex-mcp-bridge (exit code %s). See npm error above.\n' "$bridge_install_status" >&2
+  elif [ "$bridge_mode" = true ]; then
+    printf 'Dry run completed: @minhspark/codex-mcp-bridge (no changes applied).\n'
+  elif [ "$bridge_mode" != false ]; then
+    printf 'Warning: npm completed, but installation mode could not be verified.\n' >&2
+  else
+    bridge_after_root="$(command npm root "${bridge_context[@]}" 2>/dev/null)" || bridge_after_root=
+    case "$bridge_after_root" in
+      /*) bridge_after="$(_codex_bridge_installed_version "$bridge_after_root")" || bridge_after= ;;
+    esac
+    if [ -z "$bridge_after" ] || [ "$bridge_before_verified" -ne 1 ] || [ "$bridge_after_root" != "$bridge_root" ]; then
+      printf 'Warning: npm completed, but the installed @minhspark/codex-mcp-bridge version could not be verified.\n' >&2
+    elif [ "$bridge_after_root" = "$bridge_root" ] && [ "$bridge_after" = "$bridge_before" ]; then
+      printf 'Already up to date: @minhspark/codex-mcp-bridge v%s\n' "$bridge_after"
+    elif [ "$bridge_after_root" = "$bridge_root" ] && [ -n "$bridge_before" ]; then
+      printf 'Successfully updated: @minhspark/codex-mcp-bridge v%s -> v%s\n' "$bridge_before" "$bridge_after"
+    else
+      printf 'Successfully installed: @minhspark/codex-mcp-bridge v%s\n' "$bridge_after"
+    fi
+  fi
+  return "$bridge_install_status"
+}

package/src/claude-bridge.mjs

@@ -5,16 +5,23 @@ import { z } from "zod";
 
 import { CodexAppServerClient } from "./app-server-client.mjs";
 import { PLATFORM_LABEL } from "./platform.mjs";
-import { PeerEndpoint, findClaudeSession, listClaudeSessions, readTranscript } from "./peer-protocol.mjs";
+import { PeerEndpoint, assertClaudeSessionCwd, findClaudeSession, listClaudeSessions, readTranscript } from "./peer-protocol.mjs";
 import { createThreadDelivery } from "./thread-delivery.mjs";
+import { exitForVersionRequest } from "./cli-version.mjs";
+import { desktopTasksConfigured } from "./native-relay.mjs";
+import { createRuntimeState } from "./runtime-state.mjs";
 
-const VERSION = "1.13.2";
+exitForVersionRequest(import.meta.url);
+
+const VERSION = "1.13.4";
 const FORWARD_MIN_INTERVAL_MS = 5000;
 const FORWARD_MAX_PER_SESSION = 50;
 
 const log = (msg) => process.stderr.write(`[claude-bridge] ${msg}\n`);
 
 const defaultPeerName = process.env.CLAUDE_BRIDGE_PEER_NAME ?? `codex-${process.pid}`;
+const desktopOnly = desktopTasksConfigured();
+const runtime = createRuntimeState({ configuration: desktopTasksConfigured });
 
 const peer = new PeerEndpoint({
   name: defaultPeerName,
@@ -33,7 +40,7 @@ const codex = new CodexAppServerClient({
  * other thread through the shared one. `claude-bridge` never picks between
  * them - see `thread-delivery.mjs`.
  */
-const delivery = createThreadDelivery({ codex, log });
+const delivery = createThreadDelivery({ codex, log, desktopOnly });
 
 const forwarding = {
   threadId: process.env.CODEX_THREAD_ID ?? null,
@@ -46,7 +53,12 @@ const textResult = (text, isError = false) => ({
   ...(isError ? { isError: true } : {}),
 });
 
-const failure = (err) => textResult(`Claude bridge error: ${err?.message ?? String(err)}`, true);
+const failure = (err) => ({
+  ...textResult(`Claude bridge error: ${err?.message ?? String(err)}${err?.msgId ? `\nMessage id: ${err.msgId}; inspect read_claude_delivery before any resend.` : ""}`, true),
+  ...(err?.msgId ? { structuredContent: { receipt: peer.readDelivery(err.msgId) } } : {}),
+});
+
+const missingDesktopSession = "No live Claude Desktop session with an exact matching ID or name and a messaging endpoint. Open or reconnect an existing Code session in Claude Desktop for the intended project. CLI sessions are excluded; do not launch a replacement CLI session.";
 
 function formatSessionRow(s) {
   const started = s.startedAt ? new Date(s.startedAt).toISOString().replace("T", " ").slice(0, 16) : "?";
@@ -72,6 +84,7 @@ async function forwardToCodexThread(record) {
   forwarding.lastAt = now;
   forwarding.count += 1;
   try {
+    runtime.assertCurrent();
     const { backend } = await delivery.deliver(
       forwarding.threadId,
       `[message from Claude session ${record.fromSocket ?? "?"}]\n\n${record.text}`,
@@ -93,7 +106,10 @@ const server = new McpServer(
       "Talk to a live Claude Code session from Codex. list_claude_sessions finds the session, " +
       "send_to_claude_session sends to its peer transport and waits for a reply to confirm receipt. " +
       "This bridge registers itself as a peer, so Claude sees it in its own agent list and can " +
-      "message back; bind_codex_thread relays those messages into a Codex thread.",
+      "message back; bind_codex_thread relays those messages into a Codex thread. " +
+      "In Desktop-only mode, both destinations must belong to their Desktop apps. " +
+      "Use an existing session with the exact project directory and sessionId; never launch a CLI session " +
+      "or an external app-server as a substitute. A receipt confirms a reply, not visual verification in the app.",
   },
 );
 
@@ -103,7 +119,7 @@ server.registerTool(
     title: "List live Claude Code sessions",
     description:
       "List Claude Code sessions running on this machine (name, pid, sessionId, cwd, how it was started). " +
-      "Use it to pick the session to talk to.",
+      "In Desktop-only mode, only Claude Desktop Code sessions are listed. Match the exact project cwd and sessionId before sending.",
     inputSchema: {
       includeDead: z.boolean().optional().describe("Also list sessions whose process is gone (default false)"),
     },
@@ -115,10 +131,10 @@ server.registerTool(
   async ({ includeDead }) => {
     try {
       const sessions = listClaudeSessions({ includeDead: includeDead ?? false }).filter(
-        (s) => s.pid !== process.pid,
+        (s) => s.pid !== process.pid && (!desktopOnly || s.entrypoint === "claude-desktop"),
       );
-      if (!sessions.length) return textResult("No live Claude Code session found.");
-      return textResult(`${sessions.length} Claude session(s):\n\n${sessions.map(formatSessionRow).join("\n")}`);
+      if (!sessions.length) return textResult(desktopOnly ? missingDesktopSession : "No live Claude Code session found.");
+      return textResult(`${sessions.length} Claude${desktopOnly ? " Desktop" : ""} session(s):\n\n${sessions.map(formatSessionRow).join("\n")}`);
     } catch (err) {
       return failure(err);
     }
@@ -132,11 +148,13 @@ server.registerTool(
     description:
       "Send a message to a running Claude Code session's peer transport and wait for its reply. " +
       "A socket write alone does not confirm that Claude received the message. Set waitSec to 0 to send without confirmation. " +
-      "A waited send is refused while earlier messages to that session still await replies; " +
-      "wait for those replies and read_claude_inbox before trying again.",
+      "Every send is refused while earlier messages to that session still await replies, including waitSec 0; " +
+      "wait for those replies and read_claude_inbox before trying again. Desktop-only mode refuses CLI or unknown " +
+      "entrypoints, partial names, ambiguous targets, and a missing or mismatched expectedCwd before sending. It never creates a replacement session.",
     inputSchema: {
       target: z.string().describe("Session name, pid or sessionId from list_claude_sessions"),
       message: z.string().describe("The message text to deliver"),
+      expectedCwd: z.string().optional().describe("Exact absolute project directory independently verified by the caller; required in Desktop-only mode"),
       waitSec: z
         .number()
         .int()
@@ -152,26 +170,36 @@ server.registerTool(
       openWorldHint: true,
     },
   },
-  async ({ target, message, waitSec }) => {
+  async ({ target, message, waitSec, expectedCwd }) => {
     try {
+      runtime.assertCurrent();
+      const session = findClaudeSession(target, { desktopOnly });
+      if (!session) return textResult(desktopOnly ? missingDesktopSession : `No live Claude session matches "${target}".`, true);
+      if (desktopOnly || expectedCwd !== undefined) assertClaudeSessionCwd(session, expectedCwd);
       await peer.start();
-      const session = findClaudeSession(target);
-      if (!session) return textResult(`No live Claude session matches "${target}".`, true);
 
       const wait = waitSec ?? 180;
       const desktop = session.entrypoint === "claude-desktop";
       const text = desktop ? `${message}\n\n[Bridge response routing: reply with ordinary text in this conversation. The bridge reads the response associated with this message from the local transcript; no cross-session reply tool is needed.]` : message;
       const { msgId, reply, delivery } = await peer.sendAndWait(session.socket, text, {
         timeoutMs: wait * 1000,
+        beforeSend: () => {
+          runtime.assertCurrent();
+          const current = findClaudeSession(session.sessionId ?? String(session.pid), { desktopOnly });
+          if (!current || current.pid !== session.pid || current.socket !== session.socket) {
+            throw new Error("The Claude destination changed while this message was queued. No message was sent; inspect the existing Desktop session.");
+          }
+          if (desktopOnly || expectedCwd !== undefined) assertClaudeSessionCwd(current, expectedCwd);
+        },
         ...(desktop ? { transcriptSession: session } : {}),
       });
       const status = reply ? "reply_received" : delivery?.status ?? (wait === 0 ? "sent_unconfirmed" : "reply_timeout");
-      const receipt = { status, msgId, target: session.name ?? String(session.pid), sessionId: session.sessionId, waitSec: wait, ...(reply ? { source: reply.source ?? "peer" } : {}) };
+      const receipt = { status, msgId, target: session.name ?? String(session.pid), sessionId: session.sessionId, cwd: session.cwd, entrypoint: session.entrypoint, waitSec: wait, ...(reply ? { source: reply.source ?? "peer" } : {}) };
       const result = (text, isError = false) => ({ ...textResult(text, isError), structuredContent: { receipt } });
-      const targetLabel = `${session.name ?? session.pid} (pid ${session.pid}, session ${session.sessionId ?? "?"})`;
+      const targetLabel = `${session.name ?? session.pid} (pid ${session.pid}, session ${session.sessionId ?? "?"}, via ${session.entrypoint ?? "unknown"}, cwd ${session.cwd ?? "?"})`;
 
       if (!reply && delivery && delivery.status !== "delivered") {
-        return result(`Claude inbox reported ${delivery.status} for ${targetLabel}.\n${delivery.reason}\nMessage id: ${msgId}`, true);
+        return result(`Claude inbox reported ${delivery.status} for ${targetLabel}.\n${delivery.reason}\nMessage id: ${msgId}\nInspect read_claude_delivery with this message ID. Do not resend, change the sender permission class, or alter recipient permissions to bypass this receipt.`, true);
       }
 
       if (wait === 0) {
@@ -192,6 +220,21 @@ server.registerTool(
   },
 );
 
+server.registerTool(
+  "read_claude_delivery",
+  {
+    title: "Inspect a Claude message receipt without resending",
+    description: "Read the latest recipient control receipt or correlated reply for a message sent by this MCP process. Unknown IDs do not prove non-delivery; retain the original receipt after a reconnect and inspect the existing Claude session before any resend.",
+    inputSchema: { msgId: z.string().describe("The original message ID returned by send_to_claude_session") },
+    annotations: { readOnlyHint: true, openWorldHint: false },
+  },
+  async ({ msgId }) => {
+    const receipt = peer.readDelivery(msgId);
+    if (!receipt) return textResult("This MCP process has no receipt for that message ID. It may belong to a previous process; do not infer failure or resend. Inspect the original Claude Desktop session.", true);
+    return { ...textResult(JSON.stringify(receipt, null, 2)), structuredContent: { receipt } };
+  },
+);
+
 server.registerTool(
   "read_claude_inbox",
   {
@@ -307,18 +350,25 @@ server.registerTool(
     try {
       await peer.start();
       const sessions = listClaudeSessions().filter((s) => s.pid !== process.pid);
+      const eligible = sessions.filter((session) => !desktopOnly || session.entrypoint === "claude-desktop");
       const lines = [
         `platform:      ${PLATFORM_LABEL} (${process.platform}/${process.arch})`,
         `bridge:        claude-bridge ${VERSION}`,
         `peer name:     ${peer.name}   (Claude sees this in its agent list)`,
         `peer socket:   ${peer.socketPath}`,
         `sender mode:   ${peer.permissionMode ?? "unknown (recipient may hold messages for approval)"}`,
-        `live sessions: ${sessions.length}`,
+        `session policy: ${desktopOnly ? "desktop-only" : "all Claude Code entrypoints"}`,
+        `live sessions: ${eligible.length}`,
+        `excluded:      ${sessions.length - eligible.length} non-Desktop session(s)`,
         `relay thread:  ${forwarding.threadId ?? "(none - use bind_codex_thread)"}`,
         `delivery:      ${delivery.describe()}`,
         `inbox:         ${peer.inbox.length} pending message(s)`,
+        `outstanding:   ${peer.pendingMessages.size} message(s) awaiting receipt or reply`,
+        ...[...peer.pendingMessages.keys()].map((id) => `pending message: ${id} (${peer.readDelivery(id)?.status ?? "sent_unconfirmed"})`),
       ];
-      return textResult(lines.join("\n"));
+      const state = runtime.status();
+      lines.push(`runtime pid:   ${state.pid}`, `loaded source: ${state.revision}`, `disk source:   ${state.diskRevision ?? "unreadable"}`, `runtime state: ${state.current ? "current" : `STALE - ${state.reason}; reconnect this MCP server in the existing task`}`);
+      return { ...textResult(lines.join("\n"), !state.current), structuredContent: { runtime: state } };
     } catch (err) {
       return failure(err);
     }

package/src/cli-version.mjs

@@ -0,0 +1,20 @@
+import { readFileSync, realpathSync, writeSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+
+export function exitForVersionRequest(entrypointUrl) {
+  if (!process.argv.slice(2).some((arg) => arg === "--version" || arg === "-v")) return;
+  if (!process.argv[1]) return;
+
+  let entrypoint;
+  try {
+    entrypoint = realpathSync(process.argv[1]);
+  } catch (error) {
+    if (error.code === "ENOENT" || error.code === "ENOTDIR") return;
+    throw error;
+  }
+  if (entrypoint !== realpathSync(fileURLToPath(entrypointUrl))) return;
+
+  const { version } = JSON.parse(readFileSync(new URL("../package.json", import.meta.url), "utf8"));
+  writeSync(process.stdout.fd, `${version}\n`);
+  process.exit(0);
+}

package/src/codex-mcp-registration.mjs

@@ -0,0 +1,25 @@
+export function codexMcpRegistration({ name, existing, node, entry, env, desktopOnly }) {
+  if (existing) {
+    const customized = ["enabled_tools", "disabled_tools", "startup_timeout_sec", "tool_timeout_sec", "disabled_reason"]
+      .some((key) => existing[key] != null && (!Array.isArray(existing[key]) || existing[key].length > 0));
+    if (existing.enabled === false || customized || existing.transport?.type !== "stdio" || existing.transport?.cwd || existing.transport?.env_vars?.length) {
+      throw new Error("The existing MCP entry has custom access, timeout, or transport settings. Keep that entry and update only its command/args using Codex settings; the installer will not remove or reset it.");
+    }
+  }
+  const values = { ...existing?.transport?.env };
+  for (const key of ["CLAUDE_BRIDGE_PEER_NAME", "CLAUDE_BRIDGE_PERMISSION_MODE", "CODEX_BRIDGE_DESKTOP_TASKS"]) {
+    if (env[key] !== undefined) values[key] = env[key];
+  }
+  values.CODEX_BRIDGE_DESKTOP_TASKS ??= desktopOnly ? "1" : "0";
+  if (!["0", "1"].includes(values.CODEX_BRIDGE_DESKTOP_TASKS)) throw new Error("CODEX_BRIDGE_DESKTOP_TASKS must be 0 or 1");
+  if (values.CLAUDE_BRIDGE_PERMISSION_MODE !== undefined && !["bypass", "prompting"].includes(values.CLAUDE_BRIDGE_PERMISSION_MODE)) {
+    throw new Error("CLAUDE_BRIDGE_PERMISSION_MODE must be bypass or prompting; never infer it from the recipient");
+  }
+  if (values.CODEX_BRIDGE_DESKTOP_TASKS === "1") values.CODEX_BRIDGE_AUTOSTART = "0";
+  const args = ["mcp", "add", name];
+  for (const [key, value] of Object.entries(values).sort(([a], [b]) => a.localeCompare(b))) {
+    if (typeof value !== "string") throw new Error(`MCP environment value ${key} must be a string`);
+    args.push("--env", `${key}=${value}`);
+  }
+  return { args: [...args, "--", node, entry], environmentKeys: Object.keys(values).sort() };
+}

package/src/index.mjs

@@ -24,8 +24,12 @@ import { runTurn } from "./turn.mjs";
 import { BridgeSecurityPolicy } from "./security-policy.mjs";
 import { DesktopTaskDelivery, DESKTOP_TOOL_BUDGET_MS } from "./thread-delivery.mjs";
 import { desktopTasksConfigured } from "./native-relay.mjs";
+import { exitForVersionRequest } from "./cli-version.mjs";
+import { createRuntimeState } from "./runtime-state.mjs";
 
-const VERSION = "1.13.2";
+exitForVersionRequest(import.meta.url);
+
+const VERSION = "1.13.4";
 const log = (msg) => process.stderr.write(`[codex-mcp-bridge] ${msg}\n`);
 
 /**
@@ -45,6 +49,7 @@ const TERMINAL_TURN_STATUSES = new Set(["completed", "interrupted", "failed"]);
 const RELEASE_TURN_STATUSES = TERMINAL_TURN_STATUSES;
 const security = new BridgeSecurityPolicy();
 const desktopTasksEnabled = desktopTasksConfigured();
+const runtime = createRuntimeState({ configuration: desktopTasksConfigured });
 const desktopTasks = new DesktopTaskDelivery({ security });
 
 const client = desktopTasksEnabled ? null : new CodexAppServerClient({
@@ -122,17 +127,23 @@ async function delegateDesktopTask({ cwd, prompt, name, model, effort, timeoutSe
   if (openInApp ?? DEFAULT_OPEN_IN_APP) {
     try {
       await desktopTasks.open(created.threadId, { deadline });
-      notes.push("opened in Codex Desktop while the task runs");
+      notes.push(created.reused ? "opened the existing task in Codex Desktop" : "opened in Codex Desktop while the task runs");
     } catch (err) {
-      notes.push(`task was accepted; opening its page failed: ${err.message}`);
+      notes.push(`${created.reused ? "existing task retained" : "task was accepted"}; opening its page failed: ${err.message}`);
     }
   }
   const lines = [
     created.reused ? "Reused the existing Codex Desktop task; the prompt was not resent" : "Delegated through Codex Desktop", `threadId: ${created.threadId}`, `name: ${created.name}`,
-    `cwd: ${created.cwd}`, `projectId: ${created.projectId}`, `project: ${created.projectName}`,
+    `cwd: ${created.cwd}`,
+    ...(created.projectAssignmentStatus === "unverified"
+      ? [`expected projectId: ${created.expectedProjectId}`, `expected project: ${created.expectedProjectName ?? "(unnamed)"}`, "project assignment: unverified", created.projectAssignmentNote]
+      : [`projectId: ${created.projectId}`, `project: ${created.projectName ?? "(unnamed)"}`, ...(created.projectAssignmentStatus === "verified" ? ["project assignment: verified in Desktop's current listing"] : [])]),
     "permissions: Codex Desktop settings; no external app-server writer",
-    ...(created.promptChanged ? ["The edited brief was not sent. Use send_to_codex_thread with this threadId for a continuation, or a distinct title for separate work."] : []), ...notes,
+    ...(created.promptChanged ? [created.projectAssignmentStatus === "unverified"
+      ? "The edited brief was not sent. Inspect this task's project assignment before continuing it."
+      : "The edited brief was not sent. Use send_to_codex_thread with this threadId for a continuation, or a distinct title for separate work."] : []), ...notes,
   ];
+  if (created.projectAssignmentStatus === "unverified") return textResult([...lines, "status: existing task retained; project assignment needs inspection"].join("\n"));
   if (!waitForReply) return textResult([...lines, created.reused ? "status: existing task; read it to check its current progress" : "status: accepted; the task is running in Desktop"].join("\n"));
   try {
     const result = await desktopTasks.wait(created.threadId, { timeoutMs: Math.max(0, deadline - Date.now()) });
@@ -270,7 +281,8 @@ const server = new McpServer(
   { name: "codex-bridge", version: VERSION },
   {
     instructions:
-      "Bridge Claude work into Codex. Prefer delegate_to_codex: it creates a named Codex thread at the " +
+      "Bridge Claude work into Codex. Prefer an existing task: inspect its exact threadId and project, then use send_to_codex_thread. " +
+      "Only use delegate_to_codex or start_codex_thread when the user explicitly requests a new task at the " +
       "requested cwd. With Desktop tasks enabled it assigns the exact saved project and starts visibly in " +
       "Codex Desktop using Desktop permissions. Otherwise it releases the bridge writer lock and opens the exact thread in " +
       "Codex Desktop. Use send_to_codex_thread only when an existing threadId is intentional; use " +
@@ -278,7 +290,26 @@ const server = new McpServer(
   },
 );
 
-server.registerTool(
+function registerTool(name, definition, handler) {
+  server.registerTool(name, definition, async (...args) => {
+    try {
+      if (!definition.annotations?.readOnlyHint) runtime.assertCurrent();
+      if (name === "codex_bridge_status") {
+        const state = runtime.status();
+        if (!state.current) return { ...failure(new Error(`${state.reason}; reconnect this MCP server in the existing task.`)), structuredContent: { runtime: state } };
+        const result = await handler(...args);
+        result.content.push({ type: "text", text: `runtime pid: ${state.pid}\nloaded source: ${state.revision}\nruntime state: current` });
+        result.structuredContent = { ...result.structuredContent, runtime: state };
+        return result;
+      }
+      return await handler(...args);
+    } catch (err) {
+      return failure(err);
+    }
+  });
+}
+
+registerTool(
   "delegate_to_codex",
   {
     title: "Delegate work to a new Codex session",
@@ -369,7 +400,7 @@ server.registerTool(
   },
 );
 
-server.registerTool(
+registerTool(
   "send_to_codex_thread",
   {
     title: "Send a prompt to a Codex thread",
@@ -494,7 +525,7 @@ server.registerTool(
   },
 );
 
-server.registerTool(
+registerTool(
   "list_codex_threads",
   {
     title: "List Codex threads",
@@ -580,7 +611,7 @@ server.registerTool(
   },
 );
 
-server.registerTool(
+registerTool(
   "start_codex_thread",
   {
     title: "Start a new Codex thread",
@@ -622,7 +653,7 @@ server.registerTool(
   },
 );
 
-server.registerTool(
+registerTool(
   "read_codex_thread",
   {
     title: "Read a Codex thread",
@@ -669,7 +700,7 @@ server.registerTool(
   },
 );
 
-server.registerTool(
+registerTool(
   "interrupt_codex_turn",
   {
     title: "Interrupt a Codex turn",
@@ -703,7 +734,7 @@ server.registerTool(
   },
 );
 
-server.registerTool(
+registerTool(
   "open_codex_thread",
   {
     title: "Open a Codex thread in the desktop app",
@@ -746,7 +777,7 @@ server.registerTool(
   },
 );
 
-server.registerTool(
+registerTool(
   "stop_codex_app_server",
   {
     title: "Stop the shared Codex app-server",
@@ -780,7 +811,7 @@ server.registerTool(
   },
 );
 
-server.registerTool(
+registerTool(
   "codex_bridge_status",
   {
     title: "Check the Codex bridge environment",

package/src/native-relay-companion.mjs

@@ -19,8 +19,11 @@ import {
   decodeNativeToolResult,
 } from "./native-relay.mjs";
 import { IS_WINDOWS, PLATFORM_LABEL } from "./platform.mjs";
+import { exitForVersionRequest } from "./cli-version.mjs";
 
-const VERSION = "1.13.2";
+exitForVersionRequest(import.meta.url);
+
+const VERSION = "1.13.4";
 const log = (msg) => process.stderr.write(`[native-relay] ${msg}\n`);
 
 function errorResponse(code, message) {