@raysonmeng/agentbridge 0.1.4 → 0.1.6

package/plugins/agentbridge/server/daemon.js

@@ -10,6 +10,58 @@ import { createInterface } from "readline";
 import { EventEmitter } from "events";
 import { appendFileSync } from "fs";
 
+// src/state-dir.ts
+import { mkdirSync, existsSync } from "fs";
+import { join } from "path";
+import { homedir, platform } from "os";
+
+class StateDirResolver {
+  stateDir;
+  constructor(envOverride) {
+    const override = envOverride ?? process.env.AGENTBRIDGE_STATE_DIR;
+    if (override) {
+      this.stateDir = override;
+    } else if (platform() === "darwin") {
+      this.stateDir = join(homedir(), "Library", "Application Support", "AgentBridge");
+    } else {
+      const xdgState = process.env.XDG_STATE_HOME ?? join(homedir(), ".local", "state");
+      this.stateDir = join(xdgState, "agentbridge");
+    }
+  }
+  ensure() {
+    if (!existsSync(this.stateDir)) {
+      mkdirSync(this.stateDir, { recursive: true });
+    }
+  }
+  get dir() {
+    return this.stateDir;
+  }
+  get pidFile() {
+    return join(this.stateDir, "daemon.pid");
+  }
+  get tuiPidFile() {
+    return join(this.stateDir, "codex-tui.pid");
+  }
+  get lockFile() {
+    return join(this.stateDir, "daemon.lock");
+  }
+  get statusFile() {
+    return join(this.stateDir, "status.json");
+  }
+  get portsFile() {
+    return join(this.stateDir, "ports.json");
+  }
+  get logFile() {
+    return join(this.stateDir, "agentbridge.log");
+  }
+  get codexWrapperLogFile() {
+    return join(this.stateDir, "codex-wrapper.log");
+  }
+  get killedFile() {
+    return join(this.stateDir, "killed");
+  }
+}
+
 // src/app-server-protocol.ts
 var APP_SERVER_TRACKED_REQUEST_METHODS = [
   "thread/start",
@@ -54,8 +106,6 @@ function isAppServerResponseMessage(value) {
 }
 
 // src/codex-adapter.ts
-var LOG_FILE = "/tmp/agentbridge.log";
-
 class CodexAdapter extends EventEmitter {
   static RESPONSE_TRACKING_TTL_MS = 30000;
   proc = null;
@@ -66,7 +116,10 @@ class CodexAdapter extends EventEmitter {
   nextInjectionId = -1;
   appPort;
   proxyPort;
+  logFile;
   tuiConnId = 0;
+  connIdCounter = 0;
+  secondaryConnections = new Map;
   agentMessageBuffers = new Map;
   pendingRequests = new Map;
   activeTurnIds = new Set;
@@ -74,15 +127,29 @@ 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;
-  constructor(appPort = 4500, proxyPort = 4501) {
+  pendingTuiMessages = [];
+  reconnectingForNewSession = false;
+  replayingBufferedMessages = false;
+  appServerGeneration = 0;
+  outageQueue = [];
+  outageTimer = null;
+  static OUTAGE_QUEUE_MAX = 64;
+  static OUTAGE_TIMEOUT_MS = 5000;
+  lastInitializeRaw = null;
+  lastInitializedRaw = null;
+  sessionRestoreInProgress = false;
+  replayPending = new Map;
+  static SESSION_REPLAY_TIMEOUT_MS = 5000;
+  constructor(appPort = 4500, proxyPort = 4501, logFile = new StateDirResolver().logFile) {
     super();
     this.appPort = appPort;
     this.proxyPort = proxyPort;
+    this.logFile = logFile;
   }
   get appServerUrl() {
     return `ws://127.0.0.1:${this.appPort}`;
@@ -117,8 +184,16 @@ class CodexAdapter extends EventEmitter {
       clearTimeout(this.reconnectTimer);
       this.reconnectTimer = null;
     }
+    this.outageQueue = [];
+    this.clearOutageTimer();
     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();
@@ -179,16 +254,32 @@ 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();
+        if (isReconnect) {
+          this.handleSessionRestoreAfterReconnect().finally(() => this.drainOutageQueue()).catch((e) => {
+            const m = e instanceof Error ? e.message : String(e);
+            this.log(`session restore unexpected error: ${m}`);
+          });
+        } else {
+          this.drainOutageQueue();
+        }
         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)
@@ -204,22 +295,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;
@@ -245,6 +372,176 @@ class CodexAdapter extends EventEmitter {
       }
     }, delay);
   }
+  handleAppServerClose() {
+    const intentional = this.intentionalDisconnect;
+    const tuiConnected = this.tuiWs !== null;
+    this.log(`App-server connection closed (intentional=${intentional}, tuiConnected=${tuiConnected}, turnInProgress=${this.turnInProgress})`);
+    this.appServerWs = null;
+    this.clearResponseTrackingState();
+    this.activeTurnIds.clear();
+    this.turnInProgress = false;
+    if (!intentional) {
+      this.scheduleReconnect();
+    }
+  }
+  bufferDuringOutage(ws, raw) {
+    if (this.outageQueue.length >= CodexAdapter.OUTAGE_QUEUE_MAX) {
+      this.log(`ERROR: outage queue overflow (${this.outageQueue.length}/${CodexAdapter.OUTAGE_QUEUE_MAX}) \u2014 closing TUI with 1011`);
+      this.outageQueue = [];
+      this.clearOutageTimer();
+      if (this.tuiWs && this.tuiWs === ws) {
+        try {
+          ws.close(1011, "agentbridge: app-server unavailable; pending TUI queue overflow");
+        } catch (e) {
+          this.log(`Failed to close TUI WS after outage queue overflow: ${e.message}`);
+        }
+      }
+      return;
+    }
+    this.outageQueue.push({ raw, connId: ws.data.connId });
+    this.log(`DIAGNOSTIC: buffered TUI message while app-server unavailable (queue size=${this.outageQueue.length}/${CodexAdapter.OUTAGE_QUEUE_MAX})`);
+    this.ensureOutageTimer();
+  }
+  ensureOutageTimer() {
+    if (this.outageTimer !== null)
+      return;
+    this.outageTimer = setTimeout(() => {
+      this.outageTimer = null;
+      const buffered = this.outageQueue.length;
+      this.outageQueue = [];
+      this.log(`ERROR: app-server did not return within ${CodexAdapter.OUTAGE_TIMEOUT_MS}ms (buffered=${buffered}) \u2014 closing TUI with 1011`);
+      const ws = this.tuiWs;
+      if (ws) {
+        try {
+          ws.close(1011, `agentbridge: app-server unavailable after ${CodexAdapter.OUTAGE_TIMEOUT_MS}ms; buffered=${buffered}`);
+        } catch (e) {
+          this.log(`Failed to close TUI WS on outage timeout: ${e.message}`);
+        }
+      }
+    }, CodexAdapter.OUTAGE_TIMEOUT_MS);
+  }
+  clearOutageTimer() {
+    if (this.outageTimer !== null) {
+      clearTimeout(this.outageTimer);
+      this.outageTimer = null;
+    }
+  }
+  async handleSessionRestoreAfterReconnect() {
+    if (!this.lastInitializeRaw) {
+      this.log("DIAGNOSTIC: no cached initialize to replay after unintentional reconnect");
+      return;
+    }
+    if (!this.appServerWs || this.appServerWs.readyState !== WebSocket.OPEN) {
+      this.log("DIAGNOSTIC: app-server not open at session restore start \u2014 skipping");
+      return;
+    }
+    this.sessionRestoreInProgress = true;
+    try {
+      this.log(`DIAGNOSTIC: replaying cached initialize to restore session (threadId=${this.threadId ?? "none"})`);
+      await this.sendReplayAndAwait(this.lastInitializeRaw, "initialize");
+      if (this.lastInitializedRaw && this.appServerWs.readyState === WebSocket.OPEN) {
+        this.appServerWs.send(this.lastInitializedRaw);
+      }
+      if (this.threadId && this.appServerWs.readyState === WebSocket.OPEN) {
+        const replayId = `agentbridge-replay-thread-resume-${Date.now()}`;
+        const resumeRaw = JSON.stringify({
+          jsonrpc: "2.0",
+          id: replayId,
+          method: "thread/resume",
+          params: { threadId: this.threadId }
+        });
+        await this.sendReplayAndAwait(resumeRaw, "thread/resume");
+      }
+      this.log(`DIAGNOSTIC: session restored after unintentional reconnect (threadId=${this.threadId ?? "none"})`);
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      this.log(`ERROR: session restore failed (${msg}) \u2014 closing TUI with 1011`);
+      const tuiWs = this.tuiWs;
+      if (tuiWs) {
+        try {
+          tuiWs.close(1011, `agentbridge: session restore failed: ${msg}`);
+        } catch (closeErr) {
+          const cm = closeErr instanceof Error ? closeErr.message : String(closeErr);
+          this.log(`Failed to close TUI after session restore failure: ${cm}`);
+        }
+      }
+    } finally {
+      this.sessionRestoreInProgress = false;
+    }
+  }
+  sendReplayAndAwait(raw, method) {
+    if (!this.appServerWs || this.appServerWs.readyState !== WebSocket.OPEN) {
+      return Promise.reject(new Error("app-server not open"));
+    }
+    let id;
+    try {
+      const parsed = JSON.parse(raw);
+      if (parsed.id === undefined) {
+        return Promise.reject(new Error(`replay payload for ${method} has no id`));
+      }
+      id = parsed.id;
+    } catch (e) {
+      const m = e instanceof Error ? e.message : String(e);
+      return Promise.reject(new Error(`replay parse failed for ${method}: ${m}`));
+    }
+    return new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        this.replayPending.delete(id);
+        reject(new Error(`replay timeout (${CodexAdapter.SESSION_REPLAY_TIMEOUT_MS}ms) for ${method} id=${JSON.stringify(id)}`));
+      }, CodexAdapter.SESSION_REPLAY_TIMEOUT_MS);
+      this.replayPending.set(id, { method, resolve, reject, timer });
+      try {
+        this.appServerWs.send(raw);
+      } catch (e) {
+        clearTimeout(timer);
+        this.replayPending.delete(id);
+        const m = e instanceof Error ? e.message : String(e);
+        reject(new Error(`replay send failed for ${method}: ${m}`));
+      }
+    });
+  }
+  tryConsumeReplayResponse(payload) {
+    const id = payload.id;
+    if (id === undefined)
+      return false;
+    const pending = this.replayPending.get(id);
+    if (!pending)
+      return false;
+    clearTimeout(pending.timer);
+    this.replayPending.delete(id);
+    if (payload.error !== undefined) {
+      const errMsg = typeof payload.error === "object" && payload.error !== null && "message" in payload.error ? String(payload.error.message ?? "unknown") : JSON.stringify(payload.error);
+      pending.reject(new Error(`${pending.method} rejected: ${errMsg}`));
+    } else {
+      pending.resolve(payload);
+    }
+    return true;
+  }
+  drainOutageQueue() {
+    if (this.outageQueue.length === 0) {
+      this.clearOutageTimer();
+      return;
+    }
+    if (!this.appServerWs || this.appServerWs.readyState !== WebSocket.OPEN)
+      return;
+    const ws = this.tuiWs;
+    if (!ws) {
+      this.outageQueue = [];
+      this.clearOutageTimer();
+      return;
+    }
+    const messages = this.outageQueue;
+    this.outageQueue = [];
+    this.clearOutageTimer();
+    this.log(`DIAGNOSTIC: replaying ${messages.length} buffered TUI messages after app-server reconnect`);
+    for (const msg of messages) {
+      try {
+        this.onTuiMessage(ws, msg.raw);
+      } catch (e) {
+        this.log(`Failed to replay buffered TUI message (conn #${msg.connId}): ${e.message}`);
+      }
+    }
+  }
   startProxy() {
     const self = this;
     this.proxyServer = Bun.serve({
@@ -252,40 +549,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);
@@ -293,11 +659,47 @@ 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})`);
+      const appServerOpen = this.appServerWs?.readyState === WebSocket.OPEN;
+      this.log(`TUI disconnected (conn #${connId}, appServerOpen=${appServerOpen}, turnInProgress=${this.turnInProgress}, pendingTuiMessages=${this.pendingTuiMessages.length}, outageQueue=${this.outageQueue.length}, reconnectingForNewSession=${this.reconnectingForNewSession})`);
       this.tuiWs = null;
+      if (this.reconnectingForNewSession) {
+        this.log("Clearing pending TUI message buffer (TUI disconnected during app-server reconnect)");
+        this.pendingTuiMessages = [];
+        this.reconnectingForNewSession = false;
+      }
+      if (this.outageQueue.length > 0 || this.outageTimer !== null) {
+        this.log(`Clearing outage queue on TUI disconnect (buffered=${this.outageQueue.length})`);
+        this.outageQueue = [];
+        this.clearOutageTimer();
+      }
       this.emit("tuiDisconnected", connId);
     } else {
       this.log(`Stale TUI disconnected (conn #${connId}, current is #${this.tuiConnId})`);
@@ -307,6 +709,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;
@@ -315,29 +728,63 @@ 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.lastInitializeRaw = data;
+        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;
+      }
+    }
+    if (detectedMethod === "initialized") {
+      this.lastInitializedRaw = data;
+    }
+    if (!this.appServerWs || this.appServerWs.readyState !== WebSocket.OPEN || this.sessionRestoreInProgress) {
+      if (this.tuiWs && this.tuiWs === ws) {
+        this.bufferDuringOutage(ws, data);
+      } else {
+        this.log(`WARNING: non-primary TUI attempted to send while app-server down \u2014 dropped (connId=${connId})`);
+      }
+      return;
+    }
     let forwarded = data;
     try {
       const parsed = JSON.parse(data);
@@ -358,14 +805,24 @@ class CodexAdapter extends EventEmitter {
     if (this.appServerWs?.readyState === WebSocket.OPEN) {
       this.appServerWs.send(forwarded);
     } else {
-      this.log(`WARNING: app-server not connected, dropping message`);
+      this.log(`WARNING: app-server closed between OPEN check and send \u2014 message lost (connId=${ws.data.connId})`);
     }
   }
   handleAppServerPayload(raw) {
     try {
       const parsed = JSON.parse(raw);
+      if (typeof parsed === "object" && parsed !== null && "id" in parsed) {
+        if (this.tryConsumeReplayResponse(parsed)) {
+          return null;
+        }
+      }
       if (isAppServerNotification(parsed) || typeof parsed === "object" && parsed !== null && !("id" in parsed)) {
         const notificationLike = parsed;
+        if (notificationLike.method === "thread/closed") {
+          const params = notificationLike.params;
+          const threadId = typeof params?.threadId === "string" ? params.threadId : "unknown";
+          this.log(`DIAGNOSTIC: app-server emitted thread/closed (threadId=${threadId}) \u2014 TUI will exit(0) silently`);
+        }
         const forwarded = this.patchResponse(notificationLike, raw);
         this.interceptServerMessage(notificationLike);
         return forwarded;
@@ -386,9 +843,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++;
@@ -397,11 +855,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")
@@ -410,6 +881,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);
@@ -421,6 +916,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;
@@ -460,17 +956,6 @@ 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;
   }
@@ -544,7 +1029,6 @@ class CodexAdapter extends EventEmitter {
     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);
-    this.log(`[track] method=${method} id=${rpcId} (type=${typeof rpcId}) key=${key}`);
     if (!key || !isTrackedAppServerRequestMethod(method))
       return;
     const pending = { method };
@@ -582,12 +1066,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;
       }
@@ -647,20 +1136,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);
@@ -695,7 +1186,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()) {
@@ -706,17 +1197,36 @@ 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();
+  }
+  static buildPortListenLsofCommand(port) {
+    return `lsof -ti tcp:${port} -sTCP:LISTEN`;
   }
   async checkPorts() {
     for (const port of [this.appPort, this.proxyPort]) {
       try {
-        const pids = execSync(`lsof -ti :${port}`, { encoding: "utf-8" }).trim();
+        const pids = execSync(CodexAdapter.buildPortListenLsofCommand(port), {
+          encoding: "utf-8"
+        }).trim();
         if (!pids)
           continue;
         const pidList = pids.split(`
@@ -746,7 +1256,9 @@ class CodexAdapter extends EventEmitter {
           throw new Error(`Port ${port} is already in use by non-Codex process(es): PID(s) ${foreignPids.join(", ")}. ` + `Please stop the process or set a different port via ${port === this.appPort ? "CODEX_WS_PORT" : "CODEX_PROXY_PORT"} env var.`);
         }
         try {
-          const remaining = execSync(`lsof -ti :${port}`, { encoding: "utf-8" }).trim();
+          const remaining = execSync(CodexAdapter.buildPortListenLsofCommand(port), {
+            encoding: "utf-8"
+          }).trim();
           if (remaining) {
             throw new Error(`Port ${port} is still occupied (PID(s): ${remaining.replace(/\n/g, ", ")}) after cleanup. ` + `Please stop the process or set a different port via ${port === this.appPort ? "CODEX_WS_PORT" : "CODEX_PROXY_PORT"} env var.`);
           }
@@ -765,7 +1277,7 @@ class CodexAdapter extends EventEmitter {
 `;
     process.stderr.write(line);
     try {
-      appendFileSync(LOG_FILE, line);
+      appendFileSync(this.logFile, line);
     } catch {}
   }
 }
@@ -973,7 +1485,7 @@ class TuiConnectionState {
 
 // src/daemon-lifecycle.ts
 import { spawn as spawn2, execFileSync } from "child_process";
-import { existsSync, readFileSync, unlinkSync, writeFileSync, openSync, closeSync, constants } from "fs";
+import { existsSync as existsSync2, readFileSync, unlinkSync, writeFileSync, openSync, closeSync, constants } from "fs";
 import { fileURLToPath } from "url";
 var DAEMON_ENTRY = process.env.AGENTBRIDGE_DAEMON_ENTRY ?? "./daemon.ts";
 var DAEMON_PATH = fileURLToPath(new URL(DAEMON_ENTRY, import.meta.url));
@@ -1111,7 +1623,7 @@ class DaemonLifecycle {
     } catch {}
   }
   wasKilled() {
-    return existsSync(this.stateDir.killedFile);
+    return existsSync2(this.stateDir.killedFile);
   }
   launch() {
     this.stateDir.ensure();
@@ -1232,116 +1744,62 @@ function isProcessAlive(pid) {
   }
 }
 
-// src/state-dir.ts
-import { mkdirSync, existsSync as existsSync2 } from "fs";
-import { join } from "path";
-import { homedir, platform } from "os";
-
-class StateDirResolver {
-  stateDir;
-  constructor(envOverride) {
-    const override = envOverride ?? process.env.AGENTBRIDGE_STATE_DIR;
-    if (override) {
-      this.stateDir = override;
-    } else if (platform() === "darwin") {
-      this.stateDir = join(homedir(), "Library", "Application Support", "AgentBridge");
-    } else {
-      const xdgState = process.env.XDG_STATE_HOME ?? join(homedir(), ".local", "state");
-      this.stateDir = join(xdgState, "agentbridge");
-    }
-  }
-  ensure() {
-    if (!existsSync2(this.stateDir)) {
-      mkdirSync(this.stateDir, { recursive: true });
-    }
-  }
-  get dir() {
-    return this.stateDir;
-  }
-  get pidFile() {
-    return join(this.stateDir, "daemon.pid");
-  }
-  get tuiPidFile() {
-    return join(this.stateDir, "codex-tui.pid");
-  }
-  get lockFile() {
-    return join(this.stateDir, "daemon.lock");
-  }
-  get statusFile() {
-    return join(this.stateDir, "status.json");
-  }
-  get portsFile() {
-    return join(this.stateDir, "ports.json");
-  }
-  get logFile() {
-    return join(this.stateDir, "agentbridge.log");
-  }
-  get killedFile() {
-    return join(this.stateDir, "killed");
-  }
-}
-
 // src/config-service.ts
 import { readFileSync as readFileSync2, writeFileSync as writeFileSync2, mkdirSync as mkdirSync2, existsSync as existsSync3 } from "fs";
 import { join as join2 } from "path";
 var DEFAULT_CONFIG = {
   version: "1.0",
-  daemon: {
-    port: 4500,
+  codex: {
+    appPort: 4500,
     proxyPort: 4501
   },
-  agents: {
-    claude: {
-      role: "Reviewer, Planner",
-      mode: "push"
-    },
-    codex: {
-      role: "Implementer, Executor"
-    }
-  },
-  markers: ["IMPORTANT", "STATUS", "FYI"],
   turnCoordination: {
-    attentionWindowSeconds: 15,
-    busyGuard: true
+    attentionWindowSeconds: 15
   },
   idleShutdownSeconds: 30
 };
-var DEFAULT_COLLABORATION_MD = `# Collaboration Rules
-
-## Roles
-- Claude: Reviewer, Planner, Hypothesis Challenger
-- Codex: Implementer, Executor, Reproducer/Verifier
-
-## Thinking Patterns
-- Analytical/review tasks: Independent Analysis & Convergence
-- Implementation tasks: Architect -> Builder -> Critic
-- Debugging tasks: Hypothesis -> Experiment -> Interpretation
-
-## Communication
-- Use explicit phrases: "My independent view is:", "I agree on:", "I disagree on:", "Current consensus:"
-- Tag messages with [IMPORTANT], [STATUS], or [FYI]
-
-## Review Process
-- Cross-review: author never reviews their own code
-- All changes go through feature/fix branches + PR
-- Merge via squash merge
-
-## Custom Rules
-<!-- Add your project-specific collaboration rules here -->
-`;
 var CONFIG_DIR = ".agentbridge";
 var CONFIG_FILE = "config.json";
-var COLLABORATION_FILE = "collaboration.md";
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function normalizeInteger(value, fallback) {
+  if (typeof value === "number" && Number.isFinite(value))
+    return value;
+  if (typeof value === "string") {
+    const parsed = Number(value);
+    if (Number.isFinite(parsed))
+      return parsed;
+  }
+  return fallback;
+}
+function normalizeConfig(raw) {
+  if (!isRecord(raw))
+    return null;
+  const config = raw;
+  const codex = isRecord(config.codex) ? config.codex : {};
+  const daemon = isRecord(config.daemon) ? config.daemon : {};
+  const turnCoordination = isRecord(config.turnCoordination) ? config.turnCoordination : {};
+  return {
+    version: typeof config.version === "string" ? config.version : DEFAULT_CONFIG.version,
+    codex: {
+      appPort: normalizeInteger(codex.appPort ?? daemon.port, DEFAULT_CONFIG.codex.appPort),
+      proxyPort: normalizeInteger(codex.proxyPort ?? daemon.proxyPort, DEFAULT_CONFIG.codex.proxyPort)
+    },
+    turnCoordination: {
+      attentionWindowSeconds: normalizeInteger(turnCoordination.attentionWindowSeconds, DEFAULT_CONFIG.turnCoordination.attentionWindowSeconds)
+    },
+    idleShutdownSeconds: normalizeInteger(config.idleShutdownSeconds, DEFAULT_CONFIG.idleShutdownSeconds)
+  };
+}
 
 class ConfigService {
   configDir;
   configPath;
-  collaborationPath;
   constructor(projectRoot) {
     const root = projectRoot ?? process.cwd();
     this.configDir = join2(root, CONFIG_DIR);
     this.configPath = join2(this.configDir, CONFIG_FILE);
-    this.collaborationPath = join2(this.configDir, COLLABORATION_FILE);
   }
   hasConfig() {
     return existsSync3(this.configPath);
@@ -1349,7 +1807,7 @@ class ConfigService {
   load() {
     try {
       const raw = readFileSync2(this.configPath, "utf-8");
-      return JSON.parse(raw);
+      return normalizeConfig(JSON.parse(raw));
     } catch {
       return null;
     }
@@ -1362,17 +1820,6 @@ class ConfigService {
     writeFileSync2(this.configPath, JSON.stringify(config, null, 2) + `
 `, "utf-8");
   }
-  loadCollaboration() {
-    try {
-      return readFileSync2(this.collaborationPath, "utf-8");
-    } catch {
-      return null;
-    }
-  }
-  saveCollaboration(content) {
-    this.ensureConfigDir();
-    writeFileSync2(this.collaborationPath, content, "utf-8");
-  }
   initDefaults() {
     this.ensureConfigDir();
     const created = [];
@@ -1380,18 +1827,11 @@ class ConfigService {
       this.save(DEFAULT_CONFIG);
       created.push(this.configPath);
     }
-    if (!existsSync3(this.collaborationPath)) {
-      this.saveCollaboration(DEFAULT_COLLABORATION_MD);
-      created.push(this.collaborationPath);
-    }
     return created;
   }
   get configFilePath() {
     return this.configPath;
   }
-  get collaborationFilePath() {
-    return this.collaborationPath;
-  }
   ensureConfigDir() {
     if (!existsSync3(this.configDir)) {
       mkdirSync2(this.configDir, { recursive: true });
@@ -1399,13 +1839,16 @@ class ConfigService {
   }
 }
 
+// src/control-protocol.ts
+var CLOSE_CODE_REPLACED = 4001;
+
 // src/daemon.ts
 var stateDir = new StateDirResolver;
 stateDir.ensure();
 var configService = new ConfigService;
 var config = configService.loadOrDefault();
-var CODEX_APP_PORT = parseInt(process.env.CODEX_WS_PORT ?? String(config.daemon.port), 10);
-var CODEX_PROXY_PORT = parseInt(process.env.CODEX_PROXY_PORT ?? String(config.daemon.proxyPort), 10);
+var CODEX_APP_PORT = parseInt(process.env.CODEX_WS_PORT ?? String(config.codex.appPort), 10);
+var CODEX_PROXY_PORT = parseInt(process.env.CODEX_PROXY_PORT ?? String(config.codex.proxyPort), 10);
 var CONTROL_PORT = parseInt(process.env.AGENTBRIDGE_CONTROL_PORT ?? "4502", 10);
 var TUI_DISCONNECT_GRACE_MS = parseInt(process.env.TUI_DISCONNECT_GRACE_MS ?? "2500", 10);
 var CLAUDE_DISCONNECT_GRACE_MS = 5000;
@@ -1414,7 +1857,7 @@ var FILTER_MODE = process.env.AGENTBRIDGE_FILTER_MODE === "full" ? "full" : "fil
 var IDLE_SHUTDOWN_MS = parseInt(process.env.AGENTBRIDGE_IDLE_SHUTDOWN_MS ?? String(config.idleShutdownSeconds * 1000), 10);
 var ATTENTION_WINDOW_MS = parseInt(process.env.AGENTBRIDGE_ATTENTION_WINDOW_MS ?? String(config.turnCoordination.attentionWindowSeconds * 1000), 10);
 var daemonLifecycle = new DaemonLifecycle({ stateDir, controlPort: CONTROL_PORT, log });
-var codex = new CodexAdapter(CODEX_APP_PORT, CODEX_PROXY_PORT);
+var codex = new CodexAdapter(CODEX_APP_PORT, CODEX_PROXY_PORT, stateDir.logFile);
 var attachCmd = `codex --enable tui_app_server --remote ${codex.proxyUrl}`;
 var controlServer = null;
 var attachedClaude = null;
@@ -1430,6 +1873,7 @@ var idleShutdownTimer = null;
 var claudeDisconnectTimer = null;
 var claudeOnlineNoticeSent = false;
 var claudeOfflineNoticeShown = false;
+var codexCollaborationKickoffSent = false;
 var lastAttachStatusSentTs = 0;
 var ATTACH_STATUS_COOLDOWN_MS = 30000;
 var bufferedMessages = [];
@@ -1496,6 +1940,9 @@ codex.on("turnCompleted", () => {
   replyReceivedDuringTurn = false;
   emitToClaude(systemMessage("system_turn_completed", "\u2705 Codex finished the current turn. You can reply now if needed."));
   startAttentionWindow();
+  if (attachedClaude && shouldNotifyCodexClaudeOnline()) {
+    notifyCodexClaudeOnline();
+  }
 });
 codex.on("ready", (threadId) => {
   tuiConnectionState.markBridgeReady();
@@ -1640,8 +2087,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;
@@ -1826,9 +2275,23 @@ function currentReadyMessage() {
   return `\u2705 Codex TUI connected (${codex.activeThreadId}). Bridge ready.`;
 }
 function notifyCodexClaudeOnline() {
+  const message = !codexCollaborationKickoffSent ? [
+    "\uD83E\uDD1D Claude Code has connected via AgentBridge.",
+    "You are now in a multi-agent collaboration session.",
+    "When you receive a complex task, propose a division of labor to Claude.",
+    "Claude can send you messages \u2014 they will appear as injected user messages.",
+    "Respond naturally and Claude will receive your output via AgentBridge."
+  ].join(`
+`) : "\u2705 AgentBridge connected to Claude Code.";
+  const delivered = codex.injectMessage(message);
+  if (!delivered) {
+    log("Deferred Claude-online notice to Codex \u2014 will retry after current turn completes");
+    return false;
+  }
   claudeOnlineNoticeSent = true;
   claudeOfflineNoticeShown = false;
-  codex.injectMessage("\u2705 AgentBridge connected to Claude Code.");
+  codexCollaborationKickoffSent = true;
+  return true;
 }
 function shouldNotifyCodexClaudeOnline() {
   return !claudeOnlineNoticeSent || claudeOfflineNoticeShown;