@raysonmeng/agentbridge 0.1.0

package/plugins/agentbridge/server/daemon.js

@@ -0,0 +1,1762 @@
+#!/usr/bin/env bun
+// @bun
+
+// src/daemon.ts
+import { appendFileSync as appendFileSync2 } from "fs";
+
+// src/codex-adapter.ts
+import { spawn, execSync } from "child_process";
+import { createInterface } from "readline";
+import { EventEmitter } from "events";
+import { appendFileSync } from "fs";
+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;
+  proc = null;
+  appServerWs = null;
+  tuiWs = null;
+  proxyServer = null;
+  threadId = null;
+  nextInjectionId = -1;
+  appPort;
+  proxyPort;
+  tuiConnId = 0;
+  agentMessageBuffers = new Map;
+  pendingRequests = new Map;
+  activeTurnIds = new Set;
+  turnInProgress = false;
+  nextProxyId = 1e5;
+  upstreamToClient = new Map;
+  staleProxyIds = new Map;
+  bridgeRequestIds = new Map;
+  intentionalDisconnect = false;
+  constructor(appPort = 4500, proxyPort = 4501) {
+    super();
+    this.appPort = appPort;
+    this.proxyPort = proxyPort;
+  }
+  get appServerUrl() {
+    return `ws://127.0.0.1:${this.appPort}`;
+  }
+  get proxyUrl() {
+    return `ws://127.0.0.1:${this.proxyPort}`;
+  }
+  get activeThreadId() {
+    return this.threadId;
+  }
+  async start() {
+    this.intentionalDisconnect = false;
+    await this.checkPorts();
+    this.log(`Spawning codex app-server on ${this.appServerUrl}`);
+    this.proc = spawn("codex", ["app-server", "--listen", this.appServerUrl], {
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    this.proc.on("error", (err) => this.emit("error", err));
+    this.proc.on("exit", (code) => this.emit("exit", code));
+    const stderrRl = createInterface({ input: this.proc.stderr });
+    stderrRl.on("line", (l) => this.log(`[codex-server] ${l}`));
+    const stdoutRl = createInterface({ input: this.proc.stdout });
+    stdoutRl.on("line", (l) => this.log(`[codex-stdout] ${l}`));
+    await this.waitForHealthy();
+    await this.connectToAppServer();
+    this.startProxy();
+    this.log(`Proxy ready on ${this.proxyUrl}`);
+  }
+  disconnect() {
+    this.intentionalDisconnect = true;
+    if (this.reconnectTimer) {
+      clearTimeout(this.reconnectTimer);
+      this.reconnectTimer = null;
+    }
+    this.appServerWs?.close();
+    this.appServerWs = null;
+    this.proxyServer?.stop();
+    this.proxyServer = null;
+    this.clearResponseTrackingState();
+  }
+  stop() {
+    this.intentionalDisconnect = true;
+    this.disconnect();
+    if (this.proc) {
+      const proc = this.proc;
+      this.proc = null;
+      proc.kill("SIGTERM");
+      const killTimer = setTimeout(() => {
+        try {
+          proc.kill("SIGKILL");
+        } catch {}
+      }, 2000);
+      proc.on("exit", () => clearTimeout(killTimer));
+    }
+  }
+  injectMessage(text) {
+    if (!this.threadId) {
+      this.log("Cannot inject: no active thread");
+      return false;
+    }
+    if (!this.appServerWs || this.appServerWs.readyState !== WebSocket.OPEN) {
+      this.log("Cannot inject: app-server WebSocket not connected");
+      return false;
+    }
+    if (this.turnInProgress) {
+      this.log(`Rejected injection: Codex turn is in progress (thread ${this.threadId})`);
+      return false;
+    }
+    this.log(`Injecting message into Codex (${text.length} chars)`);
+    const requestId = this.nextInjectionId--;
+    this.trackBridgeRequestId(requestId);
+    try {
+      this.appServerWs.send(JSON.stringify({
+        method: "turn/start",
+        id: requestId,
+        params: { threadId: this.threadId, input: [{ type: "text", text }] }
+      }));
+      return true;
+    } catch (err) {
+      this.untrackBridgeRequestId(requestId);
+      this.log(`Injection send failed: ${err.message}`);
+      return false;
+    }
+  }
+  async waitForHealthy(maxRetries = 20, delayMs = 500) {
+    for (let i = 0;i < maxRetries; i++) {
+      try {
+        const res = await fetch(`http://127.0.0.1:${this.appPort}/healthz`);
+        if (res.ok)
+          return;
+      } catch {}
+      await new Promise((r) => setTimeout(r, delayMs));
+    }
+    throw new Error("Codex app-server failed to become healthy");
+  }
+  connectToAppServer(isReconnect = false) {
+    return new Promise((resolve, reject) => {
+      const appWs = new WebSocket(this.appServerUrl);
+      appWs.onopen = () => {
+        this.appServerWs = appWs;
+        this.intentionalDisconnect = false;
+        this.reconnectAttempts = 0;
+        this.log(isReconnect ? "Reconnected to app-server" : "Connected to app-server (persistent)");
+        resolve();
+      };
+      appWs.onmessage = (event) => {
+        const data = typeof event.data === "string" ? event.data : event.data.toString();
+        const forwarded = this.handleAppServerPayload(data);
+        if (forwarded === null)
+          return;
+        if (this.tuiWs) {
+          try {
+            this.tuiWs.send(forwarded);
+          } catch (e) {
+            this.log(`Failed to forward message to TUI: ${e.message}`);
+          }
+        } else {
+          this.log("WARNING: response from app-server but no TUI connected, message dropped");
+        }
+      };
+      appWs.onerror = () => {
+        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();
+        }
+      };
+    });
+  }
+  reconnectAttempts = 0;
+  reconnectTimer = null;
+  static MAX_RECONNECT_ATTEMPTS = 10;
+  static RECONNECT_BASE_DELAY_MS = 1000;
+  scheduleReconnect() {
+    if (!this.proc)
+      return;
+    if (this.reconnectAttempts >= CodexAdapter.MAX_RECONNECT_ATTEMPTS) {
+      this.log(`App-server reconnect failed after ${this.reconnectAttempts} attempts. Giving up.`);
+      this.emit("error", new Error("App-server connection lost and reconnect failed"));
+      return;
+    }
+    const delay = Math.min(CodexAdapter.RECONNECT_BASE_DELAY_MS * Math.pow(2, this.reconnectAttempts), 30000);
+    this.reconnectAttempts++;
+    this.log(`Scheduling app-server reconnect attempt ${this.reconnectAttempts}/${CodexAdapter.MAX_RECONNECT_ATTEMPTS} in ${delay}ms...`);
+    this.reconnectTimer = setTimeout(async () => {
+      try {
+        await this.connectToAppServer(true);
+        this.log("App-server reconnect successful");
+      } catch {
+        this.log("App-server reconnect attempt failed");
+        this.scheduleReconnect();
+      }
+    }, delay);
+  }
+  startProxy() {
+    const self = this;
+    this.proxyServer = Bun.serve({
+      port: this.proxyPort,
+      hostname: "127.0.0.1",
+      fetch(req, server) {
+        const url = new URL(req.url);
+        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;
+        return new Response("AgentBridge Codex Proxy");
+      },
+      websocket: {
+        open: (ws) => self.onTuiConnect(ws),
+        close: (ws) => self.onTuiDisconnect(ws),
+        message: (ws, msg) => self.onTuiMessage(ws, msg)
+      }
+    });
+  }
+  onTuiConnect(ws) {
+    this.tuiConnId++;
+    ws.data.connId = this.tuiConnId;
+    this.tuiWs = ws;
+    this.log(`TUI connected (conn #${this.tuiConnId})`);
+    this.emit("tuiConnected", this.tuiConnId);
+  }
+  onTuiDisconnect(ws) {
+    const connId = ws.data.connId;
+    if (this.tuiWs === ws) {
+      this.log(`TUI disconnected (conn #${connId})`);
+      this.tuiWs = null;
+      this.emit("tuiDisconnected", connId);
+    } else {
+      this.log(`Stale TUI disconnected (conn #${connId}, current is #${this.tuiConnId})`);
+    }
+    this.retireConnectionState(connId);
+  }
+  onTuiMessage(ws, msg) {
+    const data = typeof msg === "string" ? msg : msg.toString();
+    const connId = ws.data.connId;
+    if (connId !== this.tuiConnId) {
+      this.log(`Dropping message from stale TUI conn #${connId} (current is #${this.tuiConnId})`);
+      return;
+    }
+    let forwarded = data;
+    try {
+      const parsed = JSON.parse(data);
+      const method = parsed.method ?? `response:${parsed.id}`;
+      this.log(`TUI \u2192 app-server: ${method}`);
+      if (parsed.id !== undefined && parsed.method) {
+        const proxyId = this.nextProxyId++;
+        this.upstreamToClient.set(proxyId, { connId, clientId: parsed.id });
+        this.trackPendingRequest(parsed, connId, proxyId);
+        parsed.id = proxyId;
+        forwarded = JSON.stringify(parsed);
+      } else {
+        this.trackPendingRequest(parsed, connId);
+      }
+    } catch {
+      this.log(`TUI \u2192 app-server: (unparseable)`);
+    }
+    if (this.appServerWs?.readyState === WebSocket.OPEN) {
+      this.appServerWs.send(forwarded);
+    } else {
+      this.log(`WARNING: app-server not connected, dropping message`);
+    }
+  }
+  handleAppServerPayload(raw) {
+    try {
+      const parsed = JSON.parse(raw);
+      if (parsed.id === undefined) {
+        const forwarded = this.patchResponse(parsed, raw);
+        this.interceptServerMessage(parsed);
+        return forwarded;
+      }
+      return this.handleAppServerResponse(parsed, raw);
+    } catch {
+      return raw;
+    }
+  }
+  handleAppServerResponse(parsed, raw) {
+    const responseId = parsed.id;
+    const numericId = typeof responseId === "number" ? responseId : typeof responseId === "string" && /^-?\d+$/.test(responseId) ? Number(responseId) : NaN;
+    const mapping = !isNaN(numericId) ? this.upstreamToClient.get(numericId) : undefined;
+    if (mapping) {
+      this.upstreamToClient.delete(numericId);
+      if (mapping.connId !== this.tuiConnId) {
+        this.log(`Dropping stale response (upstream id ${responseId}, from conn #${mapping.connId}, current #${this.tuiConnId})`);
+        return null;
+      }
+      parsed.id = mapping.clientId;
+      const forwarded = this.patchResponse(parsed, JSON.stringify(parsed));
+      this.interceptServerMessage(parsed, mapping.connId);
+      return forwarded;
+    }
+    if (!isNaN(numericId) && this.consumeBridgeRequestId(numericId)) {
+      if (parsed.error) {
+        this.log(`Bridge-originated request failed (id ${responseId}): ${parsed.error.message ?? "unknown error"}`);
+      } else {
+        this.log(`Bridge-originated request completed (id ${responseId})`);
+      }
+      return null;
+    }
+    if (!isNaN(numericId) && this.consumeStaleProxyId(numericId)) {
+      this.log(`Dropping stale response for retired upstream id ${responseId}`);
+      return null;
+    }
+    this.log(`Dropping unmatched app-server response id ${String(responseId)}`);
+    return null;
+  }
+  patchResponse(parsed, raw) {
+    if (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})`);
+        return JSON.stringify({
+          id: parsed.id,
+          result: {
+            rateLimits: {
+              limitId: null,
+              limitName: null,
+              primary: { usedPercent: 0, windowDurationMins: 60, resetsAt: null },
+              secondary: null,
+              credits: null,
+              planType: null
+            },
+            rateLimitsByLimitId: null
+          }
+        });
+      }
+      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)
+      this.handleServerNotification(msg);
+  }
+  handleServerNotification(msg) {
+    const { method, params } = msg;
+    switch (method) {
+      case "turn/started":
+        this.markTurnStarted(params?.turn?.id);
+        break;
+      case "item/started": {
+        const item = params?.item;
+        if (item?.type === "agentMessage")
+          this.agentMessageBuffers.set(item.id, []);
+        break;
+      }
+      case "item/agentMessage/delta": {
+        const buf = this.agentMessageBuffers.get(params?.itemId);
+        if (buf && params?.delta)
+          buf.push(params.delta);
+        break;
+      }
+      case "item/completed": {
+        const item = params?.item;
+        if (item?.type === "agentMessage") {
+          const content = this.extractContent(item);
+          this.agentMessageBuffers.delete(item.id);
+          if (content) {
+            this.log(`Agent message completed (${content.length} chars)`);
+            this.emit("agentMessage", {
+              id: item.id,
+              source: "codex",
+              content,
+              timestamp: Date.now()
+            });
+          }
+        }
+        break;
+      }
+      case "turn/completed": {
+        const wasInProgress = this.turnInProgress;
+        this.markTurnCompleted(params?.turn?.id);
+        if (wasInProgress && !this.turnInProgress) {
+          this.emit("turnCompleted");
+        }
+        break;
+      }
+    }
+  }
+  extractContent(item) {
+    if (item.content?.length) {
+      return item.content.filter((c) => c.type === "text" && c.text).map((c) => c.text).join("");
+    }
+    return this.agentMessageBuffers.get(item.id)?.join("") ?? "";
+  }
+  pendingKey(rpcId, connId) {
+    const base = this.requestKey(rpcId);
+    if (!base)
+      return null;
+    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))
+      return;
+    const pending = { method };
+    if (method === "turn/start") {
+      const threadId = message?.params?.threadId;
+      if (typeof threadId === "string" && threadId.length > 0) {
+        pending.threadId = threadId;
+      }
+    }
+    if (this.pendingRequests.has(key)) {
+      this.log(`WARNING: overwriting pending request for key ${key}`);
+    }
+    this.pendingRequests.set(key, pending);
+  }
+  handleTrackedResponse(message, connId) {
+    const key = this.pendingKey(message?.id, connId);
+    if (!key)
+      return;
+    const pending = this.pendingRequests.get(key);
+    if (!pending) {
+      if (message?.result?.thread?.id) {
+        this.log(`[track-resp] Unmatched response with thread.id=${message.result.thread.id}, key=${key}, pending keys=[${[...this.pendingRequests.keys()].join(",")}]`);
+      }
+      return;
+    }
+    this.pendingRequests.delete(key);
+    if (message?.error) {
+      this.log(`Tracked request failed (${pending.method}, id ${key}): ${message.error.message ?? "unknown error"}`);
+      return;
+    }
+    switch (pending.method) {
+      case "thread/start": {
+        const threadId = message?.result?.thread?.id;
+        if (typeof threadId === "string" && threadId.length > 0) {
+          this.setActiveThreadId(threadId, `thread/start response ${key}`);
+        }
+        break;
+      }
+      case "thread/resume": {
+        const threadId = message?.result?.thread?.id;
+        if (typeof threadId === "string" && threadId.length > 0) {
+          this.setActiveThreadId(threadId, `thread/resume response ${key}`);
+        }
+        break;
+      }
+      case "turn/start":
+        if (pending.threadId) {
+          this.setActiveThreadId(pending.threadId, `turn/start response ${key}`);
+        }
+        break;
+    }
+  }
+  setActiveThreadId(threadId, reason) {
+    if (this.threadId === threadId)
+      return;
+    const previousThreadId = this.threadId;
+    this.threadId = threadId;
+    if (previousThreadId) {
+      this.log(`Active thread changed: ${previousThreadId} \u2192 ${threadId} (${reason})`);
+      return;
+    }
+    this.log(`Thread detected: ${threadId} (${reason})`);
+    this.emit("ready", threadId);
+  }
+  markTurnStarted(turnId) {
+    const wasInProgress = this.turnInProgress;
+    if (typeof turnId === "string" && turnId.length > 0) {
+      this.activeTurnIds.add(turnId);
+    } else {
+      this.activeTurnIds.add(`unknown:${Date.now()}`);
+    }
+    this.turnInProgress = this.activeTurnIds.size > 0;
+    if (!wasInProgress && this.turnInProgress) {
+      this.emit("turnStarted");
+    }
+  }
+  markTurnCompleted(turnId) {
+    if (typeof turnId === "string" && turnId.length > 0) {
+      this.activeTurnIds.delete(turnId);
+    } else {
+      this.activeTurnIds.clear();
+    }
+    this.turnInProgress = this.activeTurnIds.size > 0;
+  }
+  requestKey(id) {
+    if (typeof id === "number" || typeof id === "string")
+      return String(id);
+    return null;
+  }
+  retireConnectionState(connId) {
+    const prefix = `${connId}:`;
+    for (const key of this.pendingRequests.keys()) {
+      if (key.startsWith(prefix))
+        this.pendingRequests.delete(key);
+    }
+    for (const [upId, mapping] of this.upstreamToClient.entries()) {
+      if (mapping.connId !== connId)
+        continue;
+      this.upstreamToClient.delete(upId);
+      this.trackStaleProxyId(upId);
+    }
+  }
+  trackStaleProxyId(proxyId) {
+    this.clearTrackedId(this.staleProxyIds, proxyId);
+    const timer = setTimeout(() => {
+      this.staleProxyIds.delete(proxyId);
+    }, CodexAdapter.RESPONSE_TRACKING_TTL_MS);
+    timer.unref?.();
+    this.staleProxyIds.set(proxyId, timer);
+  }
+  consumeStaleProxyId(proxyId) {
+    return this.clearTrackedId(this.staleProxyIds, proxyId);
+  }
+  trackBridgeRequestId(requestId) {
+    this.clearTrackedId(this.bridgeRequestIds, requestId);
+    const timer = setTimeout(() => {
+      this.bridgeRequestIds.delete(requestId);
+    }, CodexAdapter.RESPONSE_TRACKING_TTL_MS);
+    timer.unref?.();
+    this.bridgeRequestIds.set(requestId, timer);
+  }
+  consumeBridgeRequestId(requestId) {
+    return this.clearTrackedId(this.bridgeRequestIds, requestId);
+  }
+  untrackBridgeRequestId(requestId) {
+    this.clearTrackedId(this.bridgeRequestIds, requestId);
+  }
+  clearTrackedId(store, id) {
+    const timer = store.get(id);
+    if (!timer)
+      return false;
+    clearTimeout(timer);
+    store.delete(id);
+    return true;
+  }
+  clearResponseTrackingState() {
+    this.pendingRequests.clear();
+    this.upstreamToClient.clear();
+    for (const timer of this.staleProxyIds.values()) {
+      clearTimeout(timer);
+    }
+    this.staleProxyIds.clear();
+    for (const timer of this.bridgeRequestIds.values()) {
+      clearTimeout(timer);
+    }
+    this.bridgeRequestIds.clear();
+  }
+  async checkPorts() {
+    for (const port of [this.appPort, this.proxyPort]) {
+      try {
+        const pids = execSync(`lsof -ti :${port}`, { encoding: "utf-8" }).trim();
+        if (!pids)
+          continue;
+        const pidList = pids.split(`
+`).map((p) => p.trim()).filter(Boolean);
+        const staleCodexPids = [];
+        const foreignPids = [];
+        for (const pid of pidList) {
+          try {
+            const cmdline = execSync(`ps -p ${pid} -o args=`, { encoding: "utf-8" }).trim();
+            if (cmdline.includes("codex") && cmdline.includes("app-server")) {
+              staleCodexPids.push(pid);
+            } else {
+              foreignPids.push(pid);
+            }
+          } catch {}
+        }
+        if (staleCodexPids.length > 0) {
+          this.log(`Cleaning up stale codex app-server on port ${port}: PID(s) ${staleCodexPids.join(", ")}`);
+          for (const pid of staleCodexPids) {
+            try {
+              execSync(`kill ${pid}`, { encoding: "utf-8" });
+            } catch {}
+          }
+          await new Promise((r) => setTimeout(r, 500));
+        }
+        if (foreignPids.length > 0) {
+          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();
+          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.`);
+          }
+        } catch (err) {
+          if (err.message?.includes("Port"))
+            throw err;
+        }
+      } catch (err) {
+        if (err.message?.includes("Port") || err.message?.includes("non-Codex"))
+          throw err;
+      }
+    }
+  }
+  log(msg) {
+    const line = `[${new Date().toISOString()}] [CodexAdapter] ${msg}
+`;
+    process.stderr.write(line);
+    try {
+      appendFileSync(LOG_FILE, line);
+    } catch {}
+  }
+}
+
+// src/message-filter.ts
+var MARKER_REGEX = /^\s*\[(IMPORTANT|STATUS|FYI)\]\s*/i;
+function parseMarker(content) {
+  const match = content.match(MARKER_REGEX);
+  if (!match)
+    return { marker: "untagged", body: content };
+  return {
+    marker: match[1].toLowerCase(),
+    body: content.slice(match[0].length)
+  };
+}
+function classifyMessage(content, mode) {
+  if (mode === "full")
+    return { action: "forward", marker: "untagged" };
+  const { marker } = parseMarker(content);
+  switch (marker) {
+    case "important":
+      return { action: "forward", marker };
+    case "status":
+      return { action: "buffer", marker };
+    case "fyi":
+      return { action: "drop", marker };
+    case "untagged":
+      return { action: "forward", marker };
+  }
+}
+var BRIDGE_CONTRACT_REMINDER = `[Bridge Contract] When sending agentMessage, put the marker at the very start of the message:
+- [IMPORTANT] for decisions, reviews, completions, blockers
+- [STATUS] for progress updates
+- [FYI] for background context
+The marker MUST be the first text in the message (e.g. "[IMPORTANT] Task done", not "Task done [IMPORTANT]").
+Keep agentMessage for high-value communication only.
+
+[Git Operations \u2014 FORBIDDEN]
+You MUST NOT execute any git write commands. This includes but is not limited to:
+git commit, git push, git pull, git fetch, git checkout -b, git branch, git merge, git rebase, git cherry-pick, git tag, git stash.
+These commands write to the .git directory, which is blocked by your sandbox. Attempting them will cause your session to hang indefinitely.
+Read-only git commands (git status, git log, git diff, git show, git rev-parse) are allowed.
+All git write operations must be delegated to Claude Code via agentMessage. Report what you changed and let Claude handle branching, committing, and pushing.
+
+[Role Guidance for Codex]
+- Your default role: Implementer, Executor, Verifier
+- Analytical/review tasks: Independent Analysis & Convergence
+- Implementation tasks: Architect -> Builder -> Critic
+- Debugging tasks: Hypothesis -> Experiment -> Interpretation
+- Do not blindly follow Claude - challenge with evidence when you disagree
+- Use explicit collaboration phrases: "My independent view is:", "I agree on:", "I disagree on:", "Current consensus:"`;
+var REPLY_REQUIRED_INSTRUCTION = `
+
+[\u26A0\uFE0F REPLY REQUIRED] Claude has explicitly requested a reply. You MUST send an agentMessage with [IMPORTANT] marker containing your response. This is a mandatory requirement \u2014 do not skip or use [STATUS]/[FYI] markers for this reply.`;
+class StatusBuffer {
+  onFlush;
+  buffer = [];
+  flushTimer = null;
+  flushThreshold;
+  flushTimeoutMs;
+  paused = false;
+  constructor(onFlush, options) {
+    this.onFlush = onFlush;
+    this.flushThreshold = options?.flushThreshold ?? 3;
+    this.flushTimeoutMs = options?.flushTimeoutMs ?? 15000;
+  }
+  get size() {
+    return this.buffer.length;
+  }
+  pause() {
+    this.paused = true;
+    this.clearTimer();
+  }
+  resume() {
+    this.paused = false;
+    if (this.buffer.length > 0) {
+      this.resetTimer();
+      if (this.buffer.length >= this.flushThreshold) {
+        this.flush("threshold reached after resume");
+      }
+    }
+  }
+  add(message) {
+    this.buffer.push(message);
+    if (this.paused)
+      return;
+    this.resetTimer();
+    if (this.buffer.length >= this.flushThreshold) {
+      this.flush("threshold reached");
+    }
+  }
+  flush(reason) {
+    if (this.buffer.length === 0)
+      return;
+    this.clearTimer();
+    const combined = this.buffer.map((m) => parseMarker(m.content).body).join(`
+---
+`);
+    const summary = {
+      id: `status_summary_${Date.now()}`,
+      source: "codex",
+      content: `[STATUS summary \u2014 ${this.buffer.length} update(s), flushed: ${reason}]
+${combined}`,
+      timestamp: Date.now()
+    };
+    this.onFlush(summary);
+    this.buffer = [];
+  }
+  dispose() {
+    this.clearTimer();
+    this.buffer = [];
+  }
+  clearTimer() {
+    if (this.flushTimer) {
+      clearTimeout(this.flushTimer);
+      this.flushTimer = null;
+    }
+  }
+  resetTimer() {
+    this.clearTimer();
+    this.flushTimer = setTimeout(() => {
+      this.flushTimer = null;
+      this.flush("timeout");
+    }, this.flushTimeoutMs);
+  }
+}
+
+// src/tui-connection-state.ts
+class TuiConnectionState {
+  options;
+  bridgeReady = false;
+  tuiConnected = false;
+  disconnectNotificationShown = false;
+  disconnectNotificationTimer = null;
+  constructor(options) {
+    this.options = options;
+  }
+  canReply() {
+    if (!this.bridgeReady)
+      return false;
+    return this.tuiConnected || this.disconnectNotificationTimer !== null;
+  }
+  snapshot() {
+    return {
+      bridgeReady: this.bridgeReady,
+      tuiConnected: this.tuiConnected,
+      disconnectNotificationShown: this.disconnectNotificationShown,
+      hasPendingDisconnectNotification: this.disconnectNotificationTimer !== null
+    };
+  }
+  markBridgeReady() {
+    this.bridgeReady = true;
+    this.disconnectNotificationShown = false;
+    this.clearPendingDisconnectNotification("thread became ready");
+  }
+  handleTuiConnected(connId) {
+    const reconnectingAfterNotice = this.disconnectNotificationShown && this.bridgeReady;
+    this.tuiConnected = true;
+    this.clearPendingDisconnectNotification(`TUI reconnected as conn #${connId}`);
+    if (reconnectingAfterNotice) {
+      this.disconnectNotificationShown = false;
+      this.options.onReconnectAfterNotice(connId);
+    }
+  }
+  handleTuiDisconnected(connId) {
+    this.tuiConnected = false;
+    if (!this.bridgeReady) {
+      this.options.log?.(`Suppressing pre-ready TUI disconnect notification (conn #${connId})`);
+      return;
+    }
+    this.scheduleDisconnectNotification(connId);
+  }
+  handleCodexExit() {
+    this.bridgeReady = false;
+    this.tuiConnected = false;
+    this.disconnectNotificationShown = false;
+    this.clearPendingDisconnectNotification("Codex process exited");
+  }
+  dispose(reason = "disposed") {
+    this.clearPendingDisconnectNotification(reason);
+  }
+  clearPendingDisconnectNotification(reason) {
+    if (!this.disconnectNotificationTimer)
+      return;
+    clearTimeout(this.disconnectNotificationTimer);
+    this.disconnectNotificationTimer = null;
+    if (reason) {
+      this.options.log?.(`Cleared pending TUI disconnect notification (${reason})`);
+    }
+  }
+  scheduleDisconnectNotification(connId) {
+    this.clearPendingDisconnectNotification("rescheduled");
+    this.disconnectNotificationTimer = setTimeout(() => {
+      this.disconnectNotificationTimer = null;
+      if (this.tuiConnected) {
+        this.options.log?.(`Skipping TUI disconnect notification for conn #${connId} because TUI already reconnected`);
+        return;
+      }
+      this.disconnectNotificationShown = true;
+      this.options.log?.(`Codex TUI disconnect persisted past grace window (conn #${connId})`);
+      this.options.onDisconnectPersisted(connId);
+    }, this.options.disconnectGraceMs);
+  }
+}
+
+// src/daemon-lifecycle.ts
+import { spawn as spawn2, execFileSync } from "child_process";
+import { existsSync, 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));
+
+class DaemonLifecycle {
+  stateDir;
+  controlPort;
+  log;
+  constructor(opts) {
+    this.stateDir = opts.stateDir;
+    this.controlPort = opts.controlPort;
+    this.log = opts.log;
+  }
+  get healthUrl() {
+    return `http://127.0.0.1:${this.controlPort}/healthz`;
+  }
+  get readyUrl() {
+    return `http://127.0.0.1:${this.controlPort}/readyz`;
+  }
+  get controlWsUrl() {
+    return `ws://127.0.0.1:${this.controlPort}/ws`;
+  }
+  async ensureRunning() {
+    if (await this.isHealthy()) {
+      await this.waitForReady();
+      return;
+    }
+    const existingPid = this.readPid();
+    if (existingPid) {
+      if (isProcessAlive(existingPid)) {
+        if (this.isDaemonProcess(existingPid)) {
+          try {
+            await this.waitForReady(12, 250);
+            return;
+          } catch {
+            throw new Error(`Found existing daemon process ${existingPid}, but control port ${this.controlPort} never became ready.`);
+          }
+        }
+        this.log(`Pid ${existingPid} is alive but not an AgentBridge daemon, removing stale pid file`);
+      }
+      this.removeStalePidFile();
+    }
+    const lockAcquired = this.acquireLock();
+    if (!lockAcquired) {
+      this.log("Another process is starting the daemon, waiting for readiness...");
+      await this.waitForReady();
+      return;
+    }
+    try {
+      this.launch();
+      await this.waitForReady();
+    } finally {
+      this.releaseLock();
+    }
+  }
+  async isHealthy() {
+    try {
+      const response = await fetch(this.healthUrl);
+      return response.ok;
+    } catch {
+      return false;
+    }
+  }
+  async waitForHealthy(maxRetries = 40, delayMs = 250) {
+    for (let attempt = 0;attempt < maxRetries; attempt++) {
+      if (await this.isHealthy())
+        return;
+      await new Promise((resolve) => setTimeout(resolve, delayMs));
+    }
+    throw new Error(`Timed out waiting for AgentBridge daemon health on ${this.healthUrl}`);
+  }
+  async isReady() {
+    try {
+      const response = await fetch(this.readyUrl);
+      return response.ok;
+    } catch {
+      return false;
+    }
+  }
+  async waitForReady(maxRetries = 40, delayMs = 250) {
+    for (let attempt = 0;attempt < maxRetries; attempt++) {
+      if (await this.isReady())
+        return;
+      await new Promise((resolve) => setTimeout(resolve, delayMs));
+    }
+    throw new Error(`Timed out waiting for AgentBridge daemon readiness on ${this.readyUrl}`);
+  }
+  readStatus() {
+    try {
+      const raw = readFileSync(this.stateDir.statusFile, "utf-8");
+      return JSON.parse(raw);
+    } catch {
+      return null;
+    }
+  }
+  writeStatus(status) {
+    this.stateDir.ensure();
+    writeFileSync(this.stateDir.statusFile, JSON.stringify(status, null, 2) + `
+`, "utf-8");
+  }
+  readPid() {
+    try {
+      const raw = readFileSync(this.stateDir.pidFile, "utf-8").trim();
+      if (!raw)
+        return null;
+      const pid = Number.parseInt(raw, 10);
+      return Number.isFinite(pid) ? pid : null;
+    } catch {
+      return null;
+    }
+  }
+  writePid(pid) {
+    this.stateDir.ensure();
+    writeFileSync(this.stateDir.pidFile, `${pid ?? process.pid}
+`, "utf-8");
+  }
+  removePidFile() {
+    try {
+      unlinkSync(this.stateDir.pidFile);
+    } catch {}
+  }
+  removeStatusFile() {
+    try {
+      unlinkSync(this.stateDir.statusFile);
+    } catch {}
+  }
+  markKilled() {
+    this.stateDir.ensure();
+    writeFileSync(this.stateDir.killedFile, `${Date.now()}
+`, "utf-8");
+  }
+  clearKilled() {
+    try {
+      unlinkSync(this.stateDir.killedFile);
+    } catch {}
+  }
+  wasKilled() {
+    return existsSync(this.stateDir.killedFile);
+  }
+  launch() {
+    this.stateDir.ensure();
+    this.log(`Launching detached daemon on control port ${this.controlPort}`);
+    const daemonProc = spawn2(process.execPath, ["run", DAEMON_PATH], {
+      cwd: process.cwd(),
+      env: {
+        ...process.env,
+        AGENTBRIDGE_CONTROL_PORT: String(this.controlPort),
+        AGENTBRIDGE_STATE_DIR: this.stateDir.dir
+      },
+      detached: true,
+      stdio: "ignore"
+    });
+    daemonProc.unref();
+  }
+  removeStalePidFile() {
+    this.log("Removing stale pid file");
+    this.removePidFile();
+  }
+  acquireLock(depth = 0) {
+    if (depth > 1) {
+      this.log("Lock acquisition failed after retry, proceeding without lock");
+      return true;
+    }
+    this.stateDir.ensure();
+    try {
+      const fd = openSync(this.stateDir.lockFile, constants.O_CREAT | constants.O_EXCL | constants.O_WRONLY);
+      writeFileSync(fd, `${process.pid}
+`);
+      closeSync(fd);
+      return true;
+    } catch (err) {
+      if (err.code === "EEXIST") {
+        try {
+          const holderPid = Number.parseInt(readFileSync(this.stateDir.lockFile, "utf-8").trim(), 10);
+          if (Number.isFinite(holderPid) && !isProcessAlive(holderPid)) {
+            this.log(`Stale lock file from dead process ${holderPid}, removing`);
+            this.releaseLock();
+            return this.acquireLock(depth + 1);
+          }
+        } catch {
+          this.log("Cannot read lock file, removing stale lock");
+          this.releaseLock();
+          return this.acquireLock(depth + 1);
+        }
+        return false;
+      }
+      this.log(`Warning: could not acquire startup lock: ${err.message}`);
+      return true;
+    }
+  }
+  releaseLock() {
+    try {
+      unlinkSync(this.stateDir.lockFile);
+    } catch {}
+  }
+  async kill(gracefulTimeoutMs = 3000) {
+    const pid = this.readPid();
+    if (!pid) {
+      this.log("No daemon pid file found");
+      this.cleanup();
+      return false;
+    }
+    if (!isProcessAlive(pid)) {
+      this.log(`Daemon pid ${pid} is not alive, cleaning up stale files`);
+      this.cleanup();
+      return false;
+    }
+    if (!this.isDaemonProcess(pid)) {
+      this.log(`Pid ${pid} is alive but is NOT an AgentBridge daemon \u2014 refusing to kill. Cleaning up stale pid file.`);
+      this.cleanup();
+      return false;
+    }
+    this.log(`Sending SIGTERM to daemon pid ${pid}`);
+    try {
+      process.kill(pid, "SIGTERM");
+    } catch {
+      this.cleanup();
+      return false;
+    }
+    const deadline = Date.now() + gracefulTimeoutMs;
+    while (Date.now() < deadline) {
+      if (!isProcessAlive(pid)) {
+        this.log(`Daemon pid ${pid} stopped gracefully`);
+        this.cleanup();
+        return true;
+      }
+      await new Promise((resolve) => setTimeout(resolve, 200));
+    }
+    this.log(`Daemon pid ${pid} did not stop gracefully, sending SIGKILL`);
+    try {
+      process.kill(pid, "SIGKILL");
+    } catch {}
+    this.cleanup();
+    return true;
+  }
+  isDaemonProcess(pid) {
+    try {
+      const cmd = execFileSync("ps", ["-p", String(pid), "-o", "command="], { encoding: "utf-8" }).trim();
+      return cmd.includes("daemon") && (cmd.includes("agentbridge") || cmd.includes("agent_bridge"));
+    } catch {
+      return false;
+    }
+  }
+  cleanup() {
+    this.removePidFile();
+    this.removeStatusFile();
+    this.releaseLock();
+  }
+}
+function isProcessAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// 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,
+    proxyPort: 4501
+  },
+  agents: {
+    claude: {
+      role: "Reviewer, Planner",
+      mode: "push"
+    },
+    codex: {
+      role: "Implementer, Executor"
+    }
+  },
+  markers: ["IMPORTANT", "STATUS", "FYI"],
+  turnCoordination: {
+    attentionWindowSeconds: 15,
+    busyGuard: true
+  },
+  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";
+
+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);
+  }
+  load() {
+    try {
+      const raw = readFileSync2(this.configPath, "utf-8");
+      return JSON.parse(raw);
+    } catch {
+      return null;
+    }
+  }
+  loadOrDefault() {
+    return this.load() ?? structuredClone(DEFAULT_CONFIG);
+  }
+  save(config) {
+    this.ensureConfigDir();
+    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 = [];
+    if (!existsSync3(this.configPath)) {
+      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 });
+    }
+  }
+}
+
+// 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 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;
+var MAX_BUFFERED_MESSAGES = parseInt(process.env.AGENTBRIDGE_MAX_BUFFERED_MESSAGES ?? "100", 10);
+var FILTER_MODE = process.env.AGENTBRIDGE_FILTER_MODE === "full" ? "full" : "filtered";
+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 attachCmd = `codex --enable tui_app_server --remote ${codex.proxyUrl}`;
+var controlServer = null;
+var attachedClaude = null;
+var nextControlClientId = 0;
+var nextSystemMessageId = 0;
+var codexBootstrapped = false;
+var attentionWindowTimer = null;
+var inAttentionWindow = false;
+var replyRequired = false;
+var replyReceivedDuringTurn = false;
+var shuttingDown = false;
+var idleShutdownTimer = null;
+var claudeDisconnectTimer = null;
+var claudeOnlineNoticeSent = false;
+var claudeOfflineNoticeShown = false;
+var lastAttachStatusSentTs = 0;
+var ATTACH_STATUS_COOLDOWN_MS = 30000;
+var bufferedMessages = [];
+var tuiConnectionState = new TuiConnectionState({
+  disconnectGraceMs: TUI_DISCONNECT_GRACE_MS,
+  log,
+  onDisconnectPersisted: (connId) => {
+    emitToClaude(systemMessage("system_tui_disconnected", `\u26A0\uFE0F Codex TUI disconnected (conn #${connId}). Codex is still running in the background \u2014 reconnect the TUI to resume.`));
+  },
+  onReconnectAfterNotice: (connId) => {
+    emitToClaude(systemMessage("system_tui_reconnected", `\u2705 Codex TUI reconnected (conn #${connId}). Bridge restored, communication can continue.`));
+    codex.injectMessage("\u2705 Claude Code is still online, bridge restored. Bidirectional communication can continue.");
+  }
+});
+var statusBuffer = new StatusBuffer((summary) => emitToClaude(summary));
+codex.on("turnStarted", () => {
+  log("Codex turn started");
+  emitToClaude(systemMessage("system_turn_started", "\u23F3 Codex is working on the current task. Wait for completion before sending a reply."));
+});
+codex.on("agentMessage", (msg) => {
+  if (msg.source !== "codex")
+    return;
+  const result = classifyMessage(msg.content, FILTER_MODE);
+  if (replyRequired) {
+    log(`Codex \u2192 Claude [${result.marker}/force-forward-reply-required] (${msg.content.length} chars)`);
+    replyReceivedDuringTurn = true;
+    if (statusBuffer.size > 0) {
+      statusBuffer.flush("reply-required message arrived");
+    }
+    emitToClaude(msg);
+    return;
+  }
+  if (inAttentionWindow && result.marker === "status") {
+    log(`Codex \u2192 Claude [${result.marker}/buffer-attention] (${msg.content.length} chars)`);
+    statusBuffer.add(msg);
+    return;
+  }
+  log(`Codex \u2192 Claude [${result.marker}/${result.action}] (${msg.content.length} chars)`);
+  switch (result.action) {
+    case "forward":
+      if (result.marker === "important" && statusBuffer.size > 0) {
+        statusBuffer.flush("important message arrived");
+      }
+      emitToClaude(msg);
+      if (result.marker === "important") {
+        startAttentionWindow();
+      }
+      break;
+    case "buffer":
+      statusBuffer.add(msg);
+      break;
+    case "drop":
+      break;
+  }
+});
+codex.on("turnCompleted", () => {
+  log("Codex turn completed");
+  statusBuffer.flush("turn completed");
+  if (replyRequired && !replyReceivedDuringTurn) {
+    log("\u26A0\uFE0F Reply was required but Codex did not send any agentMessage");
+    emitToClaude(systemMessage("system_reply_missing", "\u26A0\uFE0F Codex completed the turn without sending a reply (require_reply was set). Codex may not have generated an agentMessage. You may want to retry or rephrase."));
+  }
+  replyRequired = false;
+  replyReceivedDuringTurn = false;
+  emitToClaude(systemMessage("system_turn_completed", "\u2705 Codex finished the current turn. You can reply now if needed."));
+  startAttentionWindow();
+});
+codex.on("ready", (threadId) => {
+  tuiConnectionState.markBridgeReady();
+  log(`Codex ready \u2014 thread ${threadId}`);
+  log("Bridge fully operational");
+  emitToClaude(systemMessage("system_ready", currentReadyMessage()));
+  if (attachedClaude && shouldNotifyCodexClaudeOnline()) {
+    notifyCodexClaudeOnline();
+  }
+});
+codex.on("tuiConnected", (connId) => {
+  tuiConnectionState.handleTuiConnected(connId);
+  cancelIdleShutdown();
+  log(`Codex TUI connected (conn #${connId})`);
+  broadcastStatus();
+});
+codex.on("tuiDisconnected", (connId) => {
+  tuiConnectionState.handleTuiDisconnected(connId);
+  log(`Codex TUI disconnected (conn #${connId})`);
+  broadcastStatus();
+  scheduleIdleShutdown();
+});
+codex.on("error", (err) => {
+  log(`Codex error: ${err.message}`);
+});
+codex.on("exit", (code) => {
+  log(`Codex process exited (code ${code})`);
+  codexBootstrapped = false;
+  statusBuffer.flush("codex exited");
+  tuiConnectionState.handleCodexExit();
+  clearPendingClaudeDisconnect("Codex process exited");
+  claudeOnlineNoticeSent = false;
+  claudeOfflineNoticeShown = false;
+  emitToClaude(systemMessage("system_codex_exit", `\u26A0\uFE0F Codex app-server exited (code ${code ?? "unknown"}). AgentBridge daemon is still running, but the Codex side needs to be restarted.`));
+  broadcastStatus();
+});
+function startControlServer() {
+  controlServer = Bun.serve({
+    port: CONTROL_PORT,
+    hostname: "127.0.0.1",
+    fetch(req, server) {
+      const url = new URL(req.url);
+      if (url.pathname === "/healthz") {
+        return Response.json(currentStatus());
+      }
+      if (url.pathname === "/readyz") {
+        return Response.json(currentStatus(), { status: codexBootstrapped ? 200 : 503 });
+      }
+      if (url.pathname === "/ws" && server.upgrade(req, { data: { clientId: 0, attached: false } })) {
+        return;
+      }
+      return new Response("AgentBridge daemon");
+    },
+    websocket: {
+      idleTimeout: 960,
+      sendPings: true,
+      open: (ws) => {
+        ws.data.clientId = ++nextControlClientId;
+        log(`Frontend socket opened (#${ws.data.clientId})`);
+      },
+      close: (ws, code, reason) => {
+        log(`Frontend socket closed (#${ws.data.clientId}, code=${code}, reason=${reason || "none"}, wasAttached=${attachedClaude === ws})`);
+        if (attachedClaude === ws) {
+          detachClaude(ws, "frontend socket closed");
+        }
+      },
+      message: (ws, raw) => {
+        handleControlMessage(ws, raw);
+      }
+    }
+  });
+}
+function handleControlMessage(ws, raw) {
+  let message;
+  try {
+    const text = typeof raw === "string" ? raw : raw.toString();
+    message = JSON.parse(text);
+  } catch (e) {
+    log(`Failed to parse control message: ${e.message}`);
+    return;
+  }
+  switch (message.type) {
+    case "claude_connect":
+      attachClaude(ws);
+      return;
+    case "claude_disconnect":
+      detachClaude(ws, "frontend requested disconnect");
+      return;
+    case "status":
+      sendStatus(ws);
+      return;
+    case "claude_to_codex": {
+      if (message.message.source !== "claude") {
+        sendProtocolMessage(ws, {
+          type: "claude_to_codex_result",
+          requestId: message.requestId,
+          success: false,
+          error: "Invalid message source"
+        });
+        return;
+      }
+      if (!tuiConnectionState.canReply()) {
+        sendProtocolMessage(ws, {
+          type: "claude_to_codex_result",
+          requestId: message.requestId,
+          success: false,
+          error: "Codex is not ready. Wait for TUI to connect and create a thread."
+        });
+        return;
+      }
+      const requireReply = !!message.requireReply;
+      let contentWithReminder = message.message.content + `
+
+` + BRIDGE_CONTRACT_REMINDER;
+      if (requireReply) {
+        contentWithReminder += REPLY_REQUIRED_INSTRUCTION;
+        replyRequired = true;
+        replyReceivedDuringTurn = false;
+        log(`Reply required flag set for this message`);
+      }
+      log(`Forwarding Claude \u2192 Codex (${message.message.content.length} chars, requireReply=${requireReply})`);
+      const injected = codex.injectMessage(contentWithReminder);
+      if (!injected) {
+        const reason = codex.turnInProgress ? "Codex is busy executing a turn. Wait for it to finish before sending another message." : "Injection failed: no active thread or WebSocket not connected.";
+        log(`Injection rejected: ${reason}`);
+        sendProtocolMessage(ws, {
+          type: "claude_to_codex_result",
+          requestId: message.requestId,
+          success: false,
+          error: reason
+        });
+        return;
+      }
+      clearAttentionWindow();
+      sendProtocolMessage(ws, {
+        type: "claude_to_codex_result",
+        requestId: message.requestId,
+        success: true
+      });
+      return;
+    }
+  }
+}
+function attachClaude(ws) {
+  if (attachedClaude && attachedClaude !== ws) {
+    attachedClaude.close(4001, "replaced by a newer Claude session");
+  }
+  clearPendingClaudeDisconnect("Claude frontend attached");
+  attachedClaude = ws;
+  ws.data.attached = true;
+  cancelIdleShutdown();
+  log(`Claude frontend attached (#${ws.data.clientId})`);
+  statusBuffer.flush("claude reconnected");
+  sendStatus(ws);
+  const now = Date.now();
+  const isRapidReattach = now - lastAttachStatusSentTs < ATTACH_STATUS_COOLDOWN_MS;
+  if (bufferedMessages.length > 0) {
+    flushBufferedMessages(ws);
+  } else if (!isRapidReattach) {
+    if (tuiConnectionState.canReply()) {
+      sendBridgeMessage(ws, systemMessage("system_ready", currentReadyMessage()));
+    } else if (codexBootstrapped) {
+      sendBridgeMessage(ws, systemMessage("system_waiting", currentWaitingMessage()));
+    }
+  }
+  lastAttachStatusSentTs = now;
+  if (tuiConnectionState.canReply() && shouldNotifyCodexClaudeOnline()) {
+    notifyCodexClaudeOnline();
+  }
+}
+function detachClaude(ws, reason) {
+  if (attachedClaude !== ws)
+    return;
+  attachedClaude = null;
+  ws.data.attached = false;
+  log(`Claude frontend detached (#${ws.data.clientId}, ${reason})`);
+  scheduleClaudeDisconnectNotification(ws.data.clientId);
+  scheduleIdleShutdown();
+}
+function startAttentionWindow() {
+  clearAttentionWindow();
+  inAttentionWindow = true;
+  statusBuffer.pause();
+  log(`Attention window started (${ATTENTION_WINDOW_MS}ms)`);
+  attentionWindowTimer = setTimeout(() => {
+    attentionWindowTimer = null;
+    inAttentionWindow = false;
+    statusBuffer.resume();
+    log("Attention window ended");
+  }, ATTENTION_WINDOW_MS);
+}
+function clearAttentionWindow() {
+  if (attentionWindowTimer) {
+    clearTimeout(attentionWindowTimer);
+    attentionWindowTimer = null;
+  }
+  if (inAttentionWindow) {
+    statusBuffer.resume();
+  }
+  inAttentionWindow = false;
+}
+function scheduleIdleShutdown() {
+  cancelIdleShutdown();
+  if (attachedClaude)
+    return;
+  const snapshot = tuiConnectionState.snapshot();
+  if (snapshot.tuiConnected)
+    return;
+  log(`No clients connected. Daemon will shut down in ${IDLE_SHUTDOWN_MS}ms if no one reconnects.`);
+  idleShutdownTimer = setTimeout(() => {
+    if (attachedClaude || tuiConnectionState.snapshot().tuiConnected) {
+      log("Idle shutdown cancelled: client reconnected during grace period");
+      return;
+    }
+    shutdown("idle \u2014 no clients connected");
+  }, IDLE_SHUTDOWN_MS);
+}
+function cancelIdleShutdown() {
+  if (idleShutdownTimer) {
+    clearTimeout(idleShutdownTimer);
+    idleShutdownTimer = null;
+  }
+}
+function clearPendingClaudeDisconnect(reason) {
+  if (!claudeDisconnectTimer)
+    return;
+  clearTimeout(claudeDisconnectTimer);
+  claudeDisconnectTimer = null;
+  if (reason) {
+    log(`Cleared pending Claude disconnect notification (${reason})`);
+  }
+}
+function scheduleClaudeDisconnectNotification(clientId) {
+  clearPendingClaudeDisconnect("rescheduled");
+  claudeDisconnectTimer = setTimeout(() => {
+    claudeDisconnectTimer = null;
+    if (attachedClaude) {
+      log(`Skipping Claude disconnect notification for client #${clientId} because Claude already reconnected`);
+      return;
+    }
+    if (!tuiConnectionState.canReply()) {
+      log(`Suppressing Claude disconnect notification for client #${clientId} because Codex cannot reply`);
+      return;
+    }
+    if (!claudeOnlineNoticeSent) {
+      log(`Suppressing Claude disconnect notification for client #${clientId} because Claude was never announced online`);
+      return;
+    }
+    codex.injectMessage("\u26A0\uFE0F Claude Code went offline. AgentBridge is still running in the background; it will reconnect automatically when Claude reopens.");
+    claudeOnlineNoticeSent = false;
+    claudeOfflineNoticeShown = true;
+    log(`Claude disconnect persisted past grace window (client #${clientId})`);
+  }, CLAUDE_DISCONNECT_GRACE_MS);
+}
+function emitToClaude(message) {
+  if (attachedClaude && attachedClaude.readyState === WebSocket.OPEN) {
+    if (trySendBridgeMessage(attachedClaude, message))
+      return;
+    log("Send to Claude failed, buffering message for retry on reconnect");
+  }
+  bufferedMessages.push(message);
+  if (bufferedMessages.length > MAX_BUFFERED_MESSAGES) {
+    const dropped = bufferedMessages.length - MAX_BUFFERED_MESSAGES;
+    bufferedMessages.splice(0, dropped);
+    log(`Message buffer overflow: dropped ${dropped} oldest message(s), ${MAX_BUFFERED_MESSAGES} remaining`);
+  }
+}
+function trySendBridgeMessage(ws, message) {
+  try {
+    const result = ws.send(JSON.stringify({ type: "codex_to_claude", message }));
+    if (typeof result === "number" && result <= 0) {
+      log(`Bridge message send returned ${result} (0=dropped, -1=backpressure)`);
+      return false;
+    }
+    return true;
+  } catch (err) {
+    log(`Failed to send bridge message: ${err.message}`);
+    return false;
+  }
+}
+function flushBufferedMessages(ws) {
+  const messages = bufferedMessages.splice(0, bufferedMessages.length);
+  for (const message of messages) {
+    if (!trySendBridgeMessage(ws, message)) {
+      const failedIndex = messages.indexOf(message);
+      const remaining = messages.slice(failedIndex);
+      bufferedMessages.unshift(...remaining);
+      log(`Flush interrupted: re-buffered ${remaining.length} message(s) after send failure`);
+      return;
+    }
+  }
+}
+function sendBridgeMessage(ws, message) {
+  trySendBridgeMessage(ws, message);
+}
+function sendStatus(ws) {
+  sendProtocolMessage(ws, { type: "status", status: currentStatus() });
+}
+function broadcastStatus() {
+  if (!attachedClaude)
+    return;
+  sendStatus(attachedClaude);
+}
+function sendProtocolMessage(ws, message) {
+  try {
+    ws.send(JSON.stringify(message));
+  } catch (err) {
+    log(`Failed to send control message: ${err.message}`);
+  }
+}
+function currentStatus() {
+  const snapshot = tuiConnectionState.snapshot();
+  return {
+    bridgeReady: tuiConnectionState.canReply(),
+    tuiConnected: snapshot.tuiConnected,
+    threadId: codex.activeThreadId,
+    queuedMessageCount: bufferedMessages.length + statusBuffer.size,
+    proxyUrl: codex.proxyUrl,
+    appServerUrl: codex.appServerUrl,
+    pid: process.pid
+  };
+}
+function currentWaitingMessage() {
+  return `\u23F3 Waiting for Codex TUI to connect. Run in another terminal:
+${attachCmd}`;
+}
+function currentReadyMessage() {
+  return `\u2705 Codex TUI connected (${codex.activeThreadId}). Bridge ready.`;
+}
+function notifyCodexClaudeOnline() {
+  claudeOnlineNoticeSent = true;
+  claudeOfflineNoticeShown = false;
+  codex.injectMessage("\u2705 AgentBridge connected to Claude Code.");
+}
+function shouldNotifyCodexClaudeOnline() {
+  return !claudeOnlineNoticeSent || claudeOfflineNoticeShown;
+}
+function systemMessage(idPrefix, content) {
+  return {
+    id: `${idPrefix}_${++nextSystemMessageId}`,
+    source: "codex",
+    content,
+    timestamp: Date.now()
+  };
+}
+function writePidFile() {
+  daemonLifecycle.writePid();
+}
+function removePidFile() {
+  daemonLifecycle.removePidFile();
+}
+function writeStatusFile() {
+  daemonLifecycle.writeStatus({
+    proxyUrl: codex.proxyUrl,
+    appServerUrl: codex.appServerUrl,
+    controlPort: CONTROL_PORT,
+    pid: process.pid
+  });
+}
+function removeStatusFile() {
+  daemonLifecycle.removeStatusFile();
+}
+async function bootCodex() {
+  log("Starting AgentBridge daemon...");
+  log(`Codex app-server: ${codex.appServerUrl}`);
+  log(`Codex proxy: ${codex.proxyUrl}`);
+  log(`Control server: ws://127.0.0.1:${CONTROL_PORT}/ws`);
+  try {
+    await codex.start();
+    codexBootstrapped = true;
+    writeStatusFile();
+    emitToClaude(systemMessage("system_waiting", currentWaitingMessage()));
+    broadcastStatus();
+  } catch (err) {
+    log(`Failed to start Codex: ${err.message}`);
+    emitToClaude(systemMessage("system_codex_start_failed", `\u274C AgentBridge failed to start Codex app-server: ${err.message}`));
+    broadcastStatus();
+  }
+}
+function shutdown(reason) {
+  if (shuttingDown)
+    return;
+  shuttingDown = true;
+  log(`Shutting down daemon (${reason})...`);
+  tuiConnectionState.dispose(`daemon shutdown (${reason})`);
+  clearPendingClaudeDisconnect(`daemon shutdown (${reason})`);
+  controlServer?.stop();
+  controlServer = null;
+  codex.stop();
+  removePidFile();
+  removeStatusFile();
+  process.exit(0);
+}
+process.on("SIGINT", () => shutdown("SIGINT"));
+process.on("SIGTERM", () => shutdown("SIGTERM"));
+process.on("exit", () => {
+  removePidFile();
+  removeStatusFile();
+});
+process.on("uncaughtException", (err) => {
+  log(`UNCAUGHT EXCEPTION: ${err.stack ?? err.message}`);
+});
+process.on("unhandledRejection", (reason) => {
+  log(`UNHANDLED REJECTION: ${reason?.stack ?? reason}`);
+});
+function log(msg) {
+  const line = `[${new Date().toISOString()}] [AgentBridgeDaemon] ${msg}
+`;
+  process.stderr.write(line);
+  try {
+    appendFileSync2(stateDir.logFile, line);
+  } catch {}
+}
+if (daemonLifecycle.wasKilled()) {
+  log("Killed sentinel found \u2014 daemon was intentionally stopped. Exiting immediately.");
+  process.exit(0);
+}
+writePidFile();
+startControlServer();
+bootCodex();