@raysonmeng/agentbridge 0.1.3 → 0.1.5

package/.claude-plugin/marketplace.json

@@ -12,7 +12,7 @@
     {
       "name": "agentbridge",
       "description": "Bridge Claude Code and Codex through a shared daemon, push channel delivery, and reply/get_messages tools.",
-      "version": "0.1.3",
+      "version": "0.1.5",
       "author": {
         "name": "AgentBridge Contributors",
         "email": "raysonmeng@qq.com"

package/dist/cli.js

@@ -271,7 +271,7 @@ var exports_dev = {};
 __export(exports_dev, {
   runDev: () => runDev
 });
-import { execFileSync as execFileSync3 } from "child_process";
+import { execFileSync as execFileSync3, spawnSync } from "child_process";
 import { resolve } from "path";
 import { existsSync as existsSync3, cpSync, rmSync } from "fs";
 import { homedir } from "os";
@@ -282,6 +282,28 @@ async function runDev() {
   const marketplacePath = resolve(projectRoot, ".claude-plugin", "marketplace.json");
   const pluginDir = resolve(projectRoot, "plugins", "agentbridge");
   const pluginManifest = resolve(pluginDir, ".claude-plugin", "plugin.json");
+  console.log("Building CLI from source...");
+  const cliBuild = spawnSync("bun", ["run", "build:cli"], {
+    cwd: projectRoot,
+    stdio: "inherit"
+  });
+  if (cliBuild.status !== 0) {
+    console.error("  ERROR: CLI build failed. Fix build errors and try again.");
+    process.exit(1);
+  }
+  console.log(`  \u2713 CLI built successfully
+`);
+  console.log("Building plugin from source...");
+  const buildResult = spawnSync("bun", ["run", "build:plugin"], {
+    cwd: projectRoot,
+    stdio: "inherit"
+  });
+  if (buildResult.status !== 0) {
+    console.error("  ERROR: Plugin build failed. Fix build errors and try again.");
+    process.exit(1);
+  }
+  console.log(`  \u2713 Plugin built successfully
+`);
   if (!existsSync3(pluginManifest)) {
     console.error(`  ERROR: Plugin manifest not found at ${pluginManifest}`);
     console.error("  Run 'bun run build:plugin' first, or check your working tree.");
@@ -1012,7 +1034,7 @@ var init_kill = __esm(() => {
 var require_package = __commonJS((exports, module) => {
   module.exports = {
     name: "@raysonmeng/agentbridge",
-    version: "0.1.3",
+    version: "0.1.5",
     description: "Bridge between Claude Code and Codex \u2014 bidirectional agent communication via MCP Channel + JSON-RPC",
     type: "module",
     bin: {
@@ -1031,13 +1053,14 @@ var require_package = __commonJS((exports, module) => {
       start: "bun run src/bridge.ts",
       "build:cli": "mkdir -p dist && bun build src/cli.ts --outfile dist/cli.js --target bun && chmod +x dist/cli.js",
       "build:plugin": "mkdir -p plugins/agentbridge/server && bun build src/bridge.ts --outfile plugins/agentbridge/server/bridge-server.js --target bun && bun build src/daemon.ts --outfile plugins/agentbridge/server/daemon.js --target bun",
+      "verify:plugin-sync": "node scripts/verify-plugin-sync.cjs",
       postinstall: "node scripts/postinstall.cjs",
       prepublishOnly: "bun run build:cli && bun run build:plugin",
       "validate:plugin": "claude plugin validate plugins/agentbridge && claude plugin validate .claude-plugin/marketplace.json",
       test: "bun test src",
       typecheck: "tsc --noEmit",
       "validate:plugin-versions": "bun scripts/check-plugin-versions.js",
-      check: "tsc --noEmit && bun test src && bun run build:plugin && bun scripts/check-plugin-versions.js"
+      check: "tsc --noEmit && bun test src && bun run verify:plugin-sync && bun scripts/check-plugin-versions.js"
     },
     repository: {
       type: "git",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@raysonmeng/agentbridge",
-  "version": "0.1.3",
+  "version": "0.1.5",
   "description": "Bridge between Claude Code and Codex — bidirectional agent communication via MCP Channel + JSON-RPC",
   "type": "module",
   "bin": {
@@ -19,13 +19,14 @@
     "start": "bun run src/bridge.ts",
     "build:cli": "mkdir -p dist && bun build src/cli.ts --outfile dist/cli.js --target bun && chmod +x dist/cli.js",
     "build:plugin": "mkdir -p plugins/agentbridge/server && bun build src/bridge.ts --outfile plugins/agentbridge/server/bridge-server.js --target bun && bun build src/daemon.ts --outfile plugins/agentbridge/server/daemon.js --target bun",
+    "verify:plugin-sync": "node scripts/verify-plugin-sync.cjs",
     "postinstall": "node scripts/postinstall.cjs",
     "prepublishOnly": "bun run build:cli && bun run build:plugin",
     "validate:plugin": "claude plugin validate plugins/agentbridge && claude plugin validate .claude-plugin/marketplace.json",
     "test": "bun test src",
     "typecheck": "tsc --noEmit",
     "validate:plugin-versions": "bun scripts/check-plugin-versions.js",
-    "check": "tsc --noEmit && bun test src && bun run build:plugin && bun scripts/check-plugin-versions.js"
+    "check": "tsc --noEmit && bun test src && bun run verify:plugin-sync && bun scripts/check-plugin-versions.js"
   },
   "repository": {
     "type": "git",

package/plugins/agentbridge/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "agentbridge",
-  "version": "0.1.3",
+  "version": "0.1.5",
   "description": "Bridge Claude Code and Codex with a shared daemon, push channel delivery, and bidirectional reply tooling.",
   "author": {
     "name": "AgentBridge Contributors",

package/plugins/agentbridge/server/bridge-server.js

@@ -13749,8 +13749,8 @@ class ClaudeAdapter extends EventEmitter {
       this.resolvedMode = this.configuredMode;
       this.log(`Delivery mode set by AGENTBRIDGE_MODE: ${this.resolvedMode}`);
     } else {
-      this.resolvedMode = "push";
-      this.log("Delivery mode defaulting to push (set AGENTBRIDGE_MODE=pull for API key mode)");
+      this.resolvedMode = "pull";
+      this.log("Delivery mode defaulting to pull (set AGENTBRIDGE_MODE=push to opt into channel delivery)");
     }
   }
   async pushNotification(message) {
@@ -13781,6 +13781,7 @@ class ClaudeAdapter extends EventEmitter {
       this.log(`Pushed notification: ${msgId}`);
     } catch (e) {
       this.log(`Push notification failed: ${e.message}`);
+      this.queueForPull(message);
     }
   }
   queueForPull(message) {
@@ -13929,6 +13930,11 @@ ${formatted}`
 
 // src/daemon-client.ts
 import { EventEmitter as EventEmitter2 } from "events";
+
+// src/control-protocol.ts
+var CLOSE_CODE_REPLACED = 4001;
+
+// src/daemon-client.ts
 var nextSocketId = 0;
 
 class DaemonClient extends EventEmitter2 {
@@ -14047,7 +14053,11 @@ class DaemonClient extends EventEmitter2 {
       if (isCurrent) {
         this.ws = null;
         this.rejectPendingReplies("AgentBridge daemon disconnected.");
-        this.emit("disconnect");
+        if (event.code === CLOSE_CODE_REPLACED) {
+          this.emit("rejected");
+        } else {
+          this.emit("disconnect");
+        }
       }
     };
     ws.onerror = () => {};
@@ -14499,6 +14509,16 @@ class ConfigService {
   }
 }
 
+// src/bridge-disabled-state.ts
+function disabledReplyError(reason) {
+  switch (reason) {
+    case "rejected":
+      return "AgentBridge rejected this session \u2014 another Claude Code session is already connected. Close the other session first, or run `agentbridge kill` to reset.";
+    case "killed":
+      return "AgentBridge is disabled by `agentbridge kill`. Restart Claude Code (`agentbridge claude`), switch to a new conversation, or run `/resume` to reconnect.";
+  }
+}
+
 // src/bridge.ts
 var stateDir = new StateDirResolver;
 var configService = new ConfigService;
@@ -14510,6 +14530,7 @@ var claude = new ClaudeAdapter;
 var daemonClient = new DaemonClient(CONTROL_WS_URL);
 var shuttingDown = false;
 var daemonDisabled = false;
+var daemonDisabledReason = null;
 var RECONNECT_NOTIFY_COOLDOWN_MS = 30000;
 var DISABLED_RECOVERY_INTERVAL_MS = 5000;
 var lastDisconnectNotifyTs = 0;
@@ -14523,7 +14544,7 @@ claude.setReplySender(async (msg, requireReply) => {
   if (daemonDisabled) {
     return {
       success: false,
-      error: "AgentBridge is disabled by `agentbridge kill`. Restart Claude Code (`agentbridge claude`), switch to a new conversation, or run `/resume` to reconnect."
+      error: disabledReplyError(daemonDisabledReason ?? "killed")
     };
   }
   return daemonClient.sendReply(msg, requireReply);
@@ -14548,6 +14569,15 @@ daemonClient.on("disconnect", () => {
   }
   reconnectToDaemon();
 });
+daemonClient.on("rejected", async () => {
+  if (shuttingDown || daemonDisabled)
+    return;
+  log("Daemon rejected this session (close code 4001) \u2014 another Claude session is already connected");
+  daemonDisabled = true;
+  daemonDisabledReason = "rejected";
+  await claude.pushNotification(systemMessage("system_bridge_replaced", "\u26A0\uFE0F AgentBridge daemon rejected this session \u2014 another Claude Code session is already connected. Close the other session first, or run `agentbridge kill` to reset. AgentBridge \u5B88\u62A4\u8FDB\u7A0B\u62D2\u7EDD\u4E86\u6B64\u4F1A\u8BDD\u2014\u2014\u53E6\u4E00\u4E2A Claude Code \u4F1A\u8BDD\u5DF2\u5728\u8FDE\u63A5\u4E2D\u3002\u8BF7\u5148\u5173\u95ED\u53E6\u4E00\u4E2A\u4F1A\u8BDD\uFF0C\u6216\u8FD0\u884C `agentbridge kill` \u91CD\u7F6E\u3002"));
+  await daemonClient.disconnect();
+});
 claude.on("ready", async () => {
   log(`MCP server ready (delivery mode: ${claude.getDeliveryMode()}) \u2014 ensuring AgentBridge daemon...`);
   if (daemonLifecycle.wasKilled()) {
@@ -14565,6 +14595,7 @@ async function connectToDaemon(isReconnect = false) {
     await daemonLifecycle.ensureRunning();
     await daemonClient.connect();
     daemonClient.attachClaude();
+    daemonDisabledReason = null;
     if (!isReconnect) {
       claude.pushNotification(systemMessage("system_bridge_ready", "\u2705 AgentBridge bridge is ready. Daemon connected. Start Codex in another terminal with: agentbridge codex"));
     }
@@ -14578,6 +14609,7 @@ async function enterDisabledState(logMessage, notificationContent) {
   if (daemonDisabled)
     return;
   daemonDisabled = true;
+  daemonDisabledReason = "killed";
   log(logMessage);
   await claude.pushNotification(systemMessage("system_bridge_disabled", notificationContent));
   await daemonClient.disconnect();
@@ -14666,11 +14698,13 @@ async function pollDisabledRecovery() {
       await daemonClient.connect();
       daemonClient.attachClaude();
       daemonDisabled = false;
+      daemonDisabledReason = null;
       stopDisabledRecoveryPoller();
       claude.pushNotification(systemMessage("system_bridge_recovered", "\u2705 AgentBridge recovered after the killed sentinel was cleared. Daemon reconnected."));
     } catch (err) {
       log(`Disabled-state direct reconnect failed: ${err.message}`);
       daemonDisabled = false;
+      daemonDisabledReason = null;
       stopDisabledRecoveryPoller();
       reconnectToDaemon();
     }

package/plugins/agentbridge/server/daemon.js

@@ -9,8 +9,52 @@ import { spawn, execSync } from "child_process";
 import { createInterface } from "readline";
 import { EventEmitter } from "events";
 import { appendFileSync } from "fs";
+
+// src/app-server-protocol.ts
+var APP_SERVER_TRACKED_REQUEST_METHODS = [
+  "thread/start",
+  "thread/resume",
+  "turn/start"
+];
+var APP_SERVER_SERVER_REQUEST_METHODS = [
+  "item/permissions/requestApproval",
+  "item/fileChange/requestApproval",
+  "item/commandExecution/requestApproval"
+];
+var APP_SERVER_NOTIFICATION_METHODS = [
+  "turn/started",
+  "turn/completed",
+  "item/started",
+  "item/agentMessage/delta",
+  "item/completed"
+];
+var TRACKED_REQUEST_METHOD_SET = new Set(APP_SERVER_TRACKED_REQUEST_METHODS);
+var SERVER_REQUEST_METHOD_SET = new Set(APP_SERVER_SERVER_REQUEST_METHODS);
+var NOTIFICATION_METHOD_SET = new Set(APP_SERVER_NOTIFICATION_METHODS);
+function isObjectRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isTrackedAppServerRequestMethod(method) {
+  return typeof method === "string" && TRACKED_REQUEST_METHOD_SET.has(method);
+}
+function isAppServerRequestMessage(value) {
+  if (!isObjectRecord(value))
+    return false;
+  return (typeof value.id === "number" || typeof value.id === "string") && typeof value.method === "string";
+}
+function isAppServerNotification(value) {
+  if (!isObjectRecord(value))
+    return false;
+  return value.id === undefined && typeof value.method === "string" && NOTIFICATION_METHOD_SET.has(value.method);
+}
+function isAppServerResponseMessage(value) {
+  if (!isObjectRecord(value))
+    return false;
+  return (typeof value.id === "number" || typeof value.id === "string") && value.method === undefined && (("result" in value) || ("error" in value));
+}
+
+// src/codex-adapter.ts
 var LOG_FILE = "/tmp/agentbridge.log";
-var TRACKED_REQUEST_METHODS = new Set(["thread/start", "thread/resume", "turn/start"]);
 
 class CodexAdapter extends EventEmitter {
   static RESPONSE_TRACKING_TTL_MS = 30000;
@@ -23,6 +67,8 @@ class CodexAdapter extends EventEmitter {
   appPort;
   proxyPort;
   tuiConnId = 0;
+  connIdCounter = 0;
+  secondaryConnections = new Map;
   agentMessageBuffers = new Map;
   pendingRequests = new Map;
   activeTurnIds = new Set;
@@ -30,11 +76,15 @@ class CodexAdapter extends EventEmitter {
   nextProxyId = 1e5;
   upstreamToClient = new Map;
   serverRequestToProxy = new Map;
-  serverRequestTtlTimers = new Map;
   pendingServerRequests = [];
+  pendingServerResponses = new Map;
   staleProxyIds = new Map;
   bridgeRequestIds = new Map;
   intentionalDisconnect = false;
+  pendingTuiMessages = [];
+  reconnectingForNewSession = false;
+  replayingBufferedMessages = false;
+  appServerGeneration = 0;
   constructor(appPort = 4500, proxyPort = 4501) {
     super();
     this.appPort = appPort;
@@ -75,6 +125,12 @@ class CodexAdapter extends EventEmitter {
     }
     this.appServerWs?.close();
     this.appServerWs = null;
+    for (const [id, sec] of this.secondaryConnections) {
+      try {
+        sec.appServerWs?.close();
+      } catch {}
+      this.secondaryConnections.delete(id);
+    }
     this.proxyServer?.stop();
     this.proxyServer = null;
     this.clearResponseTrackingState();
@@ -135,16 +191,24 @@ class CodexAdapter extends EventEmitter {
     throw new Error("Codex app-server failed to become healthy");
   }
   connectToAppServer(isReconnect = false) {
+    const generation = ++this.appServerGeneration;
     return new Promise((resolve, reject) => {
       const appWs = new WebSocket(this.appServerUrl);
       appWs.onopen = () => {
+        if (this.appServerGeneration !== generation) {
+          appWs.close();
+          return;
+        }
         this.appServerWs = appWs;
         this.intentionalDisconnect = false;
         this.reconnectAttempts = 0;
-        this.log(isReconnect ? "Reconnected to app-server" : "Connected to app-server (persistent)");
+        this.log(isReconnect ? "Reconnected to app-server" : "Connected to app-server");
+        this.flushPendingServerResponses();
         resolve();
       };
       appWs.onmessage = (event) => {
+        if (this.appServerGeneration !== generation)
+          return;
         const data = typeof event.data === "string" ? event.data : event.data.toString();
         const forwarded = this.handleAppServerPayload(data);
         if (forwarded === null)
@@ -160,22 +224,58 @@ class CodexAdapter extends EventEmitter {
         }
       };
       appWs.onerror = () => {
+        if (this.appServerGeneration !== generation)
+          return;
         this.log("App-server connection error");
         if (!isReconnect)
           reject(new Error("Failed to connect to app-server"));
       };
       appWs.onclose = () => {
-        this.log("App-server connection closed");
-        this.appServerWs = null;
-        this.clearResponseTrackingState();
-        this.activeTurnIds.clear();
-        this.turnInProgress = false;
-        if (!this.intentionalDisconnect) {
-          this.scheduleReconnect();
-        }
+        if (this.appServerGeneration !== generation)
+          return;
+        this.handleAppServerClose();
       };
     });
   }
+  async reconnectAppServerForNewSession(tuiWs) {
+    this.appServerGeneration++;
+    this.intentionalDisconnect = true;
+    if (this.reconnectTimer) {
+      clearTimeout(this.reconnectTimer);
+      this.reconnectTimer = null;
+    }
+    const oldWs = this.appServerWs;
+    this.appServerWs = null;
+    if (oldWs) {
+      try {
+        oldWs.close();
+      } catch {}
+    }
+    this.clearResponseTrackingStateForAppServerReconnect();
+    this.activeTurnIds.clear();
+    this.turnInProgress = false;
+    try {
+      await this.connectToAppServer(false);
+      this.log("App-server reconnected for new TUI session \u2014 replaying buffered messages");
+      const messages = this.pendingTuiMessages;
+      this.pendingTuiMessages = [];
+      this.reconnectingForNewSession = false;
+      this.replayingBufferedMessages = true;
+      try {
+        for (const msg of messages) {
+          this.onTuiMessage(tuiWs, msg);
+        }
+      } finally {
+        this.replayingBufferedMessages = false;
+      }
+    } catch (err) {
+      this.log(`Failed to reconnect app-server for new session: ${err.message}`);
+      this.pendingTuiMessages = [];
+      this.reconnectingForNewSession = false;
+      this.intentionalDisconnect = false;
+      this.scheduleReconnect();
+    }
+  }
   reconnectAttempts = 0;
   reconnectTimer = null;
   static MAX_RECONNECT_ATTEMPTS = 10;
@@ -201,6 +301,16 @@ class CodexAdapter extends EventEmitter {
       }
     }, delay);
   }
+  handleAppServerClose() {
+    this.log("App-server connection closed");
+    this.appServerWs = null;
+    this.clearResponseTrackingState();
+    this.activeTurnIds.clear();
+    this.turnInProgress = false;
+    if (!this.intentionalDisconnect) {
+      this.scheduleReconnect();
+    }
+  }
   startProxy() {
     const self = this;
     this.proxyServer = Bun.serve({
@@ -208,40 +318,109 @@ class CodexAdapter extends EventEmitter {
       hostname: "127.0.0.1",
       fetch(req, server) {
         const url = new URL(req.url);
+        const isUpgrade = req.headers.get("upgrade")?.toLowerCase() === "websocket";
+        self.log(`HTTP ${req.method} ${url.pathname} (upgrade=${isUpgrade})`);
         if (url.pathname === "/healthz" || url.pathname === "/readyz") {
           return fetch(`http://127.0.0.1:${self.appPort}${url.pathname}`);
         }
         if (server.upgrade(req, { data: { connId: 0 } }))
           return;
+        self.log(`WARNING: non-upgrade HTTP request not handled: ${req.method} ${url.pathname}`);
         return new Response("AgentBridge Codex Proxy");
       },
       websocket: {
         open: (ws) => self.onTuiConnect(ws),
-        close: (ws) => self.onTuiDisconnect(ws),
+        close: (ws, code, reason) => {
+          self.log(`WebSocket close event: conn #${ws.data.connId}, code=${code}, reason=${reason || "none"}`);
+          self.onTuiDisconnect(ws);
+        },
         message: (ws, msg) => self.onTuiMessage(ws, msg)
       }
     });
   }
   onTuiConnect(ws) {
-    this.tuiConnId++;
-    ws.data.connId = this.tuiConnId;
+    const connId = ++this.connIdCounter;
+    ws.data.connId = connId;
+    if (this.tuiWs) {
+      this.log(`Secondary TUI connected (conn #${connId}, primary is #${this.tuiConnId})`);
+      this.setupSecondaryConnection(ws, connId);
+      return;
+    }
+    const previousConnId = this.tuiConnId > 0 ? this.tuiConnId : null;
+    this.tuiConnId = connId;
     this.tuiWs = ws;
+    this.threadId = null;
     this.log(`TUI connected (conn #${this.tuiConnId})`);
     this.emit("tuiConnected", this.tuiConnId);
+    if (previousConnId !== null) {
+      this.retireConnectionState(previousConnId);
+    }
+  }
+  setupSecondaryConnection(ws, connId) {
+    const appWs = new WebSocket(this.appServerUrl);
+    const entry = { tuiWs: ws, appServerWs: appWs, buffer: [] };
+    this.secondaryConnections.set(connId, entry);
+    appWs.onopen = () => {
+      if (!this.secondaryConnections.has(connId)) {
+        appWs.close();
+        return;
+      }
+      this.log(`Secondary conn #${connId}: app-server WS connected, flushing ${entry.buffer.length} buffered messages`);
+      for (const msg of entry.buffer) {
+        try {
+          appWs.send(msg);
+        } catch {}
+      }
+      entry.buffer = [];
+    };
+    appWs.onmessage = (event) => {
+      if (!this.secondaryConnections.has(connId))
+        return;
+      const data = typeof event.data === "string" ? event.data : event.data.toString();
+      try {
+        ws.send(data);
+      } catch {}
+    };
+    appWs.onerror = () => {
+      this.log(`Secondary conn #${connId}: app-server WS error`);
+    };
+    appWs.onclose = () => {
+      this.log(`Secondary conn #${connId}: app-server WS closed`);
+      const sec = this.secondaryConnections.get(connId);
+      if (sec) {
+        this.secondaryConnections.delete(connId);
+        try {
+          sec.tuiWs.close();
+        } catch {}
+      }
+    };
+  }
+  replayPendingForThread(resumedThreadId, ws) {
     const remaining = [];
     for (const buffered of this.pendingServerRequests) {
+      const belongsToThread = buffered.threadId === null || buffered.threadId === resumedThreadId;
+      if (!belongsToThread) {
+        remaining.push(buffered);
+        continue;
+      }
       const proxyId = this.nextProxyId++;
       try {
         const parsed = JSON.parse(buffered.raw);
         parsed.id = proxyId;
         ws.send(JSON.stringify(parsed));
         this.serverRequestToProxy.set(proxyId, {
+          raw: buffered.raw,
           serverId: buffered.serverId,
           connId: this.tuiConnId,
           method: buffered.method,
-          timestamp: Date.now()
+          timestamp: Date.now(),
+          threadId: buffered.threadId
         });
-        this.log(`Replayed buffered server request: ${buffered.method} (server id=${buffered.serverId} \u2192 proxy id=${proxyId})`);
+        if (buffered.threadId === null) {
+          this.log(`WARNING: Replaying pending server request with unknown threadId (experimental fallback, may surface orphan UI on wrong thread): ${buffered.method} (server id=${buffered.serverId} \u2192 proxy id=${proxyId})`);
+        } else {
+          this.log(`Replayed buffered server request on thread/resume: ${buffered.method} (server id=${buffered.serverId} \u2192 proxy id=${proxyId}, threadId=${buffered.threadId})`);
+        }
       } catch (e) {
         this.log(`Failed to replay buffered server request: ${buffered.method} (server id=${buffered.serverId}): ${e.message}`);
         remaining.push(buffered);
@@ -249,11 +428,41 @@ class CodexAdapter extends EventEmitter {
     }
     this.pendingServerRequests = remaining;
   }
+  dropOrphanPendingRequests(reason, matchThreadId = null) {
+    if (this.pendingServerRequests.length === 0)
+      return;
+    const remaining = [];
+    for (const buffered of this.pendingServerRequests) {
+      const shouldDrop = matchThreadId === null ? true : buffered.threadId !== null && buffered.threadId !== matchThreadId;
+      if (shouldDrop) {
+        this.log(`Dropped orphan pending server request: ${buffered.method} (server id=${buffered.serverId}, threadId=${buffered.threadId ?? "unknown"}, reason=${reason})`);
+        continue;
+      }
+      remaining.push(buffered);
+    }
+    this.pendingServerRequests = remaining;
+  }
   onTuiDisconnect(ws) {
     const connId = ws.data.connId;
+    const secondary = this.secondaryConnections.get(connId);
+    if (secondary) {
+      this.log(`Secondary TUI disconnected (conn #${connId})`);
+      this.secondaryConnections.delete(connId);
+      if (secondary.appServerWs) {
+        try {
+          secondary.appServerWs.close();
+        } catch {}
+      }
+      return;
+    }
     if (this.tuiWs === ws) {
       this.log(`TUI disconnected (conn #${connId})`);
       this.tuiWs = null;
+      if (this.reconnectingForNewSession) {
+        this.log("Clearing pending TUI message buffer (TUI disconnected during app-server reconnect)");
+        this.pendingTuiMessages = [];
+        this.reconnectingForNewSession = false;
+      }
       this.emit("tuiDisconnected", connId);
     } else {
       this.log(`Stale TUI disconnected (conn #${connId}, current is #${this.tuiConnId})`);
@@ -263,6 +472,17 @@ class CodexAdapter extends EventEmitter {
   onTuiMessage(ws, msg) {
     const data = typeof msg === "string" ? msg : msg.toString();
     const connId = ws.data.connId;
+    const secondary = this.secondaryConnections.get(connId);
+    if (secondary) {
+      if (secondary.appServerWs && secondary.appServerWs.readyState === WebSocket.OPEN) {
+        try {
+          secondary.appServerWs.send(data);
+        } catch {}
+      } else {
+        secondary.buffer.push(data);
+      }
+      return;
+    }
     if (connId !== this.tuiConnId) {
       this.log(`Dropping message from stale TUI conn #${connId} (current is #${this.tuiConnId})`);
       return;
@@ -271,29 +491,51 @@ class CodexAdapter extends EventEmitter {
       const parsed = JSON.parse(data);
       if (parsed.id !== undefined && !parsed.method) {
         const normalizedId = this.normalizeNumericId(parsed.id);
+        if (!isNaN(normalizedId) && this.pendingServerResponses.has(normalizedId)) {
+          this.log(`Ignoring duplicate approval response while app-server reconnect is pending (proxy id=${normalizedId})`);
+          return;
+        }
         const pending = !isNaN(normalizedId) ? this.serverRequestToProxy.get(normalizedId) : undefined;
         if (pending !== undefined) {
           if (pending.connId !== connId) {
             this.log(`Dropping stale server request response (proxy id=${normalizedId}, expected conn #${pending.connId}, got #${connId})`);
             return;
           }
+          parsed.id = pending.serverId;
+          const forwardedResponse = JSON.stringify(parsed);
           if (!this.appServerWs || this.appServerWs.readyState !== WebSocket.OPEN) {
-            this.log(`Cannot forward approval response: app-server disconnected (proxy id=${normalizedId})`);
+            this.bufferPendingServerResponse(normalizedId, pending, forwardedResponse, "app-server disconnected");
             return;
           }
-          parsed.id = pending.serverId;
           try {
-            this.appServerWs.send(JSON.stringify(parsed));
+            this.appServerWs.send(forwardedResponse);
             this.serverRequestToProxy.delete(normalizedId);
             this.log(`TUI \u2192 app-server: ${pending.method} response (proxy id=${normalizedId} \u2192 server id=${pending.serverId})`);
           } catch (e) {
-            parsed.id = normalizedId;
-            this.log(`Failed to forward approval response (proxy id=${normalizedId}): ${e.message}`);
+            this.bufferPendingServerResponse(normalizedId, pending, forwardedResponse, `send failed: ${e.message}`);
           }
           return;
         }
       }
     } catch {}
+    let detectedMethod;
+    try {
+      const parsed = JSON.parse(data);
+      detectedMethod = typeof parsed.method === "string" ? parsed.method : undefined;
+    } catch {}
+    if (!this.replayingBufferedMessages) {
+      if (detectedMethod === "initialize") {
+        this.log("Detected initialize \u2014 reconnecting app-server for fresh session");
+        this.reconnectingForNewSession = true;
+        this.pendingTuiMessages = [data];
+        this.reconnectAppServerForNewSession(ws);
+        return;
+      }
+      if (this.reconnectingForNewSession) {
+        this.pendingTuiMessages.push(data);
+        return;
+      }
+    }
     let forwarded = data;
     try {
       const parsed = JSON.parse(data);
@@ -320,16 +562,21 @@ class CodexAdapter extends EventEmitter {
   handleAppServerPayload(raw) {
     try {
       const parsed = JSON.parse(raw);
-      if (parsed.id === undefined) {
-        const forwarded = this.patchResponse(parsed, raw);
-        this.interceptServerMessage(parsed);
+      if (isAppServerNotification(parsed) || typeof parsed === "object" && parsed !== null && !("id" in parsed)) {
+        const notificationLike = parsed;
+        const forwarded = this.patchResponse(notificationLike, raw);
+        this.interceptServerMessage(notificationLike);
         return forwarded;
       }
-      if (parsed.method !== undefined) {
+      if (isAppServerRequestMessage(parsed)) {
         this.handleServerRequest(parsed, raw);
         return null;
       }
-      return this.handleAppServerResponse(parsed, raw);
+      if (isAppServerResponseMessage(parsed)) {
+        return this.handleAppServerResponse(parsed, raw);
+      }
+      this.log(`Dropping unclassifiable app-server message: ${raw.slice(0, 100)}`);
+      return null;
     } catch {
       return raw;
     }
@@ -337,9 +584,10 @@ class CodexAdapter extends EventEmitter {
   handleServerRequest(parsed, raw) {
     const serverId = parsed.id;
     const method = parsed.method;
+    const threadId = this.extractThreadIdFromParams(parsed.params);
     if (!this.tuiWs) {
-      this.pendingServerRequests.push({ raw, serverId, method });
-      this.log(`Server request buffered (no TUI): ${method} (server id=${serverId})`);
+      this.pendingServerRequests.push({ raw, serverId, method, threadId });
+      this.log(`Server request buffered (no TUI): ${method} (server id=${serverId}, threadId=${threadId ?? "unknown"})`);
       return;
     }
     const proxyId = this.nextProxyId++;
@@ -348,11 +596,24 @@ class CodexAdapter extends EventEmitter {
       this.tuiWs.send(JSON.stringify(parsed));
     } catch (e) {
       this.log(`Server request send failed, buffering: ${method} (server id=${serverId}): ${e.message}`);
-      this.pendingServerRequests.push({ raw, serverId, method });
+      this.pendingServerRequests.push({ raw, serverId, method, threadId });
       return;
     }
-    this.serverRequestToProxy.set(proxyId, { serverId, connId: this.tuiConnId, method, timestamp: Date.now() });
-    this.log(`Server request: ${method} (server id=${serverId} \u2192 proxy id=${proxyId}, conn #${this.tuiConnId})`);
+    this.serverRequestToProxy.set(proxyId, {
+      raw,
+      serverId,
+      connId: this.tuiConnId,
+      method,
+      timestamp: Date.now(),
+      threadId
+    });
+    this.log(`Server request: ${method} (server id=${serverId} \u2192 proxy id=${proxyId}, conn #${this.tuiConnId}, threadId=${threadId ?? "unknown"})`);
+  }
+  extractThreadIdFromParams(params) {
+    if (typeof params !== "object" || params === null)
+      return null;
+    const tid = params.threadId;
+    return typeof tid === "string" && tid.length > 0 ? tid : null;
   }
   normalizeNumericId(id) {
     if (typeof id === "number")
@@ -361,6 +622,30 @@ class CodexAdapter extends EventEmitter {
       return Number(id);
     return NaN;
   }
+  bufferPendingServerResponse(proxyId, pending, forwardedResponse, reason) {
+    this.pendingServerResponses.set(proxyId, {
+      raw: forwardedResponse,
+      serverId: pending.serverId,
+      method: pending.method,
+      timestamp: Date.now()
+    });
+    this.serverRequestToProxy.delete(proxyId);
+    this.log(`Buffered approval response until app-server reconnect (${reason}) (proxy id=${proxyId} \u2192 server id=${pending.serverId})`);
+  }
+  flushPendingServerResponses() {
+    if (!this.appServerWs || this.appServerWs.readyState !== WebSocket.OPEN)
+      return;
+    for (const [proxyId, pending] of this.pendingServerResponses.entries()) {
+      try {
+        this.appServerWs.send(pending.raw);
+        this.pendingServerResponses.delete(proxyId);
+        this.log(`Flushed buffered approval response after app-server reconnect (proxy id=${proxyId} \u2192 server id=${pending.serverId})`);
+      } catch (e) {
+        this.log(`Failed to flush buffered approval response (proxy id=${proxyId}): ${e.message}`);
+        break;
+      }
+    }
+  }
   handleAppServerResponse(parsed, raw) {
     const responseId = parsed.id;
     const numericId = this.normalizeNumericId(responseId);
@@ -372,6 +657,7 @@ class CodexAdapter extends EventEmitter {
         return null;
       }
       parsed.id = mapping.clientId;
+      this.log(`app-server \u2192 TUI: response (proxy id=${numericId} \u2192 client id=${String(mapping.clientId)}, conn #${mapping.connId})`);
       const forwarded = this.patchResponse(parsed, JSON.stringify(parsed));
       this.interceptServerMessage(parsed, mapping.connId);
       return forwarded;
@@ -392,7 +678,7 @@ class CodexAdapter extends EventEmitter {
     return null;
   }
   patchResponse(parsed, raw) {
-    if (parsed.error && parsed.id !== undefined) {
+    if (isAppServerResponseMessage(parsed) && parsed.error && parsed.id !== undefined) {
       const errMsg = parsed.error.message ?? "";
       if (errMsg.includes("rate limits") || errMsg.includes("rateLimits")) {
         this.log(`Patching rateLimits error \u2192 mock success (id: ${parsed.id})`);
@@ -411,24 +697,14 @@ class CodexAdapter extends EventEmitter {
           }
         });
       }
-      if (errMsg.includes("Already initialized")) {
-        this.log(`Patching "Already initialized" error (id: ${parsed.id})`);
-        return JSON.stringify({
-          id: parsed.id,
-          result: {
-            userAgent: "agent_bridge/0.1.0",
-            platformFamily: "unix",
-            platformOs: "macos"
-          }
-        });
-      }
     }
     return raw;
   }
   interceptServerMessage(msg, connId) {
     this.handleTrackedResponse(msg, connId);
-    if (msg.method)
+    if ("method" in msg && typeof msg.method === "string" && isAppServerNotification(msg)) {
       this.handleServerNotification(msg);
+    }
   }
   handleServerNotification(msg) {
     const { method, params } = msg;
@@ -443,7 +719,10 @@ class CodexAdapter extends EventEmitter {
         break;
       }
       case "item/agentMessage/delta": {
-        const buf = this.agentMessageBuffers.get(params?.itemId);
+        const itemId = params?.itemId;
+        if (typeof itemId !== "string")
+          break;
+        const buf = this.agentMessageBuffers.get(itemId);
         if (buf && params?.delta)
           buf.push(params.delta);
         break;
@@ -488,14 +767,15 @@ class CodexAdapter extends EventEmitter {
     return `${connId ?? this.tuiConnId}:${base}`;
   }
   trackPendingRequest(message, connId, _proxyId) {
-    const method = message?.method;
-    const key = this.pendingKey(message?.id, connId);
-    this.log(`[track] method=${method} id=${message?.id} (type=${typeof message?.id}) key=${key}`);
-    if (!key || !TRACKED_REQUEST_METHODS.has(method))
+    const rpcId = "id" in message ? message.id : undefined;
+    const method = "method" in message && typeof message.method === "string" ? message.method : undefined;
+    const key = this.pendingKey(rpcId, connId);
+    if (!key || !isTrackedAppServerRequestMethod(method))
       return;
     const pending = { method };
     if (method === "turn/start") {
-      const threadId = message?.params?.threadId;
+      const params = "params" in message && typeof message.params === "object" && message.params !== null ? message.params : undefined;
+      const threadId = params?.threadId;
       if (typeof threadId === "string" && threadId.length > 0) {
         pending.threadId = threadId;
       }
@@ -527,12 +807,17 @@ class CodexAdapter extends EventEmitter {
         if (typeof threadId === "string" && threadId.length > 0) {
           this.setActiveThreadId(threadId, `thread/start response ${key}`);
         }
+        this.dropOrphanPendingRequests(`thread/start (new session)`);
         break;
       }
       case "thread/resume": {
         const threadId = message?.result?.thread?.id;
         if (typeof threadId === "string" && threadId.length > 0) {
           this.setActiveThreadId(threadId, `thread/resume response ${key}`);
+          if (this.tuiWs) {
+            this.replayPendingForThread(threadId, this.tuiWs);
+          }
+          this.dropOrphanPendingRequests(`thread/resume to ${threadId}`, threadId);
         }
         break;
       }
@@ -592,20 +877,22 @@ class CodexAdapter extends EventEmitter {
       this.upstreamToClient.delete(upId);
       this.trackStaleProxyId(upId);
     }
+    const requeuedServerRequests = [];
     for (const [proxyId, pending] of this.serverRequestToProxy.entries()) {
       if (pending.connId === connId) {
-        this.clearTrackedId(this.serverRequestTtlTimers, proxyId);
-        const timer = setTimeout(() => {
-          this.serverRequestTtlTimers.delete(proxyId);
-          if (this.serverRequestToProxy.get(proxyId)?.connId === connId) {
-            this.serverRequestToProxy.delete(proxyId);
-            this.log(`Expired stale server request mapping (proxy id=${proxyId}, method=${pending.method})`);
-          }
-        }, CodexAdapter.RESPONSE_TRACKING_TTL_MS);
-        timer.unref?.();
-        this.serverRequestTtlTimers.set(proxyId, timer);
+        this.serverRequestToProxy.delete(proxyId);
+        requeuedServerRequests.push({
+          raw: pending.raw,
+          serverId: pending.serverId,
+          method: pending.method,
+          threadId: pending.threadId
+        });
+        this.log(`Requeued in-flight server request after TUI disconnect (proxy id=${proxyId}, server id=${pending.serverId}, method=${pending.method}, threadId=${pending.threadId ?? "unknown"})`);
       }
     }
+    if (requeuedServerRequests.length === 0)
+      return;
+    this.pendingServerRequests.push(...requeuedServerRequests);
   }
   trackStaleProxyId(proxyId) {
     this.clearTrackedId(this.staleProxyIds, proxyId);
@@ -640,7 +927,7 @@ class CodexAdapter extends EventEmitter {
     store.delete(id);
     return true;
   }
-  clearResponseTrackingState() {
+  clearTransientResponseTrackingState() {
     this.pendingRequests.clear();
     this.upstreamToClient.clear();
     for (const timer of this.staleProxyIds.values()) {
@@ -651,12 +938,26 @@ class CodexAdapter extends EventEmitter {
       clearTimeout(timer);
     }
     this.bridgeRequestIds.clear();
-    for (const timer of this.serverRequestTtlTimers.values()) {
-      clearTimeout(timer);
-    }
-    this.serverRequestTtlTimers.clear();
+  }
+  clearResponseTrackingState() {
+    this.clearTransientResponseTrackingState();
     this.serverRequestToProxy.clear();
     this.pendingServerRequests = [];
+    this.pendingServerResponses.clear();
+  }
+  clearResponseTrackingStateForAppServerReconnect() {
+    this.clearTransientResponseTrackingState();
+    for (const pending of this.serverRequestToProxy.values()) {
+      this.pendingServerRequests.push({
+        raw: pending.raw,
+        serverId: pending.serverId,
+        method: pending.method,
+        threadId: pending.threadId
+      });
+      this.log(`Requeued in-flight server request on app-server reconnect (server id=${pending.serverId}, method=${pending.method}, threadId=${pending.threadId ?? "unknown"})`);
+    }
+    this.serverRequestToProxy.clear();
+    this.pendingServerResponses.clear();
   }
   async checkPorts() {
     for (const port of [this.appPort, this.proxyPort]) {
@@ -1344,6 +1645,9 @@ class ConfigService {
   }
 }
 
+// src/control-protocol.ts
+var CLOSE_CODE_REPLACED = 4001;
+
 // src/daemon.ts
 var stateDir = new StateDirResolver;
 stateDir.ensure();
@@ -1585,8 +1889,10 @@ function handleControlMessage(ws, raw) {
   }
 }
 function attachClaude(ws) {
-  if (attachedClaude && attachedClaude !== ws) {
-    attachedClaude.close(4001, "replaced by a newer Claude session");
+  if (attachedClaude && attachedClaude !== ws && attachedClaude.readyState !== WebSocket.CLOSED) {
+    log(`Rejecting Claude frontend #${ws.data.clientId} \u2014 another session (#${attachedClaude.data.clientId}) is already attached (readyState=${attachedClaude.readyState})`);
+    ws.close(CLOSE_CODE_REPLACED, "another Claude session is already connected");
+    return;
   }
   clearPendingClaudeDisconnect("Claude frontend attached");
   attachedClaude = ws;