@raysonmeng/agentbridge 0.1.12 → 0.1.13

package/plugins/agentbridge/server/daemon.js

@@ -1,10 +1,19 @@
 #!/usr/bin/env bun
 // @bun
 
+// src/daemon.ts
+import { rmSync as rmSync2 } from "fs";
+import { randomUUID as randomUUID4 } from "crypto";
+
 // src/contract-version.ts
 var CONTRACT_VERSION = 1;
 
 // src/build-info.ts
+var CODE_HASH_SENTINEL = "source";
+function hasValidCodeHash(build) {
+  const hash = build?.codeHash;
+  return typeof hash === "string" && hash.length > 0 && hash !== CODE_HASH_SENTINEL;
+}
 function defineString(value, fallback) {
   return typeof value === "string" && value.length > 0 ? value : fallback;
 }
@@ -17,10 +26,11 @@ function defineNumber(value, fallback) {
   return typeof value === "number" && Number.isFinite(value) ? value : fallback;
 }
 var BUILD_INFO = Object.freeze({
-  version: defineString("0.1.12", "0.0.0-source"),
-  commit: defineString("eec6018", "source"),
+  version: defineString("0.1.13", "0.0.0-source"),
+  commit: defineString("7a71869", "source"),
   bundle: defineBundle("plugin"),
-  contractVersion: defineNumber(1, CONTRACT_VERSION)
+  contractVersion: defineNumber(1, CONTRACT_VERSION),
+  codeHash: defineString("e1fd67d07c62", "source")
 });
 function daemonStatusBuildInfo() {
   return { ...BUILD_INFO };
@@ -28,7 +38,14 @@ function daemonStatusBuildInfo() {
 function sameRuntimeContract(a, b) {
   if (!a || !b)
     return false;
-  return a.version === b.version && a.commit === b.commit && a.contractVersion === b.contractVersion;
+  if (a.version !== b.version || a.contractVersion !== b.contractVersion)
+    return false;
+  if (hasValidCodeHash(a) && hasValidCodeHash(b))
+    return a.codeHash === b.codeHash;
+  return a.commit === b.commit;
+}
+function runtimeContractComparisonBasis(a, b) {
+  return hasValidCodeHash(a) && hasValidCodeHash(b) ? "codeHash" : "commit";
 }
 function compatibleContractVersion(a, b) {
   if (!a || !b)
@@ -38,7 +55,175 @@ function compatibleContractVersion(a, b) {
 function formatBuildInfo(build) {
   if (!build)
     return "<unknown>";
-  return `${build.version}/${build.commit}/${build.bundle}/contract-v${build.contractVersion}`;
+  const codeHash = hasValidCodeHash(build) ? `/code-${build.codeHash}` : "";
+  return `${build.version}/${build.commit}/${build.bundle}/contract-v${build.contractVersion}${codeHash}`;
+}
+
+// src/daemon-record.ts
+import { readFileSync } from "fs";
+
+// src/atomic-json.ts
+import * as fs from "fs";
+import { randomUUID } from "crypto";
+import { dirname } from "path";
+function tmpPathFor(targetPath) {
+  return `${targetPath}.tmp.${process.pid}.${randomUUID()}`;
+}
+function atomicWriteText(path, content, options = {}) {
+  fs.mkdirSync(dirname(path), { recursive: true });
+  const tmp = tmpPathFor(path);
+  let renamed = false;
+  const fd = fs.openSync(tmp, "w", options.mode ?? 438);
+  try {
+    try {
+      fs.writeFileSync(fd, content, "utf-8");
+      if (options.fsync)
+        fs.fsyncSync(fd);
+    } finally {
+      fs.closeSync(fd);
+    }
+    fs.renameSync(tmp, path);
+    renamed = true;
+  } finally {
+    if (!renamed) {
+      try {
+        fs.unlinkSync(tmp);
+      } catch {}
+    }
+  }
+}
+function atomicWriteJson(path, value, options = {}) {
+  atomicWriteText(path, JSON.stringify(value, null, 2) + `
+`, options);
+}
+
+// src/daemon-record.ts
+var defaultRead = (path) => readFileSync(path, "utf-8");
+function writeDaemonRecord(path, record) {
+  atomicWriteJson(path, record);
+}
+function sanitizePorts(value) {
+  if (typeof value !== "object" || value === null)
+    return;
+  const raw = value;
+  const ports = {};
+  if (typeof raw.appPort === "number")
+    ports.appPort = raw.appPort;
+  if (typeof raw.proxyPort === "number")
+    ports.proxyPort = raw.proxyPort;
+  if (typeof raw.controlPort === "number")
+    ports.controlPort = raw.controlPort;
+  return Object.keys(ports).length > 0 ? ports : undefined;
+}
+function readDaemonRecord(path, read = defaultRead) {
+  let parsed;
+  try {
+    parsed = JSON.parse(read(path));
+  } catch {
+    return null;
+  }
+  if (typeof parsed !== "object" || parsed === null)
+    return null;
+  const obj = parsed;
+  if (typeof obj.pid !== "number" || !Number.isFinite(obj.pid))
+    return null;
+  const phase = obj.phase === "ready" ? "ready" : "booting";
+  const record = { pid: obj.pid, phase };
+  if (typeof obj.startedAt === "number")
+    record.startedAt = obj.startedAt;
+  if (typeof obj.nonce === "string")
+    record.nonce = obj.nonce;
+  if (obj.pairId === null || typeof obj.pairId === "string")
+    record.pairId = obj.pairId;
+  if (obj.cwd === null || typeof obj.cwd === "string")
+    record.cwd = obj.cwd;
+  if (obj.stateDir === null || typeof obj.stateDir === "string")
+    record.stateDir = obj.stateDir;
+  if (typeof obj.proxyUrl === "string")
+    record.proxyUrl = obj.proxyUrl;
+  if (typeof obj.appServerUrl === "string")
+    record.appServerUrl = obj.appServerUrl;
+  const ports = sanitizePorts(obj.ports);
+  if (ports !== undefined)
+    record.ports = ports;
+  if (typeof obj.build === "object" && obj.build !== null) {
+    record.build = obj.build;
+  }
+  if (typeof obj.turnPhase === "string")
+    record.turnPhase = obj.turnPhase;
+  if (typeof obj.turnInProgress === "boolean")
+    record.turnInProgress = obj.turnInProgress;
+  if (typeof obj.attentionWindowActive === "boolean") {
+    record.attentionWindowActive = obj.attentionWindowActive;
+  }
+  return record;
+}
+function synthesizeLegacyRecord(pidFilePath, statusFilePath, read = defaultRead) {
+  let pidFromPidFile = null;
+  try {
+    const raw = read(pidFilePath).trim();
+    const n = Number.parseInt(raw, 10);
+    if (Number.isFinite(n))
+      pidFromPidFile = n;
+  } catch {}
+  let status = null;
+  try {
+    const parsed = JSON.parse(read(statusFilePath));
+    if (typeof parsed === "object" && parsed !== null)
+      status = parsed;
+  } catch {}
+  const pidFromStatus = status && typeof status.pid === "number" && Number.isFinite(status.pid) ? status.pid : null;
+  const pid = pidFromPidFile ?? pidFromStatus;
+  if (pid === null)
+    return null;
+  const record = {
+    pid,
+    phase: status ? "ready" : "booting"
+  };
+  if (status) {
+    if (typeof status.proxyUrl === "string")
+      record.proxyUrl = status.proxyUrl;
+    if (typeof status.appServerUrl === "string")
+      record.appServerUrl = status.appServerUrl;
+    const controlPort = typeof status.controlPort === "number" ? status.controlPort : undefined;
+    const proxyPort = portFromUrl(status.proxyUrl);
+    const appPort = portFromUrl(status.appServerUrl);
+    if (controlPort !== undefined || proxyPort !== undefined || appPort !== undefined) {
+      record.ports = {};
+      if (appPort !== undefined)
+        record.ports.appPort = appPort;
+      if (proxyPort !== undefined)
+        record.ports.proxyPort = proxyPort;
+      if (controlPort !== undefined)
+        record.ports.controlPort = controlPort;
+    }
+    if (status.pairId === null || typeof status.pairId === "string")
+      record.pairId = status.pairId;
+    if (status.cwd === null || typeof status.cwd === "string")
+      record.cwd = status.cwd;
+    if (status.stateDir === null || typeof status.stateDir === "string")
+      record.stateDir = status.stateDir;
+    if (typeof status.build === "object" && status.build !== null) {
+      record.build = status.build;
+    }
+    if (typeof status.turnPhase === "string")
+      record.turnPhase = status.turnPhase;
+    if (typeof status.turnInProgress === "boolean")
+      record.turnInProgress = status.turnInProgress;
+    if (typeof status.attentionWindowActive === "boolean") {
+      record.attentionWindowActive = status.attentionWindowActive;
+    }
+  }
+  return record;
+}
+function readUnifiedDaemonRecord(paths, read = defaultRead) {
+  return readDaemonRecord(paths.daemonRecordFile, read) ?? synthesizeLegacyRecord(paths.pidFile, paths.statusFile, read);
+}
+function portFromUrl(url) {
+  if (typeof url !== "string")
+    return;
+  const match = url.match(/:(\d+)(?:[/?]|$)/);
+  return match ? Number.parseInt(match[1], 10) : undefined;
 }
 
 // src/codex-adapter.ts
@@ -47,9 +232,13 @@ import { createInterface } from "readline";
 import { EventEmitter } from "events";
 
 // src/state-dir.ts
-import { mkdirSync, existsSync } from "fs";
+import { mkdirSync as mkdirSync2, existsSync } from "fs";
 import { join } from "path";
 import { homedir, platform } from "os";
+function resolveXdgStateBase(rawXdg = process.env.XDG_STATE_HOME) {
+  const xdgState = rawXdg && rawXdg.length > 0 ? rawXdg : join(homedir(), ".local", "state");
+  return join(xdgState, "agentbridge");
+}
 
 class StateDirResolver {
   stateDir;
@@ -57,8 +246,7 @@ class StateDirResolver {
     if (platform() === "darwin") {
       return join(homedir(), "Library", "Application Support", "AgentBridge");
     }
-    const xdgState = process.env.XDG_STATE_HOME ?? join(homedir(), ".local", "state");
-    return join(xdgState, "agentbridge");
+    return resolveXdgStateBase(process.env.XDG_STATE_HOME);
   }
   constructor(envOverride) {
     const override = envOverride ?? process.env.AGENTBRIDGE_STATE_DIR;
@@ -66,7 +254,7 @@ class StateDirResolver {
   }
   ensure() {
     if (!existsSync(this.stateDir)) {
-      mkdirSync(this.stateDir, { recursive: true });
+      mkdirSync2(this.stateDir, { recursive: true });
     }
   }
   get dir() {
@@ -84,8 +272,8 @@ class StateDirResolver {
   get statusFile() {
     return join(this.stateDir, "status.json");
   }
-  get portsFile() {
-    return join(this.stateDir, "ports.json");
+  get daemonRecordFile() {
+    return join(this.stateDir, "daemon.json");
   }
   get currentThreadFile() {
     return join(this.stateDir, "current-thread.json");
@@ -205,15 +393,15 @@ async function cleanupPorts(options) {
 }
 
 // src/rotating-log.ts
-import { appendFileSync, existsSync as existsSync2, renameSync, statSync, unlinkSync } from "fs";
-import { dirname } from "path";
+import { appendFileSync, existsSync as existsSync2, renameSync as renameSync2, statSync, unlinkSync as unlinkSync2 } from "fs";
+import { dirname as dirname2 } from "path";
 var DEFAULT_MAX_BYTES = 5 * 1024 * 1024;
 var DEFAULT_KEEP = 3;
-var REAL_FS_OPS = { statSync, renameSync, unlinkSync, appendFileSync, existsSync: existsSync2 };
+var REAL_FS_OPS = { statSync, renameSync: renameSync2, unlinkSync: unlinkSync2, appendFileSync, existsSync: existsSync2 };
 function appendRotatingLog(path, content, options = {}, fsOps = REAL_FS_OPS) {
   const maxBytes = options.maxBytes ?? positiveIntFromEnv("AGENTBRIDGE_LOG_MAX_BYTES", DEFAULT_MAX_BYTES);
   const keep = options.keep ?? positiveIntFromEnv("AGENTBRIDGE_LOG_ROTATE_KEEP", DEFAULT_KEEP);
-  if (!fsOps.existsSync(dirname(path)))
+  if (!fsOps.existsSync(dirname2(path)))
     return;
   rotateIfNeeded(path, Buffer.byteLength(content), maxBytes, keep, fsOps);
   fsOps.appendFileSync(path, content, "utf-8");
@@ -363,6 +551,16 @@ var APP_SERVER_NOTIFICATION_METHODS = [
 var TRACKED_REQUEST_METHOD_SET = new Set(APP_SERVER_TRACKED_REQUEST_METHODS);
 var SERVER_REQUEST_METHOD_SET = new Set(APP_SERVER_SERVER_REQUEST_METHODS);
 var NOTIFICATION_METHOD_SET = new Set(APP_SERVER_NOTIFICATION_METHODS);
+function parseAppServerVersion(userAgent) {
+  if (typeof userAgent !== "string")
+    return null;
+  const match = userAgent.match(/\/([^\s]+)/);
+  return match ? match[1] : null;
+}
+var APP_SERVER_RATE_LIMIT_ERROR_CODES = new Set([
+  -32603,
+  -32600
+]);
 function isObjectRecord(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
@@ -410,7 +608,7 @@ function clampInterruptTimeoutMs(requested) {
 // src/codex-transport.ts
 import { createServer, connect } from "net";
 import { spawnSync } from "child_process";
-import { mkdirSync as mkdirSync2, rmSync, chmodSync } from "fs";
+import { mkdirSync as mkdirSync3, rmSync, chmodSync } from "fs";
 import { join as join2 } from "path";
 import { tmpdir } from "os";
 var CODEX_TRANSPORT_ENV = "AGENTBRIDGE_CODEX_TRANSPORT";
@@ -471,7 +669,7 @@ function ensureSocketDir(socketPath) {
   const dir = socketPath.slice(0, socketPath.lastIndexOf("/"));
   if (!dir)
     return;
-  mkdirSync2(dir, { recursive: true, mode: 448 });
+  mkdirSync3(dir, { recursive: true, mode: 448 });
   try {
     chmodSync(dir, 448);
   } catch (err) {
@@ -601,10 +799,13 @@ async function waitForUnixWsReady(socketPath, maxRetries = 40, delayMs = 250) {
 function attemptUnixWsUpgrade(socketPath) {
   return new Promise((resolve) => {
     let settled = false;
+    let timeout;
     const done = (ok) => {
       if (settled)
         return;
       settled = true;
+      if (timeout !== undefined)
+        clearTimeout(timeout);
       try {
         socket.destroy();
       } catch {}
@@ -629,7 +830,8 @@ Sec-WebSocket-Version: 13\r
     });
     socket.on("error", () => done(false));
     socket.on("close", () => done(false));
-    setTimeout(() => done(false), 1500);
+    timeout = setTimeout(() => done(false), 1500);
+    timeout.unref?.();
   });
 }
 
@@ -666,6 +868,76 @@ function wsOriginRejectedResponse() {
   return new Response("Forbidden: WebSocket Origin not allowed", { status: 403 });
 }
 
+// src/pending-request-registry.ts
+class PendingRequestRegistry {
+  entries = new Map;
+  setTimer;
+  clearTimer;
+  constructor(deps = {}) {
+    this.setTimer = deps.setTimer ?? ((fn, ms) => setTimeout(fn, ms));
+    this.clearTimer = deps.clearTimer ?? ((handle) => clearTimeout(handle));
+  }
+  get size() {
+    return this.entries.size;
+  }
+  has(id) {
+    return this.entries.has(id);
+  }
+  register(id, options) {
+    const existing = this.entries.get(id);
+    if (existing) {
+      this.clearTimer(existing.timer);
+      this.entries.delete(id);
+    }
+    return new Promise((resolve, reject) => {
+      const timer = this.setTimer(() => {
+        if (!this.entries.has(id))
+          return;
+        this.entries.delete(id);
+        options.onTimeout({ resolve, reject });
+      }, options.timeoutMs);
+      if (options.unref) {
+        timer.unref?.();
+      }
+      this.entries.set(id, { resolve, reject, timer });
+    });
+  }
+  settle(id, value) {
+    const entry = this.entries.get(id);
+    if (!entry)
+      return false;
+    this.clearTimer(entry.timer);
+    this.entries.delete(id);
+    entry.resolve(value);
+    return true;
+  }
+  reject(id, error) {
+    const entry = this.entries.get(id);
+    if (!entry)
+      return false;
+    this.clearTimer(entry.timer);
+    this.entries.delete(id);
+    entry.reject(error);
+    return true;
+  }
+  settleAll(value) {
+    const make = typeof value === "function" ? value : () => value;
+    for (const [id, entry] of this.entries) {
+      this.clearTimer(entry.timer);
+      this.entries.delete(id);
+      entry.resolve(make(id));
+    }
+  }
+  rejectAll(error) {
+    const make = typeof error === "function" ? error : () => error;
+    for (const [id, entry] of this.entries) {
+      this.clearTimer(entry.timer);
+      this.entries.delete(id);
+      entry.reject(make(id));
+    }
+  }
+}
+
 // src/codex-adapter.ts
 class CodexAdapter extends EventEmitter {
   static RESPONSE_TRACKING_TTL_MS = 30000;
@@ -715,8 +987,13 @@ class CodexAdapter extends EventEmitter {
   static OUTAGE_TIMEOUT_MS = 1e4;
   lastInitializeRaw = null;
   lastInitializedRaw = null;
+  pendingInitializeProxyIds = new Set;
+  appServerInfo = null;
+  warnedAppServerVersions = new Set;
+  warnedFragileRateLimitMessages = new Set;
   sessionRestoreInProgress = false;
-  replayPending = new Map;
+  replayPending = new PendingRequestRegistry;
+  replayMethods = new Map;
   static SESSION_REPLAY_TIMEOUT_MS = 5000;
   constructor(appPort = 4500, proxyPort = 4501, logFile = new StateDirResolver().logFile) {
     super();
@@ -734,16 +1011,40 @@ class CodexAdapter extends EventEmitter {
   get activeThreadId() {
     return this.threadId;
   }
+  get capturedAppServerInfo() {
+    return this.appServerInfo;
+  }
   async start() {
     this.intentionalDisconnect = false;
     await this.checkPorts();
-    this.resolveTransport();
-    const listen = codexListenArg(this.transport, this.appPort, this.socketPath ?? "");
-    if (this.transport === "unix" && this.socketPath) {
-      ensureSocketDir(this.socketPath);
-      removeSocketFile(this.socketPath);
+    try {
+      this.resolveTransport();
+      const listen = codexListenArg(this.transport, this.appPort, this.socketPath ?? "");
+      if (this.transport === "unix" && this.socketPath) {
+        ensureSocketDir(this.socketPath);
+        removeSocketFile(this.socketPath);
+      }
+      this.log(`Spawning codex app-server (transport=${this.transport}) --listen ${listen}`);
+      this.spawnAppServer(listen);
+      if (this.transport === "unix" && this.socketPath) {
+        await waitForUnixWsReady(this.socketPath);
+        this.relay = new TcpToUnixRelay("127.0.0.1", this.appPort, this.socketPath, (m) => this.log(`[relay] ${m}`));
+        await this.relay.start();
+        this.log(`Transport relay ready: ws://127.0.0.1:${this.appPort} \u2192 unix://${this.socketPath}`);
+      } else {
+        await this.waitForHealthy();
+      }
+      await this.connectToAppServer();
+      this.startProxy();
+      this.log(`Proxy ready on ${this.proxyUrl}`);
+    } catch (err) {
+      const m = err instanceof Error ? err.message : String(err);
+      this.log(`start() failed (${m}) \u2014 tearing down partial transport before rethrow`);
+      this.cleanupAfterFailedStart();
+      throw err;
     }
-    this.log(`Spawning codex app-server (transport=${this.transport}) --listen ${listen}`);
+  }
+  spawnAppServer(listen) {
     this.proc = spawn("codex", ["app-server", "--listen", listen], {
       stdio: ["pipe", "pipe", "pipe"]
     });
@@ -757,17 +1058,25 @@ class CodexAdapter extends EventEmitter {
     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}`));
-    if (this.transport === "unix" && this.socketPath) {
-      await waitForUnixWsReady(this.socketPath);
-      this.relay = new TcpToUnixRelay("127.0.0.1", this.appPort, this.socketPath, (m) => this.log(`[relay] ${m}`));
-      await this.relay.start();
-      this.log(`Transport relay ready: ws://127.0.0.1:${this.appPort} \u2192 unix://${this.socketPath}`);
-    } else {
-      await this.waitForHealthy();
+  }
+  teardownTransport() {
+    this.proxyServer?.stop();
+    this.proxyServer = null;
+    if (this.relay) {
+      this.relay.stop();
+      this.relay = null;
     }
-    await this.connectToAppServer();
-    this.startProxy();
-    this.log(`Proxy ready on ${this.proxyUrl}`);
+    if (this.socketPath)
+      removeSocketFile(this.socketPath);
+  }
+  cleanupAfterFailedStart() {
+    try {
+      this.teardownTransport();
+    } catch (e) {
+      this.log(`cleanupAfterFailedStart: teardownTransport error: ${e.message}`);
+    }
+    this.forceKillAppServerSync();
+    this.proc = null;
   }
   resolveTransport() {
     const mode = parseTransportMode(process.env[CODEX_TRANSPORT_ENV]);
@@ -791,14 +1100,7 @@ class CodexAdapter extends EventEmitter {
       } catch {}
       this.secondaryConnections.delete(id);
     }
-    this.proxyServer?.stop();
-    this.proxyServer = null;
-    if (this.relay) {
-      this.relay.stop();
-      this.relay = null;
-    }
-    if (this.socketPath)
-      removeSocketFile(this.socketPath);
+    this.teardownTransport();
     this.clearResponseTrackingState();
     this.resetTurnState(ADAPTER_DISCONNECT_REASON);
   }
@@ -1225,36 +1527,38 @@ class CodexAdapter extends EventEmitter {
       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}`));
+    const timeoutMs = CodexAdapter.SESSION_REPLAY_TIMEOUT_MS;
+    this.replayMethods.set(id, method);
+    const pending = this.replayPending.register(id, {
+      timeoutMs,
+      onTimeout: ({ reject }) => {
+        this.replayMethods.delete(id);
+        reject(new Error(`replay timeout (${timeoutMs}ms) for ${method} id=${JSON.stringify(id)}`));
       }
     });
+    try {
+      this.appServerWs.send(raw);
+    } catch (e) {
+      this.replayMethods.delete(id);
+      const m = e instanceof Error ? e.message : String(e);
+      this.replayPending.reject(id, new Error(`replay send failed for ${method}: ${m}`));
+    }
+    return pending;
   }
   tryConsumeReplayResponse(payload) {
     const id = payload.id;
     if (id === undefined)
       return false;
-    const pending = this.replayPending.get(id);
-    if (!pending)
+    const key = id;
+    if (!this.replayPending.has(key))
       return false;
-    clearTimeout(pending.timer);
-    this.replayPending.delete(id);
+    const method = this.replayMethods.get(key) ?? "replay";
+    this.replayMethods.delete(key);
     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}`));
+      this.replayPending.reject(key, new Error(`${method} rejected: ${errMsg}`));
     } else {
-      pending.resolve(payload);
+      this.replayPending.settle(key, payload);
     }
     return true;
   }
@@ -1549,6 +1853,9 @@ class CodexAdapter extends EventEmitter {
         const proxyId = this.nextProxyId++;
         this.upstreamToClient.set(proxyId, { connId, clientId: parsed.id });
         this.trackPendingRequest(parsed, connId, proxyId);
+        if (parsed.method === "initialize") {
+          this.pendingInitializeProxyIds.add(proxyId);
+        }
         parsed.id = proxyId;
         forwarded = JSON.stringify(parsed);
       } else {
@@ -1701,6 +2008,9 @@ class CodexAdapter extends EventEmitter {
     const mapping = !isNaN(numericId) ? this.upstreamToClient.get(numericId) : undefined;
     if (mapping) {
       this.upstreamToClient.delete(numericId);
+      if (!isNaN(numericId) && this.pendingInitializeProxyIds.delete(numericId)) {
+        this.captureAppServerInfo(parsed.result);
+      }
       if (mapping.connId !== this.tuiConnId) {
         this.log(`Dropping stale response (upstream id ${responseId}, from conn #${mapping.connId}, current #${this.tuiConnId})`);
         return null;
@@ -1751,11 +2061,40 @@ class CodexAdapter extends EventEmitter {
     this.log(`Dropping unmatched app-server response id ${String(responseId)}`);
     return null;
   }
+  captureAppServerInfo(result) {
+    const init = typeof result === "object" && result !== null ? result : {};
+    const userAgent = typeof init.userAgent === "string" ? init.userAgent : null;
+    const version = parseAppServerVersion(userAgent);
+    const info = {
+      version,
+      userAgent,
+      platformFamily: typeof init.platformFamily === "string" ? init.platformFamily : null,
+      platformOs: typeof init.platformOs === "string" ? init.platformOs : null
+    };
+    this.appServerInfo = info;
+    this.log(`Captured app-server initialize: version=${version ?? "unknown"} ` + `userAgent=${userAgent ?? "none"} platform=${info.platformOs ?? "?"}/${info.platformFamily ?? "?"}`);
+    if (version === null) {
+      const dedupKey = userAgent ?? "<missing-userAgent>";
+      if (!this.warnedAppServerVersions.has(dedupKey)) {
+        this.warnedAppServerVersions.add(dedupKey);
+        this.log(`WARNING: app-server initialize response carried no parseable version ` + `(userAgent=${userAgent ?? "missing"}). The proxy's intercept points assume a ` + `known protocol snapshot \u2014 verify the version-coupling checklist if Codex was upgraded.`);
+      }
+    }
+  }
   patchResponse(parsed, raw) {
     if (isAppServerResponseMessage(parsed) && parsed.error && parsed.id !== undefined) {
       const errMsg = parsed.error.message ?? "";
-      if (errMsg.includes("rate limits") || errMsg.includes("rateLimits")) {
-        this.log(`Patching rateLimits error \u2192 mock success (id: ${parsed.id})`);
+      const errCode = parsed.error.code;
+      const textMatchesRateLimit = errMsg.includes("rate limits") || errMsg.includes("rateLimits");
+      const codeRecognized = typeof errCode === "number" && APP_SERVER_RATE_LIMIT_ERROR_CODES.has(errCode);
+      const structuredMatch = codeRecognized && textMatchesRateLimit;
+      if (structuredMatch || textMatchesRateLimit) {
+        if (structuredMatch) {
+          this.log(`Patching rateLimits error \u2192 mock success via structured code ${errCode} (id: ${parsed.id})`);
+        } else {
+          this.warnFragileRateLimitMatch(errMsg, errCode);
+          this.log(`Patching rateLimits error \u2192 mock success via fragile text fallback (id: ${parsed.id})`);
+        }
         return JSON.stringify({
           id: parsed.id,
           result: {
@@ -1774,6 +2113,12 @@ class CodexAdapter extends EventEmitter {
     }
     return raw;
   }
+  warnFragileRateLimitMatch(errMsg, errCode) {
+    if (this.warnedFragileRateLimitMessages.has(errMsg))
+      return;
+    this.warnedFragileRateLimitMessages.add(errMsg);
+    this.log(`WARNING: fragile-match \u2014 patched a rate-limit error by human-readable text ` + `(code=${errCode ?? "none"} not in the recognized set). If Codex changed the ` + `error wording or code, update patchResponse / APP_SERVER_RATE_LIMIT_ERROR_CODES. ` + `Message: ${errMsg.slice(0, 120)}`);
+  }
   interceptServerMessage(msg, connId) {
     this.handleTrackedResponse(msg, connId);
     if ("method" in msg && typeof msg.method === "string" && isAppServerNotification(msg)) {
@@ -1977,15 +2322,27 @@ class CodexAdapter extends EventEmitter {
   markTurnCompleted(turnId) {
     const completedId = typeof turnId === "string" && turnId.length > 0 ? turnId : null;
     if (completedId !== null) {
+      const idWasTracked = this.activeTurnIds.has(completedId);
       this.activeTurnIds.delete(completedId);
       this.clearTurnWatchdog(completedId);
       this.stalledTurnIds.delete(completedId);
       this.currentlyStalledTurnIds.delete(completedId);
+      if (!idWasTracked) {
+        const placeholders = [...this.activeTurnIds].filter((id) => id.startsWith("unknown:"));
+        if (placeholders.length === 1) {
+          const placeholder = placeholders[0];
+          this.activeTurnIds.delete(placeholder);
+          this.clearTurnWatchdog(placeholder);
+          this.stalledTurnIds.delete(placeholder);
+          this.currentlyStalledTurnIds.delete(placeholder);
+        }
+      }
     } else {
       this.activeTurnIds.clear();
       this.clearAllTurnWatchdogs();
       this.stalledTurnIds.clear();
       this.currentlyStalledTurnIds.clear();
+      this.agentMessageBuffers.clear();
     }
     this.lastTurnEndedAbnormally = false;
     this.turnInProgress = this.activeTurnIds.size > 0;
@@ -2048,6 +2405,7 @@ class CodexAdapter extends EventEmitter {
     this.clearAllTurnWatchdogs();
     this.stalledTurnIds.clear();
     this.currentlyStalledTurnIds.clear();
+    this.agentMessageBuffers.clear();
     this.turnInProgress = false;
     if (wasInProgress) {
       this.lastTurnEndedAbnormally = !emitCompleted;
@@ -2136,6 +2494,7 @@ class CodexAdapter extends EventEmitter {
   clearTransientResponseTrackingState() {
     this.pendingRequests.clear();
     this.upstreamToClient.clear();
+    this.pendingInitializeProxyIds.clear();
     for (const timer of this.staleProxyIds.values()) {
       clearTimeout(timer);
     }
@@ -2191,11 +2550,65 @@ var CLOSE_CODE_REPLACED = 4001;
 var CLOSE_CODE_EVICTED_STALE = 4002;
 var CLOSE_CODE_PROBE_IN_PROGRESS = 4003;
 var CLOSE_CODE_PAIR_MISMATCH = 4004;
+var CLOSE_CODE_TOKEN_MISMATCH = 4005;
+var CLOSE_CODE_CONTRACT_MISMATCH = 4006;
+
+// src/control-token.ts
+import { chmodSync as chmodSync2, readFileSync as readFileSync2 } from "fs";
+import { join as join3 } from "path";
+import { randomUUID as randomUUID2 } from "crypto";
+var CONTROL_TOKEN_FILENAME = "control-token";
+function resolveControlTokenPath(stateDir) {
+  return join3(stateDir, CONTROL_TOKEN_FILENAME);
+}
+function generateControlToken() {
+  return randomUUID2();
+}
+function writeControlToken(path, token) {
+  atomicWriteText(path, token, { mode: 384 });
+  chmodSync2(path, 384);
+}
+function validateControlToken(input) {
+  const { expectedToken } = input;
+  if (expectedToken == null || expectedToken.length === 0) {
+    return { ok: true };
+  }
+  const provided = input.providedToken;
+  if (provided == null || provided.length === 0) {
+    return { ok: false, reason: "missing control token" };
+  }
+  if (!constantTimeEquals(provided, expectedToken)) {
+    return { ok: false, reason: "control token mismatch" };
+  }
+  return { ok: true };
+}
+function constantTimeEquals(a, b) {
+  const len = Math.max(a.length, b.length);
+  let diff = a.length ^ b.length;
+  for (let i = 0;i < len; i++) {
+    diff |= (a.charCodeAt(i) || 0) ^ (b.charCodeAt(i) || 0);
+  }
+  return diff === 0;
+}
 
 // src/daemon-identity.ts
 function validateClaudeClientIdentity(input) {
-  if (!input.expectedPairId)
-    return { ok: true };
+  if (input.expectedControlToken && input.identity) {
+    const tokenResult = validateControlToken({
+      expectedToken: input.expectedControlToken,
+      providedToken: input.identity.controlToken
+    });
+    if (!tokenResult.ok) {
+      return {
+        ok: false,
+        closeCode: CLOSE_CODE_TOKEN_MISMATCH,
+        reason: tokenResult.reason
+      };
+    }
+  }
+  if (!input.expectedPairId) {
+    return input.identity ? validateContractVersion(input) : { ok: true };
+  }
   if (!input.identity) {
     return input.allowIdentityless ? { ok: true } : { ok: false, closeCode: CLOSE_CODE_PAIR_MISMATCH, reason: "missing client identity" };
   }
@@ -2213,10 +2626,43 @@ function validateClaudeClientIdentity(input) {
       reason: `cwd mismatch: expected ${input.daemonCwd}, got ${input.identity.cwd ?? "<none>"}`
     };
   }
+  return validateContractVersion(input);
+}
+function validateContractVersion(input) {
+  if (input.expectedContractVersion === undefined)
+    return { ok: true };
+  const provided = input.identity?.contractVersion;
+  if (provided === undefined || provided === null) {
+    return {
+      ok: false,
+      closeCode: CLOSE_CODE_CONTRACT_MISMATCH,
+      reason: `missing contract version: daemon speaks contract v${input.expectedContractVersion}`
+    };
+  }
+  if (provided !== input.expectedContractVersion) {
+    return {
+      ok: false,
+      closeCode: CLOSE_CODE_CONTRACT_MISMATCH,
+      reason: `contract version mismatch: daemon v${input.expectedContractVersion}, client v${provided}`
+    };
+  }
   return { ok: true };
 }
+function evaluateInjectionAttachGuard(attachedSocket, requestingSocket) {
+  if (attachedSocket != null && attachedSocket === requestingSocket) {
+    return { allowed: true };
+  }
+  return {
+    allowed: false,
+    code: "not_attached",
+    reason: "This socket is not the attached Claude session. Send `claude_connect` " + "(with a valid control token) and win the attach slot before injecting a turn."
+  };
+}
 
 // src/message-filter.ts
+import { randomUUID as randomUUID3 } from "crypto";
+var STATUS_SUMMARY_SALT = randomUUID3().slice(0, 8);
+var statusSummaryCounter = 0;
 var MARKER_REGEX = /^\s*\[(IMPORTANT|STATUS|FYI)\]\s*/i;
 function parseMarker(content) {
   const match = content.match(MARKER_REGEX);
@@ -2242,6 +2688,37 @@ function classifyMessage(content, mode) {
       return { action: "forward", marker };
   }
 }
+function routeCodexMessage(content, ctx) {
+  const result = classifyMessage(content, ctx.mode);
+  if (ctx.replyArmed) {
+    return {
+      action: "forward",
+      marker: result.marker,
+      reason: "force-forward-reply-required",
+      flushStatusBuffer: true,
+      noteReplyForwarded: true
+    };
+  }
+  if (ctx.inAttentionWindow && result.marker === "status") {
+    return {
+      action: "buffer",
+      marker: result.marker,
+      reason: "buffer-attention"
+    };
+  }
+  if (result.action === "forward" && result.marker === "important") {
+    return {
+      ...result,
+      reason: "forward",
+      flushStatusBuffer: true,
+      startAttentionWindow: true
+    };
+  }
+  return {
+    ...result,
+    reason: result.action
+  };
+}
 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.`;
@@ -2251,11 +2728,14 @@ class StatusBuffer {
   flushTimer = null;
   flushThreshold;
   flushTimeoutMs;
+  maxBuffered;
   paused = false;
+  droppedCount = 0;
   constructor(onFlush, options) {
     this.onFlush = onFlush;
     this.flushThreshold = options?.flushThreshold ?? 3;
     this.flushTimeoutMs = options?.flushTimeoutMs ?? 15000;
+    this.maxBuffered = options?.maxBuffered ?? 200;
   }
   get size() {
     return this.buffer.length;
@@ -2275,6 +2755,10 @@ class StatusBuffer {
   }
   add(message) {
     this.buffer.push(message);
+    while (this.buffer.length > this.maxBuffered) {
+      this.buffer.shift();
+      this.droppedCount++;
+    }
     if (this.paused)
       return;
     this.resetTimer();
@@ -2289,19 +2773,22 @@ class StatusBuffer {
     const combined = this.buffer.map((m) => parseMarker(m.content).body).join(`
 ---
 `);
+    const droppedNote = this.droppedCount > 0 ? `, ${this.droppedCount} older dropped` : "";
     const summary = {
-      id: `status_summary_${Date.now()}`,
+      id: `status_summary_${STATUS_SUMMARY_SALT}_${++statusSummaryCounter}`,
       source: "codex",
-      content: `[STATUS summary \u2014 ${this.buffer.length} update(s), flushed: ${reason}]
+      content: `[STATUS summary \u2014 ${this.buffer.length} update(s)${droppedNote}, flushed: ${reason}]
 ${combined}`,
       timestamp: Date.now()
     };
     this.onFlush(summary);
     this.buffer = [];
+    this.droppedCount = 0;
   }
   dispose() {
     this.clearTimer();
     this.buffer = [];
+    this.droppedCount = 0;
   }
   clearTimer() {
     if (this.flushTimer) {
@@ -2398,7 +2885,7 @@ class TuiConnectionState {
 
 // src/daemon-lifecycle.ts
 import { spawn as spawn2 } from "child_process";
-import { existsSync as existsSync3, readFileSync, statSync as statSync2, unlinkSync as unlinkSync2, writeFileSync, openSync, closeSync, constants } from "fs";
+import { existsSync as existsSync3, readFileSync as readFileSync3, statSync as statSync2, unlinkSync as unlinkSync3, writeFileSync as writeFileSync2, openSync as openSync2, closeSync as closeSync2, constants } from "fs";
 import { fileURLToPath } from "url";
 
 // src/process-lifecycle.ts
@@ -2442,6 +2929,8 @@ var DAEMON_ENTRY = process.env.AGENTBRIDGE_DAEMON_ENTRY || DEFAULT_DAEMON_ENTRY;
 var DAEMON_PATH = fileURLToPath(new URL(DAEMON_ENTRY, import.meta.url));
 var REUSE_READY_RETRIES = parsePositiveIntEnv("AGENTBRIDGE_REUSE_READY_RETRIES", 12);
 var REUSE_READY_DELAY_MS = 250;
+var WAIT_READY_RETRIES = 40;
+var WAIT_READY_DELAY_MS = 250;
 var HEALTH_FETCH_TIMEOUT_MS = 500;
 var LOCK_IDENTITY_GRACE_MS = parsePositiveIntEnv("AGENTBRIDGE_LOCK_IDENTITY_GRACE_MS", 120000);
 function isReuseVerdict(verdict) {
@@ -2479,22 +2968,33 @@ function classifyDaemon(expectedPairId, status, buildInfo) {
         reason: "runtime build drift has a compatible contract and a live Codex TUI is attached"
       };
     }
+    const basis = runtimeContractComparisonBasis(status.build, buildInfo) === "codeHash" ? "compared by codeHash" : "compared by commit stamp; legacy build without codeHash";
     return {
       verdict: "replace-drifted",
-      reason: `runtime build ${formatBuildInfo(status.build)} does not match launcher ${formatBuildInfo(buildInfo)}`
+      reason: `runtime build ${formatBuildInfo(status.build)} does not match launcher ` + `${formatBuildInfo(buildInfo)} (${basis})`
     };
   }
   return { verdict: "reuse", reason: "daemon pair and runtime contract match" };
 }
+function resolveTiming(timing) {
+  return {
+    reuseReadyRetries: timing?.reuseReadyRetries ?? REUSE_READY_RETRIES,
+    reuseReadyDelayMs: timing?.reuseReadyDelayMs ?? REUSE_READY_DELAY_MS,
+    waitReadyRetries: timing?.waitReadyRetries ?? WAIT_READY_RETRIES,
+    waitReadyDelayMs: timing?.waitReadyDelayMs ?? WAIT_READY_DELAY_MS
+  };
+}
 
 class DaemonLifecycle {
   stateDir;
   controlPort;
   log;
+  timing;
   constructor(opts) {
     this.stateDir = opts.stateDir;
     this.controlPort = opts.controlPort;
     this.log = opts.log;
+    this.timing = resolveTiming(opts.timing);
   }
   get healthUrl() {
     return `http://127.0.0.1:${this.controlPort}/healthz`;
@@ -2551,7 +3051,7 @@ class DaemonLifecycle {
           break;
       }
       try {
-        await this.waitForReady(REUSE_READY_RETRIES, REUSE_READY_DELAY_MS);
+        await this.waitForReady(this.timing.reuseReadyRetries, this.timing.reuseReadyDelayMs);
         return;
       } catch {
         this.log(`Daemon on control port ${this.controlPort} is healthy but not ready within reuse window \u2014 replacing`);
@@ -2564,7 +3064,7 @@ class DaemonLifecycle {
       if (isProcessAlive(existingPid)) {
         if (isAgentBridgeDaemon(existingPid)) {
           try {
-            await this.waitForReady(REUSE_READY_RETRIES, REUSE_READY_DELAY_MS);
+            await this.waitForReady(this.timing.reuseReadyRetries, this.timing.reuseReadyDelayMs);
             return;
           } catch {
             this.log(`Existing daemon process ${existingPid} never became ready \u2014 replacing`);
@@ -2592,7 +3092,7 @@ class DaemonLifecycle {
           await this.kill(3000, status?.pid);
         } else {
           try {
-            await this.waitForReady(REUSE_READY_RETRIES, REUSE_READY_DELAY_MS);
+            await this.waitForReady(this.timing.reuseReadyRetries, this.timing.reuseReadyDelayMs);
             return;
           } catch {
             this.log(`Daemon on control port ${this.controlPort} is healthy but not ready under startup lock \u2014 replacing`);
@@ -2601,7 +3101,7 @@ class DaemonLifecycle {
         }
       }
       this.launch();
-      await this.waitForReady();
+      await this.waitForReady(this.timing.waitReadyRetries, this.timing.waitReadyDelayMs);
     });
   }
   async isHealthy() {
@@ -2628,7 +3128,7 @@ class DaemonLifecycle {
       return false;
     }
   }
-  async waitForReady(maxRetries = 40, delayMs = 250) {
+  async waitForReady(maxRetries = WAIT_READY_RETRIES, delayMs = WAIT_READY_DELAY_MS) {
     for (let attempt = 0;attempt < maxRetries; attempt++) {
       if (await this.isReady())
         return;
@@ -2636,7 +3136,7 @@ class DaemonLifecycle {
     }
     throw new Error(`Timed out waiting for AgentBridge daemon readiness on ${this.readyUrl}`);
   }
-  async waitForReadyAndOurs(maxRetries = 40, delayMs = 250) {
+  async waitForReadyAndOurs(maxRetries = WAIT_READY_RETRIES, delayMs = WAIT_READY_DELAY_MS) {
     for (let attempt = 0;attempt < maxRetries; attempt++) {
       if (await this.isReady()) {
         const status = await this.fetchStatus();
@@ -2652,22 +3152,35 @@ class DaemonLifecycle {
     }
     throw new Error(`Timed out waiting for AgentBridge daemon readiness+identity on ${this.readyUrl} (control port ${this.controlPort})`);
   }
+  readDaemonRecord() {
+    return readUnifiedDaemonRecord({
+      daemonRecordFile: this.stateDir.daemonRecordFile,
+      pidFile: this.stateDir.pidFile,
+      statusFile: this.stateDir.statusFile
+    });
+  }
+  writeDaemonRecord(record) {
+    writeDaemonRecord(this.stateDir.daemonRecordFile, record);
+  }
+  removeDaemonRecord() {
+    try {
+      unlinkSync3(this.stateDir.daemonRecordFile);
+    } catch {}
+  }
   readStatus() {
     try {
-      const raw = readFileSync(this.stateDir.statusFile, "utf-8");
+      const raw = readFileSync3(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");
+    atomicWriteJson(this.stateDir.statusFile, status);
   }
   readPid() {
     try {
-      const raw = readFileSync(this.stateDir.pidFile, "utf-8").trim();
+      const raw = readFileSync3(this.stateDir.pidFile, "utf-8").trim();
       if (!raw)
         return null;
       const pid = Number.parseInt(raw, 10);
@@ -2677,28 +3190,27 @@ class DaemonLifecycle {
     }
   }
   writePid(pid) {
-    this.stateDir.ensure();
-    writeFileSync(this.stateDir.pidFile, `${pid ?? process.pid}
-`, "utf-8");
+    atomicWriteText(this.stateDir.pidFile, `${pid ?? process.pid}
+`);
   }
   removePidFile() {
     try {
-      unlinkSync2(this.stateDir.pidFile);
+      unlinkSync3(this.stateDir.pidFile);
     } catch {}
   }
   removeStatusFile() {
     try {
-      unlinkSync2(this.stateDir.statusFile);
+      unlinkSync3(this.stateDir.statusFile);
     } catch {}
   }
   markKilled() {
     this.stateDir.ensure();
-    writeFileSync(this.stateDir.killedFile, `${Date.now()}
+    writeFileSync2(this.stateDir.killedFile, `${Date.now()}
 `, "utf-8");
   }
   clearKilled() {
     try {
-      unlinkSync2(this.stateDir.killedFile);
+      unlinkSync3(this.stateDir.killedFile);
     } catch {}
   }
   wasKilled() {
@@ -2720,8 +3232,10 @@ class DaemonLifecycle {
     daemonProc.unref();
   }
   removeStalePidFile() {
-    this.log("Removing stale pid file");
+    this.log("Removing stale daemon identity files");
     this.removePidFile();
+    this.removeStatusFile();
+    this.removeDaemonRecord();
   }
   async replaceUnhealthyDaemon(statusPid) {
     await this.withStartupLockStrict(async (locked) => {
@@ -2737,7 +3251,7 @@ class DaemonLifecycle {
         }
         if (isReuseVerdict(classification.verdict)) {
           try {
-            await this.waitForReady(REUSE_READY_RETRIES, REUSE_READY_DELAY_MS);
+            await this.waitForReady(this.timing.reuseReadyRetries, this.timing.reuseReadyDelayMs);
             return;
           } catch {}
         }
@@ -2745,12 +3259,12 @@ class DaemonLifecycle {
       this.log(`Killing unhealthy daemon on control port ${this.controlPort} and relaunching`);
       await this.kill(3000, statusPid);
       this.launch();
-      await this.waitForReady();
+      await this.waitForReady(this.timing.waitReadyRetries, this.timing.waitReadyDelayMs);
     });
   }
   async waitForContendedStartupLock() {
     this.log("Another process holds the startup lock, waiting for readiness+identity...");
-    await this.waitForReadyAndOurs();
+    await this.waitForReadyAndOurs(this.timing.waitReadyRetries, this.timing.waitReadyDelayMs);
   }
   async withStartupLockStrict(fn) {
     const locked = this.acquireLockStrict();
@@ -2765,15 +3279,15 @@ class DaemonLifecycle {
     this.stateDir.ensure();
     let fd = null;
     try {
-      fd = openSync(this.stateDir.lockFile, constants.O_CREAT | constants.O_EXCL | constants.O_WRONLY);
-      writeFileSync(fd, `${process.pid}
+      fd = openSync2(this.stateDir.lockFile, constants.O_CREAT | constants.O_EXCL | constants.O_WRONLY);
+      writeFileSync2(fd, `${process.pid}
 `);
-      closeSync(fd);
+      closeSync2(fd);
       return true;
     } catch (err) {
       if (fd !== null && err.code !== "EEXIST") {
         try {
-          closeSync(fd);
+          closeSync2(fd);
         } catch {}
         this.releaseLock();
       }
@@ -2781,7 +3295,7 @@ class DaemonLifecycle {
         if (reclaimed)
           return false;
         try {
-          const holderPid = Number.parseInt(readFileSync(this.stateDir.lockFile, "utf-8").trim(), 10);
+          const holderPid = Number.parseInt(readFileSync3(this.stateDir.lockFile, "utf-8").trim(), 10);
           if (Number.isFinite(holderPid) && !isProcessAlive(holderPid)) {
             this.log(`Stale startup lock from dead process ${holderPid}, reclaiming`);
             this.releaseLock();
@@ -2810,7 +3324,7 @@ class DaemonLifecycle {
   }
   releaseLock() {
     try {
-      unlinkSync2(this.stateDir.lockFile);
+      unlinkSync3(this.stateDir.lockFile);
     } catch {}
   }
   async kill(gracefulTimeoutMs = 3000, pidOverride) {
@@ -2856,6 +3370,7 @@ class DaemonLifecycle {
   cleanup() {
     this.removePidFile();
     this.removeStatusFile();
+    this.removeDaemonRecord();
   }
 }
 async function fetchWithTimeout(url, timeoutMs = HEALTH_FETCH_TIMEOUT_MS) {
@@ -2869,8 +3384,8 @@ async function fetchWithTimeout(url, timeoutMs = HEALTH_FETCH_TIMEOUT_MS) {
 }
 
 // src/config-service.ts
-import { readFileSync as readFileSync2, writeFileSync as writeFileSync2, mkdirSync as mkdirSync3, existsSync as existsSync4 } from "fs";
-import { join as join3 } from "path";
+import { readFileSync as readFileSync4, mkdirSync as mkdirSync4, existsSync as existsSync4 } from "fs";
+import { join as join4 } from "path";
 var DEFAULT_BUDGET_CONFIG = {
   enabled: true,
   pollSeconds: 300,
@@ -3041,13 +3556,13 @@ function normalizeConfig(raw) {
   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)
+      appPort: normalizeBoundedInteger(codex.appPort ?? daemon.port, DEFAULT_CONFIG.codex.appPort, 1, 65535),
+      proxyPort: normalizeBoundedInteger(codex.proxyPort ?? daemon.proxyPort, DEFAULT_CONFIG.codex.proxyPort, 1, 65535)
     },
     turnCoordination: {
-      attentionWindowSeconds: normalizeInteger(turnCoordination.attentionWindowSeconds, DEFAULT_CONFIG.turnCoordination.attentionWindowSeconds)
+      attentionWindowSeconds: normalizeBoundedInteger(turnCoordination.attentionWindowSeconds, DEFAULT_CONFIG.turnCoordination.attentionWindowSeconds, 0, Number.MAX_SAFE_INTEGER)
     },
-    idleShutdownSeconds: normalizeInteger(config.idleShutdownSeconds, DEFAULT_CONFIG.idleShutdownSeconds),
+    idleShutdownSeconds: normalizeBoundedInteger(config.idleShutdownSeconds, DEFAULT_CONFIG.idleShutdownSeconds, 1, Number.MAX_SAFE_INTEGER),
     budget: normalizeBudgetConfig(config.budget)
   };
 }
@@ -3057,8 +3572,8 @@ class ConfigService {
   configPath;
   constructor(projectRoot) {
     const root = projectRoot ?? process.cwd();
-    this.configDir = join3(root, CONFIG_DIR);
-    this.configPath = join3(this.configDir, CONFIG_FILE);
+    this.configDir = join4(root, CONFIG_DIR);
+    this.configPath = join4(this.configDir, CONFIG_FILE);
   }
   hasConfig() {
     return existsSync4(this.configPath);
@@ -3066,7 +3581,7 @@ class ConfigService {
   load() {
     let raw;
     try {
-      raw = readFileSync2(this.configPath, "utf-8");
+      raw = readFileSync4(this.configPath, "utf-8");
     } catch (err) {
       if (err?.code === "ENOENT") {
         return { state: "absent" };
@@ -3119,9 +3634,7 @@ class ConfigService {
     };
   }
   save(config) {
-    this.ensureConfigDir();
-    writeFileSync2(this.configPath, JSON.stringify(config, null, 2) + `
-`, "utf-8");
+    atomicWriteJson(this.configPath, config);
   }
   initDefaults() {
     this.ensureConfigDir();
@@ -3137,11 +3650,32 @@ class ConfigService {
   }
   ensureConfigDir() {
     if (!existsSync4(this.configDir)) {
-      mkdirSync3(this.configDir, { recursive: true });
+      mkdirSync4(this.configDir, { recursive: true });
     }
   }
 }
 
+// src/budget/budget-gate.ts
+function matchingGateReset(usage) {
+  if (!usage)
+    return 0;
+  const windows = [usage.fiveHour, usage.weekly].filter((window) => !!window && window.resetEpoch > 0);
+  const matching = windows.filter((window) => Math.abs(window.util - usage.gateUtil) < 0.0001);
+  const candidates = matching.length > 0 ? matching : windows;
+  if (candidates.length === 0)
+    return 0;
+  return Math.min(...candidates.map((window) => window.resetEpoch));
+}
+function resumeBlockingEpoch(usage, cfg, now) {
+  if (!usage)
+    return 0;
+  if (usage.rateLimitedUntil > now)
+    return usage.rateLimitedUntil;
+  if (usage.gateUtil >= cfg.resumeBelow)
+    return matchingGateReset(usage);
+  return 0;
+}
+
 // src/budget/types.ts
 var STALE_MAX_AGE_SEC = 600;
 
@@ -3166,25 +3700,6 @@ function usageSummary(name, usage) {
     return `${AGENT_LABEL[name]} \u672A\u77E5`;
   return `${AGENT_LABEL[name]} gate=${pct(usage.gateUtil)} warn=${pct(usage.warnUtil)} 5h\u91CD\u7F6E=${formatEpoch(usage.fiveHour?.resetEpoch ?? 0)}`;
 }
-function matchingGateReset(usage) {
-  if (!usage)
-    return 0;
-  const windows = [usage.fiveHour, usage.weekly].filter((window) => !!window && window.resetEpoch > 0);
-  const matching = windows.filter((window) => Math.abs(window.util - usage.gateUtil) < 0.0001);
-  const candidates = matching.length > 0 ? matching : windows;
-  if (candidates.length === 0)
-    return 0;
-  return Math.min(...candidates.map((window) => window.resetEpoch));
-}
-function resumeBlockingEpoch(usage, cfg, now) {
-  if (!usage)
-    return 0;
-  if (usage.rateLimitedUntil > now)
-    return usage.rateLimitedUntil;
-  if (usage.gateUtil >= cfg.resumeBelow)
-    return matchingGateReset(usage);
-  return 0;
-}
 function resumeAfterEpoch(claude, codex, cfg, now) {
   const epochs = [
     resumeBlockingEpoch(claude, cfg, now),
@@ -3367,8 +3882,163 @@ function computeBudgetState(claude, codex, cfg, now) {
   };
 }
 
-// src/budget/budget-coordinator.ts
+// src/budget/budget-fingerprint.ts
 var RESET_FINGERPRINT_BUCKET_SEC = 600;
+var AGENT_LABEL2 = {
+  claude: "Claude",
+  codex: "Codex"
+};
+function pct2(value) {
+  return `${Math.round(value * 10) / 10}%`;
+}
+function formatEpoch2(epoch) {
+  return new Date(epoch * 1000).toISOString().replace("T", " ").replace(/\.\d+Z$/, "Z");
+}
+var INITIAL_FINGERPRINT_STATE = {
+  side: null,
+  fingerprint: null,
+  resumeEpoch: null,
+  reason: null
+};
+function sideToAgents(side) {
+  if (side === "both")
+    return ["claude", "codex"];
+  if (side === "claude")
+    return ["claude"];
+  if (side === "codex")
+    return ["codex"];
+  return [];
+}
+function agentsToSide(agents) {
+  const claude = agents.has("claude");
+  const codex = agents.has("codex");
+  if (claude && codex)
+    return "both";
+  if (claude)
+    return "claude";
+  if (codex)
+    return "codex";
+  return null;
+}
+function shouldEnter(usage, cfg, now) {
+  if (!isDecisionGrade(usage, now))
+    return false;
+  return usage.gateUtil >= cfg.pauseAt;
+}
+function canAgentResume(usage, cfg, now) {
+  if (!isDecisionGrade(usage, now))
+    return false;
+  if (usage.rateLimitedUntil > now)
+    return false;
+  return usage.gateUtil < cfg.resumeBelow;
+}
+function nextActiveSide(prevSide, state, cfg) {
+  const active = new Set(sideToAgents(prevSide));
+  for (const agent of ["claude", "codex"]) {
+    const usage = state.perAgent[agent];
+    if (shouldEnter(usage, cfg, state.now)) {
+      active.add(agent);
+    } else if (active.has(agent) && canAgentResume(usage, cfg, state.now)) {
+      active.delete(agent);
+    }
+  }
+  return agentsToSide(active);
+}
+function activeSideReason(agent, usage, cfg, now) {
+  if (!usage)
+    return `${AGENT_LABEL2[agent]} \u63A2\u6D4B\u6682\u65F6\u4E0D\u53EF\u7528\uFF0C\u4FDD\u6301\u4E0A\u4E00\u8F6E\u9884\u7B97\u5E72\u9884`;
+  if (usage.rateLimitedUntil > now) {
+    return `${AGENT_LABEL2[agent]} \u63A2\u9488\u88AB\u9650\u6D41\u81F3 ${formatEpoch2(usage.rateLimitedUntil)}`;
+  }
+  if (usage.gateUtil >= cfg.pauseAt) {
+    return `${AGENT_LABEL2[agent]} gateUtil ${pct2(usage.gateUtil)} \u2265 pauseAt ${pct2(cfg.pauseAt)}`;
+  }
+  return `${AGENT_LABEL2[agent]} gateUtil ${pct2(usage.gateUtil)} \u5C1A\u672A\u4F4E\u4E8E resumeBelow ${pct2(cfg.resumeBelow)}`;
+}
+function interventionReason(side, state, cfg) {
+  return sideToAgents(side).map((agent) => activeSideReason(agent, state.perAgent[agent], cfg, state.now)).join("\uFF1B");
+}
+function resumeAfterEpoch2(side, state, cfg) {
+  const epochs = sideToAgents(side).map((agent) => resumeBlockingEpoch(state.perAgent[agent], cfg, state.now)).filter((epoch) => epoch > 0);
+  if (epochs.length === 0)
+    return null;
+  return Math.max(...epochs);
+}
+function activeSideProbeUncertain(side, state) {
+  return sideToAgents(side).some((agent) => {
+    const usage = state.perAgent[agent];
+    return usage === null || usage.rateLimitedUntil > state.now || !isDecisionGrade(usage, state.now);
+  });
+}
+function directiveFingerprint(state, activeSide) {
+  const side = activeSide ?? (state.phase === "balance" ? state.drift.lighter ?? "none" : state.pause.side ?? "none");
+  let reset = 0;
+  if (activeSide === "claude") {
+    reset = state.pause.resetEpochs.claude;
+  } else if (activeSide === "codex") {
+    reset = state.pause.resetEpochs.codex;
+  } else if (activeSide === "both") {
+    reset = Math.max(state.pause.resetEpochs.claude, state.pause.resetEpochs.codex);
+  } else if (state.phase === "balance" && state.drift.lighter) {
+    reset = state.perAgent[state.drift.lighter]?.fiveHour?.resetEpoch ?? 0;
+  }
+  const heavier = activeSide ? "" : state.drift.heavier ?? "none";
+  return [
+    activeSide ? "paused" : state.phase,
+    heavier,
+    side,
+    Math.round(reset / RESET_FINGERPRINT_BUCKET_SEC)
+  ].join("|");
+}
+function classifyPoll(prev, state, cfg) {
+  const previousSide = prev.side;
+  const currentSide = nextActiveSide(previousSide, state, cfg);
+  if (currentSide) {
+    const reason = interventionReason(currentSide, state, cfg);
+    const nextResumeRaw = resumeAfterEpoch2(currentSide, state, cfg);
+    const resumeEpoch = previousSide === currentSide ? nextResumeRaw ?? prev.resumeEpoch : nextResumeRaw;
+    const uncertain = previousSide === currentSide && activeSideProbeUncertain(currentSide, state) && prev.fingerprint;
+    const fingerprint2 = uncertain ? prev.fingerprint : directiveFingerprint(state, currentSide);
+    const pauseChanged = !previousSide;
+    const emit = !previousSide || previousSide !== currentSide || fingerprint2 !== prev.fingerprint;
+    return {
+      next: { side: currentSide, fingerprint: fingerprint2, resumeEpoch, reason },
+      effect: {
+        kind: uncertain ? "hold-uncertain" : "enter",
+        side: currentSide,
+        reason,
+        resumeEpoch,
+        emit,
+        pauseChanged
+      }
+    };
+  }
+  if (previousSide) {
+    return {
+      next: { side: null, fingerprint: null, resumeEpoch: null, reason: null },
+      effect: { kind: "exit", previousSide }
+    };
+  }
+  if (!isDecisionGrade(state.perAgent.claude, state.now) || !isDecisionGrade(state.perAgent.codex, state.now)) {
+    return { next: prev, effect: { kind: "none" } };
+  }
+  if (!state.directiveToClaude) {
+    return {
+      next: { side: null, fingerprint: null, resumeEpoch: null, reason: null },
+      effect: { kind: "none" }
+    };
+  }
+  const fingerprint = directiveFingerprint(state);
+  if (fingerprint !== prev.fingerprint) {
+    return {
+      next: { side: null, fingerprint, resumeEpoch: null, reason: null },
+      effect: { kind: "advise", phase: state.phase }
+    };
+  }
+  return { next: prev, effect: { kind: "none" } };
+}
+
+// src/budget/budget-coordinator.ts
 var LOW_UTIL_PCT = 50;
 var NEAR_PAUSE_MARGIN_PCT = 10;
 var NEAR_WARN_UTIL_PCT = 75;
@@ -3386,27 +4056,17 @@ var REAL_BUDGET_POLL_SCHEDULER = {
     clearTimeout(timer);
   }
 };
-var AGENT_LABEL2 = {
+var AGENT_LABEL3 = {
   claude: "Claude",
   codex: "Codex"
 };
-function pct2(value) {
+function pct3(value) {
   return `${Math.round(value * 10) / 10}%`;
 }
 function usageLine(agent, usage) {
   if (!usage)
-    return `${AGENT_LABEL2[agent]} \u672A\u77E5`;
-  return `${AGENT_LABEL2[agent]} gate=${pct2(usage.gateUtil)} warn=${pct2(usage.warnUtil)}`;
-}
-function matchingGateReset2(usage) {
-  if (!usage)
-    return 0;
-  const windows = [usage.fiveHour, usage.weekly].filter((window) => !!window && window.resetEpoch > 0);
-  const matching = windows.filter((window) => Math.abs(window.util - usage.gateUtil) < 0.0001);
-  const candidates = matching.length > 0 ? matching : windows;
-  if (candidates.length === 0)
-    return 0;
-  return Math.min(...candidates.map((window) => window.resetEpoch));
+    return `${AGENT_LABEL3[agent]} \u672A\u77E5`;
+  return `${AGENT_LABEL3[agent]} gate=${pct3(usage.gateUtil)} warn=${pct3(usage.warnUtil)}`;
 }
 function maxPollDelayMs(config) {
   return Math.max(0, config.pollSeconds * 1000);
@@ -3463,16 +4123,14 @@ class BudgetCoordinator {
   config;
   emit;
   onPauseChange;
+  onSnapshot;
   now;
   scheduler;
   log;
   timer = null;
   running = false;
-  activeSides = new Set;
-  lastDirectiveFingerprint = null;
+  fpState = INITIAL_FINGERPRINT_STATE;
   latestSnapshot = null;
-  pauseReason = null;
-  pauseResumeAfterEpoch = null;
   pendingOverrideTier = null;
   pendingOverrides = null;
   lastAppliedTier = "full";
@@ -3483,6 +4141,7 @@ class BudgetCoordinator {
     this.config = options.config;
     this.emit = options.emit;
     this.onPauseChange = options.onPauseChange;
+    this.onSnapshot = options.onSnapshot ?? (() => {});
     this.now = options.now ?? (() => Math.floor(Date.now() / 1000));
     this.scheduler = options.scheduler ?? REAL_BUDGET_POLL_SCHEDULER;
     this.log = options.log ?? (() => {});
@@ -3503,10 +4162,10 @@ class BudgetCoordinator {
     }
   }
   isPaused() {
-    return this.activeSides.size > 0;
+    return this.fpState.side !== null;
   }
   isGateClosed() {
-    return this.activeSides.has("codex");
+    return this.fpState.side === "codex" || this.fpState.side === "both";
   }
   getSnapshot() {
     return this.latestSnapshot;
@@ -3560,7 +4219,7 @@ class BudgetCoordinator {
     }
     if (!usage) {
       if (!this.isPaused())
-        this.latestSnapshot = null;
+        this.setSnapshot(null);
       return;
     }
     if (!this.running) {
@@ -3569,85 +4228,39 @@ class BudgetCoordinator {
     const state = computeBudgetState(usage.claude, usage.codex, this.config, this.now());
     this.updatePendingOverrides(state.effort.codexTier);
     this.applyState(state);
-    this.latestSnapshot = this.toSnapshot(state);
+    this.setSnapshot(this.toSnapshot(state));
+  }
+  setSnapshot(snapshot) {
+    this.latestSnapshot = snapshot;
+    this.onSnapshot(snapshot);
   }
   applyState(state) {
-    const previousSide = this.pauseSide();
-    this.updateActiveSides(state);
-    const currentSide = this.pauseSide();
-    if (currentSide) {
-      this.pauseReason = this.interventionReason(state);
-      const nextResumeAfterEpoch = this.resumeAfterEpoch(state);
-      this.pauseResumeAfterEpoch = previousSide === currentSide ? nextResumeAfterEpoch ?? this.pauseResumeAfterEpoch : nextResumeAfterEpoch;
-      const fingerprint2 = previousSide === currentSide && this.activeSideProbeUncertain(state) && this.lastDirectiveFingerprint ? this.lastDirectiveFingerprint : this.directiveFingerprint(state, currentSide);
-      if (!previousSide) {
-        this.onPauseChange(true);
+    const { next, effect } = classifyPoll(this.fpState, state, this.config);
+    this.fpState = next;
+    switch (effect.kind) {
+      case "enter":
+      case "hold-uncertain": {
+        if (effect.pauseChanged)
+          this.onPauseChange(true);
+        if (effect.emit) {
+          this.emitDirective(this.interventionPrefix(effect.side), this.interventionDirective(state, effect.side, effect.reason, effect.resumeEpoch));
+        }
+        return;
       }
-      if (!previousSide || previousSide !== currentSide || fingerprint2 !== this.lastDirectiveFingerprint) {
-        this.emitDirective(this.interventionPrefix(currentSide), this.interventionDirective(state, currentSide));
+      case "exit": {
+        this.onPauseChange(false);
+        this.emitDirective(this.recoveryPrefix(effect.previousSide), this.recoveryDirective(state, effect.previousSide));
+        return;
       }
-      this.lastDirectiveFingerprint = fingerprint2;
-      return;
-    }
-    if (previousSide) {
-      this.pauseReason = null;
-      this.pauseResumeAfterEpoch = null;
-      this.lastDirectiveFingerprint = null;
-      this.onPauseChange(false);
-      this.emitDirective(this.recoveryPrefix(previousSide), this.recoveryDirective(state, previousSide));
-      return;
-    }
-    if (!isDecisionGrade(state.perAgent.claude, state.now) || !isDecisionGrade(state.perAgent.codex, state.now)) {
-      return;
-    }
-    if (!state.directiveToClaude) {
-      this.lastDirectiveFingerprint = null;
-      return;
-    }
-    const fingerprint = this.directiveFingerprint(state);
-    if (fingerprint !== this.lastDirectiveFingerprint) {
-      const prefix = state.phase === "balance" ? "system_budget_balance" : "system_budget_parallel";
-      this.emitDirective(prefix, state.directiveToClaude);
-      this.lastDirectiveFingerprint = fingerprint;
-    }
-  }
-  updateActiveSides(state) {
-    for (const agent of ["claude", "codex"]) {
-      const usage = state.perAgent[agent];
-      if (this.shouldEnter(usage, state.now)) {
-        this.activeSides.add(agent);
-      } else if (this.activeSides.has(agent) && this.canAgentResume(usage, state.now)) {
-        this.activeSides.delete(agent);
+      case "advise": {
+        const prefix = effect.phase === "balance" ? "system_budget_balance" : "system_budget_parallel";
+        this.emitDirective(prefix, state.directiveToClaude);
+        return;
       }
+      case "none":
+        return;
     }
   }
-  shouldEnter(usage, now) {
-    if (!isDecisionGrade(usage, now))
-      return false;
-    return usage.gateUtil >= this.config.pauseAt;
-  }
-  canAgentResume(usage, now) {
-    if (!isDecisionGrade(usage, now))
-      return false;
-    if (usage.rateLimitedUntil > now)
-      return false;
-    return usage.gateUtil < this.config.resumeBelow;
-  }
-  resumeAfterEpoch(state) {
-    const epochs = ["claude", "codex"].filter((agent) => this.activeSides.has(agent)).map((agent) => this.resumeBlockingEpoch(state.perAgent[agent], state.now)).filter((epoch) => epoch > 0);
-    if (epochs.length === 0)
-      return null;
-    return Math.max(...epochs);
-  }
-  resumeBlockingEpoch(usage, now) {
-    if (!usage)
-      return 0;
-    if (usage.rateLimitedUntil > now)
-      return usage.rateLimitedUntil;
-    if (usage.gateUtil >= this.config.resumeBelow)
-      return matchingGateReset2(usage);
-    return 0;
-  }
   tierControlEnabled() {
     if (!this.config.codexTierControl)
       return false;
@@ -3681,82 +4294,24 @@ class BudgetCoordinator {
     this.pendingOverrideTier = tier;
     this.pendingOverrides = { ...overrides };
   }
-  directiveFingerprint(state, activeSide) {
-    const side = activeSide ?? (state.phase === "balance" ? state.drift.lighter ?? "none" : state.pause.side ?? "none");
-    let reset = 0;
-    if (activeSide === "claude") {
-      reset = state.pause.resetEpochs.claude;
-    } else if (activeSide === "codex") {
-      reset = state.pause.resetEpochs.codex;
-    } else if (activeSide === "both") {
-      reset = Math.max(state.pause.resetEpochs.claude, state.pause.resetEpochs.codex);
-    } else if (state.phase === "balance" && state.drift.lighter) {
-      reset = state.perAgent[state.drift.lighter]?.fiveHour?.resetEpoch ?? 0;
-    } else if (side === "claude") {
-      reset = state.pause.resetEpochs.claude;
-    } else if (side === "codex") {
-      reset = state.pause.resetEpochs.codex;
-    } else if (side === "both") {
-      reset = Math.max(state.pause.resetEpochs.claude, state.pause.resetEpochs.codex);
-    }
-    return [
-      activeSide ? "paused" : state.phase,
-      state.drift.heavier ?? "none",
-      side,
-      Math.round(reset / RESET_FINGERPRINT_BUCKET_SEC)
-    ].join("|");
-  }
   emitDirective(prefix, content) {
     this.emit(`${prefix}_${this.sequence++}`, content);
   }
-  pauseSide() {
-    const claude = this.activeSides.has("claude");
-    const codex = this.activeSides.has("codex");
-    if (claude && codex)
-      return "both";
-    if (claude)
-      return "claude";
-    if (codex)
-      return "codex";
-    return null;
-  }
   interventionPrefix(side) {
     return side === "claude" ? "system_budget_handoff" : "system_budget_pause";
   }
   recoveryPrefix(previousSide) {
     return previousSide === "claude" ? "system_budget_claude_recovered" : "system_budget_resume";
   }
-  interventionDirective(state, side) {
-    return renderBudgetInterventionDirective(state.perAgent.claude, state.perAgent.codex, side, this.pauseReason ?? "\u9884\u7B97\u63A5\u8FD1\u8017\u5C3D", this.pauseResumeAfterEpoch, this.config);
-  }
-  interventionReason(state) {
-    return ["claude", "codex"].filter((agent) => this.activeSides.has(agent)).map((agent) => this.activeSideReason(agent, state.perAgent[agent], state.now)).join("\uFF1B");
-  }
-  activeSideProbeUncertain(state) {
-    return ["claude", "codex"].some((agent) => {
-      if (!this.activeSides.has(agent))
-        return false;
-      const usage = state.perAgent[agent];
-      return usage === null || usage.rateLimitedUntil > state.now || !isDecisionGrade(usage, state.now);
-    });
-  }
-  activeSideReason(agent, usage, now) {
-    if (!usage)
-      return `${AGENT_LABEL2[agent]} \u63A2\u6D4B\u6682\u65F6\u4E0D\u53EF\u7528\uFF0C\u4FDD\u6301\u4E0A\u4E00\u8F6E\u9884\u7B97\u5E72\u9884`;
-    if (usage.rateLimitedUntil > now) {
-      return `${AGENT_LABEL2[agent]} \u63A2\u9488\u88AB\u9650\u6D41\u81F3 ${this.formatEpoch(usage.rateLimitedUntil)}`;
-    }
-    if (usage.gateUtil >= this.config.pauseAt) {
-      return `${AGENT_LABEL2[agent]} gateUtil ${pct2(usage.gateUtil)} \u2265 pauseAt ${pct2(this.config.pauseAt)}`;
-    }
-    return `${AGENT_LABEL2[agent]} gateUtil ${pct2(usage.gateUtil)} \u5C1A\u672A\u4F4E\u4E8E resumeBelow ${pct2(this.config.resumeBelow)}`;
+  interventionDirective(state, side, reason, resumeEpoch) {
+    return renderBudgetInterventionDirective(state.perAgent.claude, state.perAgent.codex, side, reason || "\u9884\u7B97\u63A5\u8FD1\u8017\u5C3D", resumeEpoch, this.config);
   }
   recoveryDirective(state, previousSide) {
     if (previousSide === "claude") {
       return [
         "\u3010\u9884\u7B97\u534F\u8C03 \xB7 \u8D26\u53F7\u7EA7\u3011Claude \u4FA7\u9884\u7B97\u5DF2\u6062\u590D\u3002",
         `${usageLine("claude", state.perAgent.claude)}\uFF1B${usageLine("codex", state.perAgent.codex)}\u3002`,
-        `Claude gateUtil \u5DF2\u4F4E\u4E8E ${pct2(this.config.resumeBelow)}\uFF0C\u4E14\u6CA1\u6709\u6709\u6548 rate_limit\u3002`,
+        `Claude gateUtil \u5DF2\u4F4E\u4E8E ${pct3(this.config.resumeBelow)}\uFF0C\u4E14\u6CA1\u6709\u6709\u6548 rate_limit\u3002`,
         "Claude \u53EF\u6062\u590D orchestrator \u89D2\u8272\uFF1B\u540E\u7EED\u5206\u914D\u524D\u8BF7\u91CD\u65B0\u67E5\u8BE2\u5B9E\u65F6\u989D\u5EA6\uFF0C\u4E0D\u8981\u4F9D\u8D56\u65E7\u6570\u5B57\u3002"
       ].join(`
 `);
@@ -3765,7 +4320,7 @@ class BudgetCoordinator {
       return [
         "\u3010\u9884\u7B97\u534F\u8C03 \xB7 \u8D26\u53F7\u7EA7\u3011Codex \u4FA7\u9884\u7B97\u95F8\u95E8\u89E3\u9664\u3002",
         `${usageLine("claude", state.perAgent.claude)}\uFF1B${usageLine("codex", state.perAgent.codex)}\u3002`,
-        `\u95F8\u95E8\u5DF2\u653E\u5F00\uFF1ACodex gateUtil \u4F4E\u4E8E ${pct2(this.config.resumeBelow)}\uFF0C\u4E14\u6CA1\u6709\u6709\u6548 rate_limit\u3002`,
+        `\u95F8\u95E8\u5DF2\u653E\u5F00\uFF1ACodex gateUtil \u4F4E\u4E8E ${pct3(this.config.resumeBelow)}\uFF0C\u4E14\u6CA1\u6709\u6709\u6548 rate_limit\u3002`,
         "\u5EFA\u8BAE Claude \u7528 reply \u5E26\u4E0A\u5F53\u524D\u76EE\u6807\u3001checkpoint \u548C\u4E0B\u4E00\u6B65\uFF0C\u5524\u9192 Codex \u63A5\u7EED\u6267\u884C\u3002"
       ].join(`
 `);
@@ -3773,14 +4328,11 @@ class BudgetCoordinator {
     return [
       "\u3010\u9884\u7B97\u534F\u8C03 \xB7 \u8D26\u53F7\u7EA7\u3011\u8054\u5408\u6682\u505C\u89E3\u9664\u3002",
       `${usageLine("claude", state.perAgent.claude)}\uFF1B${usageLine("codex", state.perAgent.codex)}\u3002`,
-      `\u95F8\u95E8\u5DF2\u653E\u5F00\uFF1A\u53CC\u65B9 gateUtil \u5747\u4F4E\u4E8E ${pct2(this.config.resumeBelow)}\uFF0C\u4E14\u6CA1\u6709\u6709\u6548 rate_limit\u3002`,
+      `\u95F8\u95E8\u5DF2\u653E\u5F00\uFF1A\u53CC\u65B9 gateUtil \u5747\u4F4E\u4E8E ${pct3(this.config.resumeBelow)}\uFF0C\u4E14\u6CA1\u6709\u6709\u6548 rate_limit\u3002`,
       "\u5EFA\u8BAE Claude \u7528 reply \u5E26\u4E0A\u5F53\u524D\u76EE\u6807\u3001checkpoint \u548C\u4E0B\u4E00\u6B65\uFF0C\u5524\u9192 Codex \u63A5\u7EED\u6267\u884C\u3002"
     ].join(`
 `);
   }
-  formatEpoch(epoch) {
-    return new Date(epoch * 1000).toISOString().replace("T", " ").replace(/\.\d+Z$/, "Z");
-  }
   toSnapshot(state) {
     const paused = this.isPaused();
     return {
@@ -3791,9 +4343,9 @@ class BudgetCoordinator {
       driftPct: state.drift.pct,
       paused,
       gateClosed: this.isGateClosed(),
-      pauseSide: this.pauseSide(),
-      pauseReason: paused ? this.pauseReason ?? state.pause.reason : null,
-      resumeAfterEpoch: paused ? this.pauseResumeAfterEpoch ?? state.pause.resumeAfterEpoch : null,
+      pauseSide: this.fpState.side,
+      pauseReason: paused ? this.fpState.reason ?? state.pause.reason : null,
+      resumeAfterEpoch: paused ? this.fpState.resumeEpoch ?? state.pause.resumeAfterEpoch : null,
       parallelRecommended: paused ? false : state.parallel.recommended,
       codexTier: state.effort.codexTier,
       claudeAdvice: state.effort.claudeAdvice
@@ -3805,7 +4357,7 @@ class BudgetCoordinator {
 import { execFile } from "child_process";
 import { existsSync as existsSync5 } from "fs";
 import { homedir as homedir2 } from "os";
-import { basename, join as join4 } from "path";
+import { basename, join as join5 } from "path";
 var DEFAULT_TIMEOUT_MS = 1e4;
 var MAX_BUFFER = 1024 * 1024;
 function defaultRunner(command, args, options) {
@@ -4053,11 +4605,11 @@ class QuotaSource {
       add(command, commandKind(command));
       return candidates;
     }
-    const binDir = join4(this.homeDir, ".budget-guard/bin");
-    const installedBudgetProbe = join4(binDir, "budget-probe");
+    const binDir = join5(this.homeDir, ".budget-guard/bin");
+    const installedBudgetProbe = join5(binDir, "budget-probe");
     if (existsSync5(installedBudgetProbe))
       add(installedBudgetProbe, "budget-probe");
-    const installedProbeMjs = join4(binDir, "probe.mjs");
+    const installedProbeMjs = join5(binDir, "probe.mjs");
     if (existsSync5(installedProbeMjs))
       add(installedProbeMjs, "probe-mjs");
     return candidates;
@@ -4120,6 +4672,27 @@ function createQuotaSource(options) {
   return new QuotaSource(options);
 }
 
+// src/daemon-identity-ownership.ts
+import { readFileSync as readFileSync5 } from "fs";
+var defaultRead2 = (path) => readFileSync5(path, "utf-8");
+function pidFileOwnedByUs(pidFilePath, ourPid, read = defaultRead2) {
+  let raw;
+  try {
+    raw = read(pidFilePath);
+  } catch {
+    return false;
+  }
+  const trimmed = raw.trim();
+  if (trimmed.length === 0)
+    return false;
+  if (!/^[+-]?\d+$/.test(trimmed))
+    return false;
+  const pid = Number.parseInt(trimmed, 10);
+  if (!Number.isFinite(pid))
+    return false;
+  return pid === ourPid;
+}
+
 // src/idempotency-tracker.ts
 var DEFAULT_TOMBSTONE_TTL_MS = 20 * 60 * 1000;
 
@@ -4270,14 +4843,11 @@ class ReplyRequiredTracker {
 // src/thread-state.ts
 import {
   existsSync as existsSync6,
-  mkdirSync as mkdirSync4,
   readdirSync,
-  readFileSync as readFileSync3,
-  renameSync as renameSync2,
-  writeFileSync as writeFileSync3
+  readFileSync as readFileSync6
 } from "fs";
 import { homedir as homedir3 } from "os";
-import { basename as basename2, dirname as dirname2, join as join5 } from "path";
+import { basename as basename2, join as join6 } from "path";
 function nowIso() {
   return new Date().toISOString();
 }
@@ -4286,18 +4856,11 @@ function threadTag(identity) {
   return `abg:${name}:${identity.cwd}`;
 }
 function codexHome(env = process.env) {
-  return env.CODEX_HOME && env.CODEX_HOME.length > 0 ? env.CODEX_HOME : join5(homedir3(), ".codex");
-}
-function atomicWriteJson(path, value) {
-  mkdirSync4(dirname2(path), { recursive: true });
-  const tmp = `${path}.tmp.${process.pid}.${Date.now()}`;
-  writeFileSync3(tmp, JSON.stringify(value, null, 2) + `
-`, "utf-8");
-  renameSync2(tmp, path);
+  return env.CODEX_HOME && env.CODEX_HOME.length > 0 ? env.CODEX_HOME : join6(homedir3(), ".codex");
 }
 function readRawCurrentThread(stateDir) {
   try {
-    const parsed = JSON.parse(readFileSync3(stateDir.currentThreadFile, "utf-8"));
+    const parsed = JSON.parse(readFileSync6(stateDir.currentThreadFile, "utf-8"));
     if (parsed?.version === 1 && typeof parsed.threadId === "string" && parsed.threadId.length > 0 && (parsed.status === "pending" || parsed.status === "current") && typeof parsed.cwd === "string") {
       return parsed;
     }
@@ -4305,7 +4868,7 @@ function readRawCurrentThread(stateDir) {
   return null;
 }
 function findCodexRolloutFile(threadId, env = process.env, maxEntries = 20000) {
-  const sessionsDir = join5(codexHome(env), "sessions");
+  const sessionsDir = join6(codexHome(env), "sessions");
   if (!threadId || !existsSync6(sessionsDir))
     return null;
   const exactName = `rollout-${threadId}.jsonl`;
@@ -4321,7 +4884,7 @@ function findCodexRolloutFile(threadId, env = process.env, maxEntries = 20000) {
     }
     for (const entry of entries) {
       visited++;
-      const path = join5(dir, entry.name);
+      const path = join6(dir, entry.name);
       if (entry.isDirectory()) {
         stack.push(path);
         continue;
@@ -4415,6 +4978,7 @@ function formatWaitingForCodexTuiMessage(options) {
 // src/pair-registry.ts
 var PAIR_BASE_PORT = 4500;
 var PAIR_SLOT_STRIDE = 10;
+var RECLAIMABLE_MIN_AGE_MS = 24 * 60 * 60 * 1000;
 var MAX_PAIR_SLOT = Math.floor((65535 - 2 - PAIR_BASE_PORT) / PAIR_SLOT_STRIDE);
 
 // src/liveness-probe.ts
@@ -4445,10 +5009,55 @@ async function probeLiveness(target, options) {
   return target.pongCount > baseline;
 }
 
+// src/delivery-buffer.ts
+class BoundedMessageBuffer {
+  messages = [];
+  cap;
+  overflowLabel;
+  overflowNoun;
+  log;
+  constructor(options) {
+    this.cap = options.cap;
+    this.overflowLabel = options.overflowLabel;
+    this.overflowNoun = options.overflowNoun ?? "message(s)";
+    this.log = options.log;
+  }
+  get length() {
+    return this.messages.length;
+  }
+  push(message) {
+    this.messages.push(message);
+    this.enforceCap();
+  }
+  unshiftMany(messages) {
+    if (messages.length === 0)
+      return;
+    this.messages.unshift(...messages);
+    this.enforceCap();
+  }
+  drainAll() {
+    return this.messages.splice(0, this.messages.length);
+  }
+  clear() {
+    this.messages.length = 0;
+  }
+  enforceCap() {
+    if (this.messages.length > this.cap) {
+      const dropped = this.messages.length - this.cap;
+      this.messages.splice(0, dropped);
+      this.log(`${this.overflowLabel}: dropped ${dropped} oldest ${this.overflowNoun}, ${this.cap} remaining`);
+    }
+  }
+}
+
 // src/daemon.ts
 var stateDir = new StateDirResolver;
 stateDir.ensure();
 var processLogger = createProcessLogger({ component: "AgentBridgeDaemon", logFile: stateDir.logFile });
+var controlTokenPath = resolveControlTokenPath(stateDir.dir);
+var controlToken = generateControlToken();
+var weWroteToken = false;
+var weWrotePid = false;
 var configService = new ConfigService;
 var config = configService.loadOrDefault(processLogger.log);
 var CODEX_APP_PORT = parseInt(process.env.CODEX_WS_PORT ?? String(config.codex.appPort), 10);
@@ -4465,12 +5074,16 @@ var CODEX_BOOT_RETRIES = parsePositiveIntEnv("AGENTBRIDGE_CODEX_BOOT_RETRIES", 2
 var ALLOW_IDENTITYLESS_CLIENT = process.env.AGENTBRIDGE_COMPAT_IDENTITYLESS === "1";
 var BUDGET_CONFIG = applyBudgetEnvOverrides(config.budget);
 var daemonLifecycle = new DaemonLifecycle({ stateDir, controlPort: CONTROL_PORT, log });
+var DAEMON_NONCE = randomUUID4();
+var DAEMON_STARTED_AT = Date.now();
 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 boundControlPort = false;
 var attachedClaude = null;
 var nextControlClientId = 0;
 var nextSystemMessageId = 0;
+var SYSTEM_MSG_SALT = randomUUID4().slice(0, 8);
 var codexBootstrapped = false;
 var attentionWindowTimer = null;
 var inAttentionWindow = false;
@@ -4488,9 +5101,20 @@ var ATTACH_STATUS_COOLDOWN_MS = 30000;
 var LIVENESS_PROBE_TIMEOUT_MS = parsePositiveIntEnv("AGENTBRIDGE_LIVENESS_PROBE_TIMEOUT_MS", 3000, log);
 var LIVENESS_PROBE_POLL_MS = 50;
 var challengeInProgress = false;
-var bufferedMessages = [];
+var bufferedMessages = new BoundedMessageBuffer({
+  cap: MAX_BUFFERED_MESSAGES,
+  overflowLabel: "Message buffer overflow",
+  log
+});
+function createPendingBackpressureBuffer() {
+  return new BoundedMessageBuffer({
+    cap: MAX_BUFFERED_MESSAGES,
+    overflowLabel: "Backpressure overflow",
+    overflowNoun: "tracked message(s)",
+    log
+  });
+}
 var budgetCoordinator = null;
-var budgetStatusTimer = null;
 function ensureBudgetCoordinatorStarted() {
   if (!BUDGET_CONFIG.enabled)
     return;
@@ -4501,27 +5125,18 @@ function ensureBudgetCoordinatorStarted() {
       config: BUDGET_CONFIG,
       emit: (id, content) => {
         emitToClaude(systemMessage(id, content));
-        queueMicrotask(() => broadcastStatus());
       },
       onPauseChange: (paused) => {
         log(`Budget intervention ${paused ? "ACTIVE" : "CLEARED"} ` + `(gate ${budgetCoordinator?.isGateClosed() ? "CLOSED" : "OPEN"})`);
-        queueMicrotask(() => broadcastStatus());
       },
+      onSnapshot: () => broadcastStatus(),
       log
     });
   }
   budgetCoordinator.start();
-  if (!budgetStatusTimer) {
-    budgetStatusTimer = setInterval(() => broadcastStatus(), BUDGET_CONFIG.pollSeconds * 1000);
-    budgetStatusTimer.unref?.();
-  }
 }
 function stopBudgetCoordinator() {
   budgetCoordinator?.stop();
-  if (budgetStatusTimer) {
-    clearInterval(budgetStatusTimer);
-    budgetStatusTimer = null;
-  }
 }
 function budgetPauseGateError() {
   const snapshot = budgetCoordinator?.getSnapshot() ?? null;
@@ -4625,29 +5240,22 @@ codex.on("turnStarted", () => {
 codex.on("agentMessage", (msg) => {
   if (msg.source !== "codex")
     return;
-  const result = classifyMessage(msg.content, FILTER_MODE);
-  if (replyTracker.isArmed) {
-    log(`Codex \u2192 Claude [${result.marker}/force-forward-reply-required] (${msg.content.length} chars)`);
+  const route = routeCodexMessage(msg.content, {
+    mode: FILTER_MODE,
+    replyArmed: replyTracker.isArmed,
+    inAttentionWindow
+  });
+  log(`Codex \u2192 Claude [${route.marker}/${route.reason}] (${msg.content.length} chars)`);
+  if (route.noteReplyForwarded) {
     replyTracker.noteForwarded();
-    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;
+  if (route.flushStatusBuffer) {
+    statusBuffer.flush(route.noteReplyForwarded ? "reply-required message arrived" : "important message arrived");
   }
-  log(`Codex \u2192 Claude [${result.marker}/${result.action}] (${msg.content.length} chars)`);
-  switch (result.action) {
+  switch (route.action) {
     case "forward":
-      if (result.marker === "important" && statusBuffer.size > 0) {
-        statusBuffer.flush("important message arrived");
-      }
       emitToClaude(msg);
-      if (result.marker === "important") {
+      if (route.startAttentionWindow) {
         startAttentionWindow();
       }
       break;
@@ -4722,6 +5330,7 @@ codex.on("error", (err) => {
 });
 codex.on("exit", (code) => {
   log(`Codex process exited (code ${code})`);
+  const wasBootstrapped = codexBootstrapped;
   codexBootstrapped = false;
   replyTracker.reset();
   idempotencyTracker.terminateAll("aborted");
@@ -4730,65 +5339,77 @@ codex.on("exit", (code) => {
   statusBuffer.flush("codex exited");
   tuiConnectionState.handleCodexExit();
   clearPendingClaudeDisconnect("Codex process exited");
-  emitToClaude(systemMessage("system_codex_exit", `\u26A0\uFE0F Codex app-server exited (code ${code ?? "unknown"}). AgentBridge daemon is still running. ` + `Restart the Codex side (\`agentbridge codex\`); if it does not come back within ` + `${Math.round(BOOTSTRAP_TIMEOUT_MS / 1000)}s the daemon will self-replace so the next launch starts clean.`));
+  if (wasBootstrapped) {
+    emitToClaude(systemMessage("system_codex_exit", `\u26A0\uFE0F Codex app-server exited (code ${code ?? "unknown"}). AgentBridge daemon is still running. ` + `Restart the Codex side (\`agentbridge codex\`); if it does not come back within ` + `${Math.round(BOOTSTRAP_TIMEOUT_MS / 1000)}s the daemon will self-replace so the next launch starts clean.`));
+  }
   broadcastStatus();
-  armBootDeadline();
+  if (wasBootstrapped) {
+    armBootDeadline();
+  }
 });
 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") {
-        if (!isAllowedWsUpgrade(req)) {
-          log("Rejected WS upgrade on control port: Origin header present (possible CSWSH)");
-          return wsOriginRejectedResponse();
+  let server;
+  try {
+    server = Bun.serve({
+      port: CONTROL_PORT,
+      hostname: "127.0.0.1",
+      fetch(req, server2) {
+        const url = new URL(req.url);
+        if (url.pathname === "/healthz") {
+          return Response.json(currentStatus());
         }
-        if (server.upgrade(req, { data: { clientId: 0, attached: false, lastPongAt: Date.now(), pongCount: 0, pendingBackpressure: [] } })) {
-          return;
+        if (url.pathname === "/readyz") {
+          return Response.json(currentStatus(), { status: codexBootstrapped ? 200 : 503 });
         }
-      }
-      return new Response("AgentBridge daemon");
-    },
-    websocket: {
-      idleTimeout: 960,
-      sendPings: true,
-      open: (ws) => {
-        ws.data.clientId = ++nextControlClientId;
-        ws.data.lastPongAt = Date.now();
-        ws.data.pendingBackpressure = [];
-        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");
+        if (url.pathname === "/ws") {
+          if (!isAllowedWsUpgrade(req)) {
+            log("Rejected WS upgrade on control port: Origin header present (possible CSWSH)");
+            return wsOriginRejectedResponse();
+          }
+          if (server2.upgrade(req, { data: { clientId: 0, attached: false, lastPongAt: Date.now(), pongCount: 0, pendingBackpressure: createPendingBackpressureBuffer() } })) {
+            return;
+          }
         }
+        return new Response("AgentBridge daemon");
       },
-      message: (ws, raw) => {
-        handleControlMessage(ws, raw);
-      },
-      pong: (ws) => {
-        ws.data.lastPongAt = Date.now();
-        ws.data.pongCount++;
-      },
-      drain: (ws) => {
-        if (ws.data.pendingBackpressure.length > 0 && ws.getBufferedAmount() === 0) {
-          ws.data.pendingBackpressure = [];
-        }
-        if (ws === attachedClaude && bufferedMessages.length > 0) {
-          flushBufferedMessages(ws);
+      websocket: {
+        idleTimeout: 960,
+        sendPings: true,
+        open: (ws) => {
+          ws.data.clientId = ++nextControlClientId;
+          ws.data.lastPongAt = Date.now();
+          ws.data.pendingBackpressure = createPendingBackpressureBuffer();
+          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);
+        },
+        pong: (ws) => {
+          ws.data.lastPongAt = Date.now();
+          ws.data.pongCount++;
+        },
+        drain: (ws) => {
+          if (ws.data.pendingBackpressure.length > 0 && ws.getBufferedAmount() === 0) {
+            ws.data.pendingBackpressure.clear();
+          }
+          if (ws === attachedClaude && bufferedMessages.length > 0) {
+            flushBufferedMessages(ws);
+          }
         }
       }
-    }
-  });
+    });
+  } catch (err) {
+    log(`Control port ${CONTROL_PORT} bind failed (${err?.code ?? err?.message ?? err}) \u2014 ` + `another daemon owns it; exiting without touching shared identity files`);
+    process.exit(0);
+  }
+  controlServer = server;
+  boundControlPort = true;
 }
 function handleControlMessage(ws, raw) {
   let message;
@@ -4805,7 +5426,9 @@ function handleControlMessage(ws, raw) {
         expectedPairId: process.env.AGENTBRIDGE_PAIR_ID ?? null,
         daemonCwd: process.cwd(),
         identity: message.identity,
-        allowIdentityless: ALLOW_IDENTITYLESS_CLIENT
+        allowIdentityless: ALLOW_IDENTITYLESS_CLIENT,
+        expectedControlToken: controlToken,
+        expectedContractVersion: BUILD_INFO.contractVersion
       });
       if (!admission.ok) {
         log(`Rejecting Claude frontend #${ws.data.clientId}: ${admission.reason}`);
@@ -4884,6 +5507,16 @@ function waitForInterruptOutcome(turnIds) {
   });
 }
 async function handleClaudeToCodex(ws, message) {
+  const attachGuard = evaluateInjectionAttachGuard(attachedClaude, ws);
+  if (!attachGuard.allowed) {
+    log(`Rejecting claude_to_codex from non-attached socket #${ws.data.clientId} ` + `(request ${message.requestId}, attached=${attachedClaude ? "#" + attachedClaude.data.clientId : "none"})`);
+    sendClaudeToCodexResult(ws, message.requestId, {
+      success: false,
+      code: attachGuard.code,
+      error: attachGuard.reason
+    });
+    return;
+  }
   if (message.message.source !== "claude") {
     sendClaudeToCodexResult(ws, message.requestId, {
       success: false,
@@ -4916,8 +5549,8 @@ async function handleClaudeToCodex(ws, message) {
   if (budgetCoordinator?.isGateClosed()) {
     const reason = budgetPauseGateError();
     log(`Injection rejected by budget pause gate`);
-    const resumeAfterEpoch2 = budgetCoordinator?.getSnapshot()?.resumeAfterEpoch ?? null;
-    const retryAfterMs = resumeAfterEpoch2 !== null ? Math.max(0, resumeAfterEpoch2 * 1000 - Date.now()) : undefined;
+    const resumeAfterEpoch3 = budgetCoordinator?.getSnapshot()?.resumeAfterEpoch ?? null;
+    const retryAfterMs = resumeAfterEpoch3 !== null ? Math.max(0, resumeAfterEpoch3 * 1000 - Date.now()) : undefined;
     sendClaudeToCodexResult(ws, message.requestId, {
       success: false,
       code: "budget_paused",
@@ -4999,6 +5632,17 @@ async function handleClaudeToCodex(ws, message) {
       return;
     }
     log("Interrupt reached terminal boundary \u2014 injecting the message as a new turn");
+    const postWaitAttachGuard = evaluateInjectionAttachGuard(attachedClaude, ws);
+    if (!postWaitAttachGuard.allowed) {
+      releaseInterruptKey();
+      log(`Rejecting interrupt-path injection from socket #${ws.data.clientId} that lost the attach ` + `slot during the terminal-boundary wait (request ${message.requestId}, ` + `attached=${attachedClaude ? "#" + attachedClaude.data.clientId : "none"})`);
+      sendClaudeToCodexResult(ws, message.requestId, {
+        success: false,
+        code: "not_attached",
+        error: "The original Claude session disconnected (or was replaced by a newer session) while " + "the interrupt was waiting to take effect. Your message was NOT injected \u2014 this avoids " + "delivering it into a different session's thread. Reconnect and resend if still needed."
+      });
+      return;
+    }
     if (interruptThreadId && codex.activeThreadId !== interruptThreadId) {
       releaseInterruptKey();
     }
@@ -5106,14 +5750,9 @@ function detachClaude(ws, reason) {
   ws.data.attached = false;
   log(`Claude frontend detached (#${ws.data.clientId}, ${reason})`);
   if (ws.data.pendingBackpressure.length > 0) {
-    bufferedMessages.unshift(...ws.data.pendingBackpressure);
-    log(`Re-buffered ${ws.data.pendingBackpressure.length} backpressured message(s) for redelivery on reconnect`);
-    ws.data.pendingBackpressure = [];
-    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`);
-    }
+    const reBuffered = ws.data.pendingBackpressure.drainAll();
+    log(`Re-buffered ${reBuffered.length} backpressured message(s) for redelivery on reconnect`);
+    bufferedMessages.unshiftMany(reBuffered);
   }
   scheduleClaudeDisconnectNotification(ws.data.clientId);
   scheduleIdleShutdown();
@@ -5236,11 +5875,6 @@ function emitToClaude(message) {
     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 {
@@ -5251,11 +5885,6 @@ function trySendBridgeMessage(ws, message) {
     }
     if (typeof result === "number" && result === -1) {
       ws.data.pendingBackpressure.push(message);
-      if (ws.data.pendingBackpressure.length > MAX_BUFFERED_MESSAGES) {
-        const dropped = ws.data.pendingBackpressure.length - MAX_BUFFERED_MESSAGES;
-        ws.data.pendingBackpressure.splice(0, dropped);
-        log(`Backpressure overflow: dropped ${dropped} oldest tracked message(s), ${MAX_BUFFERED_MESSAGES} remaining`);
-      }
     }
     return true;
   } catch (err) {
@@ -5264,11 +5893,11 @@ function trySendBridgeMessage(ws, message) {
   }
 }
 function flushBufferedMessages(ws) {
-  const messages = bufferedMessages.splice(0, bufferedMessages.length);
+  const messages = bufferedMessages.drainAll();
   for (let i = 0;i < messages.length; i++) {
     if (!trySendBridgeMessage(ws, messages[i])) {
       const remaining = messages.slice(i);
-      bufferedMessages.unshift(...remaining);
+      bufferedMessages.unshiftMany(remaining);
       log(`Flush interrupted: re-buffered ${remaining.length} message(s) after send failure`);
       return;
     }
@@ -5312,7 +5941,8 @@ function currentStatus() {
     budget: budgetCoordinator?.getSnapshot() ?? undefined,
     turnInProgress: codex.turnInProgress,
     turnPhase: codex.turnPhase,
-    attentionWindowActive: inAttentionWindow
+    attentionWindowActive: inAttentionWindow,
+    appServerInfo: codex.capturedAppServerInfo
   };
 }
 function currentWaitingMessage() {
@@ -5333,7 +5963,7 @@ function currentReadyMessage() {
 }
 function systemMessage(idPrefix, content) {
   return {
-    id: `${idPrefix}_${++nextSystemMessageId}`,
+    id: `${idPrefix}_${SYSTEM_MSG_SALT}_${++nextSystemMessageId}`,
     source: "codex",
     content,
     timestamp: Date.now()
@@ -5341,9 +5971,47 @@ function systemMessage(idPrefix, content) {
 }
 function writePidFile() {
   daemonLifecycle.writePid();
+  daemonLifecycle.writeDaemonRecord(buildDaemonRecord("booting"));
+  weWrotePid = true;
+}
+function writeControlTokenPostBind() {
+  if (controlToken === null)
+    return;
+  try {
+    writeControlToken(controlTokenPath, controlToken);
+    weWroteToken = true;
+  } catch (err) {
+    controlToken = null;
+    processLogger.log(`Failed to write control token (${controlTokenPath}): ${err?.message ?? err} \u2014 ` + `token layer DISABLED for this daemon (attach guard + Origin guard still active)`);
+  }
 }
 function removePidFile() {
+  if (!weWrotePid || !pidFileOwnedByUs(stateDir.pidFile, process.pid))
+    return;
   daemonLifecycle.removePidFile();
+  daemonLifecycle.removeDaemonRecord();
+}
+function buildDaemonRecord(phase) {
+  return {
+    pid: process.pid,
+    phase,
+    startedAt: DAEMON_STARTED_AT,
+    nonce: DAEMON_NONCE,
+    pairId: process.env.AGENTBRIDGE_PAIR_ID ?? null,
+    cwd: process.cwd(),
+    stateDir: stateDir.dir,
+    proxyUrl: codex.proxyUrl,
+    appServerUrl: codex.appServerUrl,
+    ports: {
+      appPort: portFromUrl(codex.appServerUrl) ?? CODEX_APP_PORT,
+      proxyPort: portFromUrl(codex.proxyUrl) ?? CODEX_PROXY_PORT,
+      controlPort: CONTROL_PORT
+    },
+    build: daemonStatusBuildInfo(),
+    turnInProgress: codex.turnInProgress,
+    turnPhase: codex.turnPhase,
+    attentionWindowActive: inAttentionWindow
+  };
 }
 function writeStatusFile() {
   daemonLifecycle.writeStatus({
@@ -5357,11 +6025,16 @@ function writeStatusFile() {
     build: daemonStatusBuildInfo(),
     turnInProgress: codex.turnInProgress,
     turnPhase: codex.turnPhase,
-    attentionWindowActive: inAttentionWindow
+    attentionWindowActive: inAttentionWindow,
+    appServerInfo: codex.capturedAppServerInfo
   });
+  daemonLifecycle.writeDaemonRecord(buildDaemonRecord("ready"));
 }
 function removeStatusFile() {
+  if (!boundControlPort)
+    return;
   daemonLifecycle.removeStatusFile();
+  daemonLifecycle.removeDaemonRecord();
 }
 function armBootDeadline() {
   if (bootDeadlineTimer)
@@ -5434,20 +6107,41 @@ function shutdown(reason, exitCode = 0) {
   codex.stop();
   removePidFile();
   removeStatusFile();
+  removeControlToken();
   process.exit(exitCode);
 }
+function removeControlToken() {
+  if (!weWroteToken)
+    return;
+  try {
+    rmSync2(controlTokenPath, { force: true });
+  } catch {}
+}
 process.on("SIGINT", () => shutdown("SIGINT"));
 process.on("SIGTERM", () => shutdown("SIGTERM"));
 process.on("exit", () => {
   codex.forceKillAppServerSync();
   removePidFile();
   removeStatusFile();
+  removeControlToken();
 });
 process.on("uncaughtException", (err) => {
-  processLogger.fatal("UNCAUGHT EXCEPTION", err);
+  processLogger.fatal("UNCAUGHT EXCEPTION \u2014 auto-shutting down daemon", err);
+  try {
+    shutdown("uncaught exception", 1);
+  } catch (shutdownErr) {
+    processLogger.fatal("shutdown during uncaughtException failed", shutdownErr);
+  }
+  process.exit(1);
 });
 process.on("unhandledRejection", (reason) => {
-  processLogger.fatal("UNHANDLED REJECTION", reason);
+  processLogger.fatal("UNHANDLED REJECTION \u2014 auto-shutting down daemon", reason);
+  try {
+    shutdown("unhandled rejection", 1);
+  } catch (shutdownErr) {
+    processLogger.fatal("shutdown during unhandledRejection failed", shutdownErr);
+  }
+  process.exit(1);
 });
 function log(msg) {
   processLogger.log(msg);
@@ -5456,7 +6150,8 @@ if (daemonLifecycle.wasKilled()) {
   log("Killed sentinel found \u2014 daemon was intentionally stopped. Exiting immediately.");
   process.exit(0);
 }
-writePidFile();
 startControlServer();
+writePidFile();
+writeControlTokenPostBind();
 armBootDeadline();
 bootCodex();