@raysonmeng/agentbridge 0.1.11 → 0.1.13

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

@@ -6518,7 +6518,7 @@ var require_dist = __commonJS((exports, module) => {
 });
 
 // src/bridge.ts
-import { existsSync as existsSync6 } from "fs";
+import { existsSync as existsSync7 } from "fs";
 
 // node_modules/zod/v4/core/core.js
 var NEVER = Object.freeze({
@@ -13662,19 +13662,21 @@ class StdioServerTransport {
 // src/claude-adapter.ts
 import { EventEmitter } from "events";
 import { randomUUID } from "crypto";
+import { performance } from "perf_hooks";
 
 // src/rotating-log.ts
 import { appendFileSync, existsSync, renameSync, statSync, unlinkSync } from "fs";
 import { dirname } from "path";
 var DEFAULT_MAX_BYTES = 5 * 1024 * 1024;
 var DEFAULT_KEEP = 3;
-function appendRotatingLog(path, content, options = {}) {
+var REAL_FS_OPS = { statSync, renameSync, unlinkSync, appendFileSync, existsSync };
+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 (!existsSync(dirname(path)))
+  if (!fsOps.existsSync(dirname(path)))
     return;
-  rotateIfNeeded(path, Buffer.byteLength(content), maxBytes, keep);
-  appendFileSync(path, content, "utf-8");
+  rotateIfNeeded(path, Buffer.byteLength(content), maxBytes, keep, fsOps);
+  fsOps.appendFileSync(path, content, "utf-8");
 }
 function positiveIntFromEnv(name, fallback) {
   const value = process.env[name];
@@ -13683,26 +13685,48 @@ function positiveIntFromEnv(name, fallback) {
   const parsed = Number(value);
   return Number.isFinite(parsed) && parsed > 0 ? Math.floor(parsed) : fallback;
 }
-function rotateIfNeeded(path, incomingBytes, maxBytes, keep) {
+function isEnoent(error2) {
+  return !!error2 && error2.code === "ENOENT";
+}
+function renameIfPresent(from, to, fsOps) {
+  try {
+    fsOps.renameSync(from, to);
+  } catch (error2) {
+    if (!isEnoent(error2))
+      throw error2;
+  }
+}
+function unlinkIfPresent(path, fsOps) {
+  try {
+    fsOps.unlinkSync(path);
+  } catch (error2) {
+    if (!isEnoent(error2))
+      throw error2;
+  }
+}
+function rotateIfNeeded(path, incomingBytes, maxBytes, keep, fsOps) {
   if (!Number.isFinite(maxBytes) || maxBytes <= 0 || keep <= 0)
     return;
-  if (!existsSync(path))
-    return;
-  const size = statSync(path).size;
+  let size;
+  try {
+    size = fsOps.statSync(path).size;
+  } catch (error2) {
+    if (isEnoent(error2))
+      return;
+    throw error2;
+  }
   if (size + incomingBytes <= maxBytes)
     return;
   for (let index = keep;index >= 1; index--) {
     const current = `${path}.${index}`;
     const next = `${path}.${index + 1}`;
-    if (!existsSync(current))
-      continue;
     if (index === keep) {
-      unlinkSync(current);
+      unlinkIfPresent(current, fsOps);
     } else {
-      renameSync(current, next);
+      renameIfPresent(current, next, fsOps);
     }
   }
-  renameSync(path, `${path}.1`);
+  renameIfPresent(path, `${path}.1`, fsOps);
 }
 
 // src/process-log.ts
@@ -13782,6 +13806,10 @@ function formatError2(error2) {
 import { mkdirSync, existsSync as existsSync2 } 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;
@@ -13789,8 +13817,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;
@@ -13816,8 +13843,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");
@@ -13859,6 +13886,9 @@ function formatAgent(name, usage, snapshotAt) {
   if (usage.rateLimitedUntil > 0) {
     parts.push(`\u9650\u6D41\u81F3 ${formatEpoch(usage.rateLimitedUntil)}`);
   }
+  if (usage.parsedVia === "positional") {
+    parts.push("\u26A0\uFE0F \u7A97\u53E3\u8BC6\u522B\u4F7F\u7528\u4F4D\u7F6E\u515C\u5E95");
+  }
   const ageSec = usage.fetchedAt > 0 ? snapshotAt - usage.fetchedAt : 0;
   if (ageSec > 300) {
     parts.push(`\u26A0\uFE0F \u6570\u636E\u91C7\u96C6\u4E8E ${Math.round(ageSec / 60)} \u5206\u949F\u524D`);
@@ -13917,6 +13947,10 @@ function renderBudgetSnapshot(snapshot) {
 var BUDGET_UNAVAILABLE_TEXT = "\u9884\u7B97\u611F\u77E5\u4E0D\u53EF\u7528\uFF1A\u672A\u68C0\u6D4B\u5230 agent-quota-guard \u63A2\u9488\uFF08~/.budget-guard/bin/budget-probe\uFF09\u6216 budget \u529F\u80FD\u5DF2\u7981\u7528\u3002\u534F\u4F5C\u4E0D\u53D7\u5F71\u54CD\u3002";
 
 // src/claude-adapter.ts
+var DEFAULT_MAX_BUFFERED_MESSAGES = 100;
+var DEFAULT_MAX_BUFFERED_BYTES = 4 * 1024 * 1024;
+var DEFAULT_DEDUPE_CAPACITY = 2048;
+var DEFAULT_DEDUPE_TTL_MS = 20 * 60 * 1000;
 var CLAUDE_INSTRUCTIONS = [
   "Codex is an AI coding agent (OpenAI) running in a separate session on the same machine.",
   "",
@@ -13947,7 +13981,7 @@ var CLAUDE_INSTRUCTIONS = [
   "## Turn coordination",
   "- When you see '\u23F3 Codex is working', do NOT call the reply tool \u2014 wait for '\u2705 Codex finished'.",
   "- After Codex finishes a turn, you have an attention window to review and respond before new messages arrive.",
-  '- If the reply tool returns a busy error, Codex is still executing. You decide: wait and retry later, or resend with on_busy="steer" to feed the message INTO the running turn (good for mid-course corrections; it does not interrupt or restart the work).',
+  '- If the reply tool returns a busy error, Codex is still executing. You decide: wait and retry later, resend with on_busy="steer" to feed the message INTO the running turn (good for mid-course corrections; it does not interrupt or restart the work), or resend with on_busy="interrupt" to STOP the running turn and start a new one with your message (use only when the current work is obsolete \u2014 prefer steer otherwise).',
   "",
   "## Budget awareness",
   "- Use the get_budget tool to check both agents' subscription quota (5h/weekly windows, drift, pause state).",
@@ -13965,10 +13999,20 @@ class ClaudeAdapter extends EventEmitter {
   logFile;
   logger;
   pendingMessages = [];
+  pendingMessageByteSizes = [];
+  pendingMessageBytes = 0;
   maxBufferedMessages;
+  maxBufferedBytes;
   droppedMessageCount = 0;
+  oversizedMessageCount = 0;
+  oversizedMessageBytes = 0;
+  oversizedMessageSourceCounts = {};
+  dedupeCapacity;
+  dedupeTtlMs;
+  monotonicNow;
+  deliveredMessageIds = new Map;
   budgetSnapshot = null;
-  constructor(logFile = new StateDirResolver().logFile) {
+  constructor(logFile = new StateDirResolver().logFile, options = {}) {
     super();
     this.logFile = logFile;
     this.logger = createProcessLogger({ component: "ClaudeAdapter", logFile: this.logFile });
@@ -13979,7 +14023,11 @@ class ClaudeAdapter extends EventEmitter {
     if (process.env.AGENTBRIDGE_MODE) {
       this.log(`AGENTBRIDGE_MODE="${process.env.AGENTBRIDGE_MODE}" is no longer supported \u2014 ` + "pull mode was removed; push delivery (with per-message fallback queue) is always used.");
     }
-    this.maxBufferedMessages = parseInt(process.env.AGENTBRIDGE_MAX_BUFFERED_MESSAGES ?? "100", 10);
+    this.maxBufferedMessages = positiveIntegerOr(options.maxBufferedMessages, parsePositiveIntegerEnv("AGENTBRIDGE_MAX_BUFFERED_MESSAGES", DEFAULT_MAX_BUFFERED_MESSAGES));
+    this.maxBufferedBytes = positiveIntegerOr(options.maxBufferedBytes, parsePositiveIntegerEnv("AGENTBRIDGE_MAX_BUFFERED_BYTES", DEFAULT_MAX_BUFFERED_BYTES));
+    this.dedupeCapacity = positiveIntegerOr(options.dedupeCapacity, DEFAULT_DEDUPE_CAPACITY);
+    this.dedupeTtlMs = positiveIntegerOr(options.dedupeTtlMs, DEFAULT_DEDUPE_TTL_MS);
+    this.monotonicNow = options.now ?? (() => performance.now());
     this.server = new Server({ name: "agentbridge", version: "0.1.0" }, {
       capabilities: {
         experimental: { "claude/channel": {} },
@@ -14006,10 +14054,12 @@ class ClaudeAdapter extends EventEmitter {
   }
   async pushNotification(message) {
     this.log(`pushNotification (instance=${this.instanceId}, msgId=${message.id}, len=${message.content.length})`);
+    if (!this.rememberDelivery(message))
+      return;
     await this.pushViaChannel(message);
   }
   async pushViaChannel(message) {
-    const msgId = `codex_msg_${this.notificationIdPrefix}_${++this.notificationSeq}`;
+    const deliveryAttemptId = `codex_msg_${this.notificationIdPrefix}_${++this.notificationSeq}`;
     const ts = new Date(message.timestamp).toISOString();
     try {
       await this.server.notification({
@@ -14018,7 +14068,8 @@ class ClaudeAdapter extends EventEmitter {
           content: message.content,
           meta: {
             chat_id: this.sessionId,
-            message_id: msgId,
+            message_id: message.id,
+            delivery_attempt_id: deliveryAttemptId,
             user: "Codex",
             user_id: "codex",
             ts,
@@ -14026,39 +14077,93 @@ class ClaudeAdapter extends EventEmitter {
           }
         }
       });
-      this.log(`Pushed notification: ${msgId}`);
+      this.log(`Pushed notification: ${message.id} (attempt=${deliveryAttemptId})`);
     } catch (e) {
       this.log(`Push notification failed: ${e.message}`);
       this.queueFallbackMessage(message);
     }
   }
+  rememberDelivery(message) {
+    const now = this.monotonicNow();
+    this.pruneDeliveredMessageIds(now);
+    if (this.deliveredMessageIds.has(message.id)) {
+      this.deliveredMessageIds.delete(message.id);
+      this.deliveredMessageIds.set(message.id, now);
+      this.log(`Duplicate Codex message suppressed (msgId=${message.id}, source=${message.source}, ` + `instance=${this.instanceId})`);
+      return false;
+    }
+    this.deliveredMessageIds.set(message.id, now);
+    while (this.deliveredMessageIds.size > this.dedupeCapacity) {
+      const oldest = this.deliveredMessageIds.keys().next().value;
+      if (oldest === undefined)
+        break;
+      this.deliveredMessageIds.delete(oldest);
+    }
+    return true;
+  }
+  pruneDeliveredMessageIds(now) {
+    for (const [id, seenAt] of this.deliveredMessageIds) {
+      if (now - seenAt <= this.dedupeTtlMs)
+        break;
+      this.deliveredMessageIds.delete(id);
+    }
+  }
   queueFallbackMessage(message) {
-    if (this.pendingMessages.length >= this.maxBufferedMessages) {
-      this.pendingMessages.shift();
+    const messageBytes = utf8ByteLength(message.content);
+    if (messageBytes > this.maxBufferedBytes) {
+      this.oversizedMessageCount++;
+      this.oversizedMessageBytes += messageBytes;
+      this.oversizedMessageSourceCounts[message.source] = (this.oversizedMessageSourceCounts[message.source] ?? 0) + 1;
+      this.log(`Fallback queue omitted oversized ${message.source} message ` + `(${formatBytes(messageBytes)} > ${formatBytes(this.maxBufferedBytes)}; ` + `total oversized: ${this.oversizedMessageCount})`);
+      return;
+    }
+    let dropped = 0;
+    while (this.pendingMessages.length >= this.maxBufferedMessages || this.pendingMessageBytes + messageBytes > this.maxBufferedBytes) {
+      const droppedMessage = this.pendingMessages.shift();
+      const droppedBytes = this.pendingMessageByteSizes.shift() ?? 0;
+      if (!droppedMessage)
+        break;
+      this.pendingMessageBytes = Math.max(0, this.pendingMessageBytes - droppedBytes);
       this.droppedMessageCount++;
-      this.log(`Fallback queue full, dropped oldest message (total dropped: ${this.droppedMessageCount})`);
+      dropped++;
+    }
+    if (dropped > 0) {
+      this.log(`Fallback queue overflow: dropped ${dropped} oldest message${dropped > 1 ? "s" : ""} ` + `(${this.pendingMessages.length} pending, ${formatBytes(this.pendingMessageBytes)} buffered, ` + `${this.droppedMessageCount} dropped since last drain)`);
     }
     this.pendingMessages.push(message);
-    this.log(`Queued fallback message (${this.pendingMessages.length} pending, instance=${this.instanceId})`);
+    this.pendingMessageByteSizes.push(messageBytes);
+    this.pendingMessageBytes += messageBytes;
+    this.log(`Queued fallback message (${this.pendingMessages.length} pending, ` + `${formatBytes(this.pendingMessageBytes)} buffered, instance=${this.instanceId})`);
   }
   drainMessages() {
-    this.log(`get_messages called (instance=${this.instanceId}, pending=${this.pendingMessages.length}, dropped=${this.droppedMessageCount})`);
-    if (this.pendingMessages.length === 0 && this.droppedMessageCount === 0) {
+    this.log(`get_messages called (instance=${this.instanceId}, pending=${this.pendingMessages.length}, ` + `bytes=${this.pendingMessageBytes}, dropped=${this.droppedMessageCount}, oversized=${this.oversizedMessageCount})`);
+    if (this.pendingMessages.length === 0 && this.droppedMessageCount === 0 && this.oversizedMessageCount === 0) {
       return {
         content: [{ type: "text", text: "No new messages from Codex." }]
       };
     }
     const messages = this.pendingMessages;
     this.pendingMessages = [];
+    this.pendingMessageByteSizes = [];
+    this.pendingMessageBytes = 0;
     const dropped = this.droppedMessageCount;
     this.droppedMessageCount = 0;
+    const oversizedSourceCounts = this.oversizedMessageSourceCounts;
+    const oversized = this.oversizedMessageCount;
+    const oversizedBytes = this.oversizedMessageBytes;
+    this.oversizedMessageSourceCounts = {};
+    this.oversizedMessageCount = 0;
+    this.oversizedMessageBytes = 0;
     const count = messages.length;
-    let header = `[${count} new message${count > 1 ? "s" : ""} from Codex]`;
+    const notices = [];
     if (dropped > 0) {
-      header += ` (${dropped} older message${dropped > 1 ? "s" : ""} were dropped due to queue overflow)`;
+      notices.push(`${dropped} older message${dropped > 1 ? "s" : ""} ` + `${dropped > 1 ? "were" : "was"} dropped due to fallback queue overflow`);
+    }
+    if (oversized > 0) {
+      for (const [source, sourceCount] of Object.entries(oversizedSourceCounts)) {
+        notices.push(`${sourceCount} oversized message${sourceCount === 1 ? "" : "s"} ` + `from ${formatSource(source)} omitted ` + `(>${formatBytes(this.maxBufferedBytes)})`);
+      }
     }
-    header += `
-chat_id: ${this.sessionId}`;
     const formatted = messages.map((msg, i) => {
       const ts = new Date(msg.timestamp).toISOString();
       return `---
@@ -14067,14 +14172,25 @@ Codex: ${msg.content}`;
     }).join(`
 
 `);
-    this.log(`get_messages returning ${count} message(s) (instance=${this.instanceId}, dropped=${dropped})`);
+    const noticeText = notices.map((notice) => `WARNING: ${notice}`).join(`
+`);
+    const parts = [];
+    if (count > 0) {
+      parts.push(`[${count} new message${count > 1 ? "s" : ""} from Codex]
+chat_id: ${this.sessionId}`);
+    }
+    if (noticeText)
+      parts.push(noticeText);
+    if (formatted)
+      parts.push(formatted);
+    this.log(`get_messages returning ${count} message(s) ` + `(instance=${this.instanceId}, dropped=${dropped}, oversized=${oversized}, oversizedBytes=${oversizedBytes})`);
     return {
       content: [
         {
           type: "text",
-          text: `${header}
+          text: parts.join(`
 
-${formatted}`
+`)
         }
       ]
     };
@@ -14098,12 +14214,16 @@ ${formatted}`
               },
               require_reply: {
                 type: "boolean",
-                description: "When true, Codex is required to send a reply. All Codex messages from this turn will be forwarded immediately (bypassing STATUS buffering). Use this when you need a direct answer from Codex."
+                description: 'When true, Codex is required to send a reply. All Codex messages from this turn will be forwarded immediately (bypassing STATUS buffering). Use this when you need a direct answer from Codex. Combinable with on_busy="steer": the reply expectation arms once the steer is accepted into the running turn.'
               },
               on_busy: {
                 type: "string",
-                enum: ["reject", "steer"],
-                description: `What to do when Codex is mid-turn. "reject" (default): fail with a busy error \u2014 wait and retry. "steer": feed this message INTO the running turn \u2014 Codex sees it immediately and integrates it without losing work. Use steer for mid-course corrections, added constraints, or updated acceptance criteria; it does NOT start a new turn, so don't combine it with require_reply. If you need Codex to STOP and do something else, wait for the turn to finish (interrupt support is coming separately).`
+                enum: ["reject", "steer", "interrupt"],
+                description: 'What to do when Codex is mid-turn. "reject" (default): fail with a busy error \u2014 wait and retry. "steer": feed this message INTO the running turn \u2014 Codex sees it immediately and integrates it without losing work; use it for mid-course corrections, added constraints, or updated acceptance criteria (it does NOT start a new turn). "interrupt": STOP the running turn, wait for it to terminate, then send this message as a NEW turn \u2014 use only when the current work is obsolete; prefer steer otherwise.'
+              },
+              idempotency_key: {
+                type: "string",
+                description: "Optional client-generated key (non-empty, max 128 chars) that makes this reply idempotent: a retry carrying the same key is NOT re-injected \u2014 the bridge answers duplicate_in_flight / duplicate_terminal instead. Use a fresh key per logical message."
               }
             },
             required: ["text"]
@@ -14163,19 +14283,29 @@ ${formatted}`
     }
     const requireReply = args?.require_reply === true;
     const onBusyRaw = args?.on_busy;
-    const onBusy = onBusyRaw === "steer" ? "steer" : "reject";
-    if (onBusyRaw !== undefined && onBusyRaw !== "reject" && onBusyRaw !== "steer") {
+    if (onBusyRaw !== undefined && onBusyRaw !== "reject" && onBusyRaw !== "steer" && onBusyRaw !== "interrupt") {
       return {
-        content: [{ type: "text", text: `Error: invalid on_busy value ${JSON.stringify(onBusyRaw)} \u2014 use "reject" or "steer".` }],
+        content: [{ type: "text", text: `Error: invalid on_busy value ${JSON.stringify(onBusyRaw)} \u2014 use "reject", "steer" or "interrupt".` }],
         isError: true
       };
     }
-    if (onBusy === "steer" && requireReply) {
-      return {
-        content: [{ type: "text", text: 'Error: require_reply cannot be combined with on_busy="steer" yet \u2014 a steer joins the RUNNING turn instead of starting a new one, so reply tracking would mis-arm. Send the steer without require_reply.' }],
-        isError: true
-      };
+    const onBusy = onBusyRaw === "steer" || onBusyRaw === "interrupt" ? onBusyRaw : "reject";
+    const idempotencyKeyRaw = args?.idempotency_key;
+    if (idempotencyKeyRaw !== undefined) {
+      if (typeof idempotencyKeyRaw !== "string" || idempotencyKeyRaw.length === 0) {
+        return {
+          content: [{ type: "text", text: "Error: idempotency_key must be a non-empty string." }],
+          isError: true
+        };
+      }
+      if (idempotencyKeyRaw.length > 128) {
+        return {
+          content: [{ type: "text", text: `Error: idempotency_key is too long (${idempotencyKeyRaw.length} chars, max 128).` }],
+          isError: true
+        };
+      }
     }
+    const idempotencyKey = idempotencyKeyRaw;
     const bridgeMsg = {
       id: args?.chat_id ?? `reply_${Date.now()}`,
       source: "claude",
@@ -14189,16 +14319,22 @@ ${formatted}`
         isError: true
       };
     }
-    const result = await this.replySender(bridgeMsg, requireReply, onBusy);
+    const result = await this.replySender(bridgeMsg, requireReply, onBusy, idempotencyKey);
     if (!result.success) {
-      this.log(`Reply delivery failed: ${result.error}`);
+      this.log(`Reply delivery failed: ${result.error}${result.code ? ` (code=${result.code})` : ""}`);
+      const codePrefix = result.code ? ` [${result.code}]` : "";
       return {
-        content: [{ type: "text", text: `Error: ${result.error}` }],
+        content: [{ type: "text", text: `Error${codePrefix}: ${result.error}` }],
         isError: true
       };
     }
     const pending = this.pendingMessages.length;
-    let responseText = onBusy === "steer" ? "Reply sent to Codex (will be steered into the running turn if one is active; watch for a system_steer_failed notice if the app-server rejects it)." : "Reply sent to Codex.";
+    let responseText = "Reply sent to Codex.";
+    if (onBusy === "steer") {
+      responseText = "Reply sent to Codex (will be steered into the running turn if one is active; watch for a system_steer_failed notice if the app-server rejects it).";
+    } else if (onBusy === "interrupt") {
+      responseText = "Reply sent to Codex as a new turn (any turn still running was interrupted first; if it had already finished, your message was simply injected).";
+    }
     if (pending > 0) {
       responseText += ` Note: ${pending} unread Codex message${pending > 1 ? "s" : ""} already waiting \u2014 call get_messages to read them.`;
     }
@@ -14210,11 +14346,37 @@ ${formatted}`
     this.logger.log(msg);
   }
 }
+function parsePositiveIntegerEnv(name, fallback) {
+  return positiveIntegerOr(parseInt(process.env[name] ?? "", 10), fallback);
+}
+function positiveIntegerOr(value, fallback) {
+  return typeof value === "number" && Number.isFinite(value) && value > 0 ? Math.floor(value) : fallback;
+}
+function utf8ByteLength(value) {
+  return Buffer.byteLength(value, "utf8");
+}
+function formatSource(source) {
+  return source === "codex" ? "Codex" : "Claude";
+}
+function formatBytes(bytes) {
+  if (bytes < 1024)
+    return `${bytes}B`;
+  if (bytes % (1024 * 1024) === 0)
+    return `${bytes / (1024 * 1024)}MiB`;
+  if (bytes % 1024 === 0)
+    return `${bytes / 1024}KiB`;
+  return `${bytes}B`;
+}
 
 // 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;
 }
@@ -14227,15 +14389,23 @@ function defineNumber(value, fallback) {
   return typeof value === "number" && Number.isFinite(value) ? value : fallback;
 }
 var BUILD_INFO = Object.freeze({
-  version: defineString("0.1.11", "0.0.0-source"),
-  commit: defineString("48eb0ed", "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 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)
@@ -14245,7 +14415,8 @@ 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-client.ts
@@ -14256,6 +14427,83 @@ 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/interrupt-timing.ts
+var CLIENT_REPLY_TIMEOUT_MS = 15000;
+var INTERRUPT_CLIENT_MARGIN_MS = 2000;
+var MAX_INTERRUPT_TIMEOUT_MS = CLIENT_REPLY_TIMEOUT_MS - INTERRUPT_CLIENT_MARGIN_MS;
+
+// 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, error2) {
+    const entry = this.entries.get(id);
+    if (!entry)
+      return false;
+    this.clearTimer(entry.timer);
+    this.entries.delete(id);
+    entry.reject(error2);
+    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(error2) {
+    const make = typeof error2 === "function" ? error2 : () => error2;
+    for (const [id, entry] of this.entries) {
+      this.clearTimer(entry.timer);
+      this.entries.delete(id);
+      entry.reject(make(id));
+    }
+  }
+}
 
 // src/daemon-client.ts
 var nextSocketId = 0;
@@ -14266,7 +14514,8 @@ class DaemonClient extends EventEmitter2 {
   ws = null;
   wsId = 0;
   nextRequestId = 1;
-  pendingReplies = new Map;
+  pendingReplies = new PendingRequestRegistry;
+  pendingEventWaiters = new PendingRequestRegistry;
   constructor(url, options = {}) {
     super();
     this.url = url;
@@ -14312,81 +14561,72 @@ class DaemonClient extends EventEmitter2 {
     });
   }
   attachClaude() {
+    const identity = this.resolveIdentity();
     this.send({
       type: "claude_connect",
-      ...this.options.identity ? { identity: this.options.identity } : {}
+      ...identity ? { identity } : {}
     });
   }
+  resolveIdentity() {
+    const opt = this.options.identity;
+    return typeof opt === "function" ? opt() : opt;
+  }
   async attachClaudeAndWaitForStatus(timeoutMs = 1000) {
     if (!this.ws || this.ws.readyState !== WebSocket.OPEN) {
       return null;
     }
-    return await new Promise((resolve) => {
-      let settled = false;
-      let timer = null;
-      const cleanup = () => {
-        if (settled)
-          return;
-        settled = true;
-        if (timer) {
-          clearTimeout(timer);
-          timer = null;
-        }
-        this.off("status", onStatus);
-        this.off("rejected", onRejected);
-        this.off("disconnect", onDisconnect);
-      };
-      const finish = (value) => {
-        cleanup();
-        resolve(value);
-      };
-      const onStatus = (status) => finish(status);
-      const onRejected = () => finish(null);
-      const onDisconnect = () => finish(null);
-      this.on("status", onStatus);
-      this.on("rejected", onRejected);
-      this.on("disconnect", onDisconnect);
-      timer = setTimeout(() => {
-        finish(null);
-      }, timeoutMs);
-      try {
-        this.attachClaude();
-      } catch {
-        finish(null);
-      }
+    return this.awaitTypedResponse({
+      key: "status",
+      successEvent: "status",
+      successValue: (status) => status,
+      failValue: null,
+      timeoutMs,
+      send: () => this.attachClaude()
     });
   }
   async probeIncumbent(timeoutMs = 3000) {
     if (!this.ws || this.ws.readyState !== WebSocket.OPEN) {
       return { connected: false, alive: false };
     }
-    return await new Promise((resolve) => {
-      let settled = false;
-      let timer = null;
-      const finish = (value) => {
-        if (settled)
-          return;
-        settled = true;
-        if (timer)
-          clearTimeout(timer);
-        this.off("incumbentStatus", onStatus);
-        this.off("disconnect", onDisconnect);
-        this.off("rejected", onRejected);
-        resolve(value);
-      };
-      const onStatus = (s) => finish(s);
-      const onDisconnect = () => finish({ connected: false, alive: false });
-      const onRejected = () => finish({ connected: false, alive: false });
-      this.on("incumbentStatus", onStatus);
-      this.on("disconnect", onDisconnect);
-      this.on("rejected", onRejected);
-      timer = setTimeout(() => finish({ connected: false, alive: false }), timeoutMs);
-      try {
-        this.send({ type: "probe_incumbent" });
-      } catch {
-        finish({ connected: false, alive: false });
-      }
+    return this.awaitTypedResponse({
+      key: "incumbent_status",
+      successEvent: "incumbentStatus",
+      successValue: (s) => s,
+      failValue: { connected: false, alive: false },
+      timeoutMs,
+      send: () => this.send({ type: "probe_incumbent" })
+    });
+  }
+  awaitTypedResponse(opts) {
+    const { key, successEvent, successValue, failValue, timeoutMs, send } = opts;
+    const onSuccess = (payload) => {
+      this.pendingEventWaiters.settle(key, successValue(payload));
+    };
+    const onRejected = () => {
+      this.pendingEventWaiters.settle(key, failValue);
+    };
+    const onDisconnect = () => {
+      this.pendingEventWaiters.settle(key, failValue);
+    };
+    const pending = this.pendingEventWaiters.register(key, {
+      timeoutMs,
+      onTimeout: ({ resolve }) => resolve(failValue)
     });
+    const cleanup = () => {
+      this.off(successEvent, onSuccess);
+      this.off("rejected", onRejected);
+      this.off("disconnect", onDisconnect);
+    };
+    pending.finally(cleanup);
+    this.on(successEvent, onSuccess);
+    this.on("rejected", onRejected);
+    this.on("disconnect", onDisconnect);
+    try {
+      send();
+    } catch {
+      this.pendingEventWaiters.settle(key, failValue);
+    }
+    return pending;
   }
   async disconnect() {
     if (!this.ws)
@@ -14400,25 +14640,24 @@ class DaemonClient extends EventEmitter2 {
     this.ws = null;
     this.rejectPendingReplies("Daemon connection closed");
   }
-  async sendReply(message, requireReply, onBusy) {
+  async sendReply(message, requireReply, onBusy, idempotencyKey) {
     if (!this.ws || this.ws.readyState !== WebSocket.OPEN) {
       return { success: false, error: "AgentBridge daemon is not connected." };
     }
     const requestId = `reply_${Date.now()}_${this.nextRequestId++}`;
-    return new Promise((resolve) => {
-      const timer = setTimeout(() => {
-        this.pendingReplies.delete(requestId);
-        resolve({ success: false, error: "Timed out waiting for AgentBridge daemon reply." });
-      }, 15000);
-      this.pendingReplies.set(requestId, { resolve, timer });
-      this.send({
-        type: "claude_to_codex",
-        requestId,
-        message,
-        ...requireReply ? { requireReply: true } : {},
-        ...onBusy && onBusy !== "reject" ? { onBusy } : {}
-      });
+    const pending = this.pendingReplies.register(requestId, {
+      timeoutMs: CLIENT_REPLY_TIMEOUT_MS,
+      onTimeout: ({ resolve }) => resolve({ success: false, error: "Timed out waiting for AgentBridge daemon reply." })
     });
+    this.send({
+      type: "claude_to_codex",
+      requestId,
+      message,
+      ...requireReply ? { requireReply: true } : {},
+      ...onBusy && onBusy !== "reject" ? { onBusy } : {},
+      ...idempotencyKey ? { idempotencyKey } : {}
+    });
+    return pending;
   }
   attachSocketHandlers(ws, socketId) {
     ws.onmessage = (event) => {
@@ -14434,14 +14673,23 @@ class DaemonClient extends EventEmitter2 {
           this.emit("codexMessage", message.message);
           return;
         case "claude_to_codex_result": {
-          const pending = this.pendingReplies.get(message.requestId);
-          if (!pending)
-            return;
-          clearTimeout(pending.timer);
-          this.pendingReplies.delete(message.requestId);
-          pending.resolve({ success: message.success, error: message.error });
+          this.pendingReplies.settle(message.requestId, {
+            success: message.success,
+            error: message.error,
+            ...message.code !== undefined ? { code: message.code } : {},
+            ...message.phase !== undefined ? { phase: message.phase } : {},
+            ...message.retryAfterMs !== undefined ? { retryAfterMs: message.retryAfterMs } : {}
+          });
           return;
         }
+        case "turn_started":
+          this.emit("turnStarted", {
+            requestId: message.requestId,
+            ...message.idempotencyKey !== undefined ? { idempotencyKey: message.idempotencyKey } : {},
+            threadId: message.threadId,
+            turnId: message.turnId
+          });
+          return;
         case "status":
           this.emit("status", message.status);
           return;
@@ -14456,7 +14704,7 @@ class DaemonClient extends EventEmitter2 {
       if (isCurrent) {
         this.ws = null;
         this.rejectPendingReplies("AgentBridge daemon disconnected.");
-        if (event.code === CLOSE_CODE_REPLACED || event.code === CLOSE_CODE_EVICTED_STALE || event.code === CLOSE_CODE_PROBE_IN_PROGRESS || event.code === CLOSE_CODE_PAIR_MISMATCH) {
+        if (event.code === CLOSE_CODE_REPLACED || event.code === CLOSE_CODE_EVICTED_STALE || event.code === CLOSE_CODE_PROBE_IN_PROGRESS || event.code === CLOSE_CODE_PAIR_MISMATCH || event.code === CLOSE_CODE_TOKEN_MISMATCH || event.code === CLOSE_CODE_CONTRACT_MISMATCH) {
           this.emit("rejected", event.code);
         } else {
           this.emit("disconnect");
@@ -14466,11 +14714,7 @@ class DaemonClient extends EventEmitter2 {
     ws.onerror = () => {};
   }
   rejectPendingReplies(error2) {
-    for (const [requestId, pending] of this.pendingReplies.entries()) {
-      clearTimeout(pending.timer);
-      pending.resolve({ success: false, error: error2 });
-      this.pendingReplies.delete(requestId);
-    }
+    this.pendingReplies.settleAll(() => ({ success: false, error: error2 }));
   }
   send(message) {
     if (!this.ws || this.ws.readyState !== WebSocket.OPEN) {
@@ -14486,9 +14730,44 @@ class DaemonClient extends EventEmitter2 {
 
 // src/daemon-lifecycle.ts
 import { spawn } 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 readFileSync2, statSync as statSync2, unlinkSync as unlinkSync3, writeFileSync as writeFileSync2, openSync as openSync2, closeSync as closeSync2, constants } from "fs";
 import { fileURLToPath } from "url";
 
+// src/atomic-json.ts
+import * as fs from "fs";
+import { randomUUID as randomUUID2 } from "crypto";
+import { dirname as dirname2 } from "path";
+function tmpPathFor(targetPath) {
+  return `${targetPath}.tmp.${process.pid}.${randomUUID2()}`;
+}
+function atomicWriteText(path, content, options = {}) {
+  fs.mkdirSync(dirname2(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/env-utils.ts
 function parsePositiveIntEnv(name, fallback, log = () => {}, env = process.env) {
   const raw = env[name];
@@ -14537,23 +14816,208 @@ function isAgentBridgeProcess(pid, lookup = commandForPid) {
   return cmd.includes("agentbridge") || cmd.includes("agent_bridge");
 }
 
+// src/daemon-record.ts
+import { readFileSync } from "fs";
+var defaultRead = (path) => readFileSync(path, "utf-8");
+function writeDaemonRecord(path, record3) {
+  atomicWriteJson(path, record3);
+}
+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 record3 = { pid: obj.pid, phase };
+  if (typeof obj.startedAt === "number")
+    record3.startedAt = obj.startedAt;
+  if (typeof obj.nonce === "string")
+    record3.nonce = obj.nonce;
+  if (obj.pairId === null || typeof obj.pairId === "string")
+    record3.pairId = obj.pairId;
+  if (obj.cwd === null || typeof obj.cwd === "string")
+    record3.cwd = obj.cwd;
+  if (obj.stateDir === null || typeof obj.stateDir === "string")
+    record3.stateDir = obj.stateDir;
+  if (typeof obj.proxyUrl === "string")
+    record3.proxyUrl = obj.proxyUrl;
+  if (typeof obj.appServerUrl === "string")
+    record3.appServerUrl = obj.appServerUrl;
+  const ports = sanitizePorts(obj.ports);
+  if (ports !== undefined)
+    record3.ports = ports;
+  if (typeof obj.build === "object" && obj.build !== null) {
+    record3.build = obj.build;
+  }
+  if (typeof obj.turnPhase === "string")
+    record3.turnPhase = obj.turnPhase;
+  if (typeof obj.turnInProgress === "boolean")
+    record3.turnInProgress = obj.turnInProgress;
+  if (typeof obj.attentionWindowActive === "boolean") {
+    record3.attentionWindowActive = obj.attentionWindowActive;
+  }
+  return record3;
+}
+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 record3 = {
+    pid,
+    phase: status ? "ready" : "booting"
+  };
+  if (status) {
+    if (typeof status.proxyUrl === "string")
+      record3.proxyUrl = status.proxyUrl;
+    if (typeof status.appServerUrl === "string")
+      record3.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) {
+      record3.ports = {};
+      if (appPort !== undefined)
+        record3.ports.appPort = appPort;
+      if (proxyPort !== undefined)
+        record3.ports.proxyPort = proxyPort;
+      if (controlPort !== undefined)
+        record3.ports.controlPort = controlPort;
+    }
+    if (status.pairId === null || typeof status.pairId === "string")
+      record3.pairId = status.pairId;
+    if (status.cwd === null || typeof status.cwd === "string")
+      record3.cwd = status.cwd;
+    if (status.stateDir === null || typeof status.stateDir === "string")
+      record3.stateDir = status.stateDir;
+    if (typeof status.build === "object" && status.build !== null) {
+      record3.build = status.build;
+    }
+    if (typeof status.turnPhase === "string")
+      record3.turnPhase = status.turnPhase;
+    if (typeof status.turnInProgress === "boolean")
+      record3.turnInProgress = status.turnInProgress;
+    if (typeof status.attentionWindowActive === "boolean") {
+      record3.attentionWindowActive = status.attentionWindowActive;
+    }
+  }
+  return record3;
+}
+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/daemon-lifecycle.ts
 var DEFAULT_DAEMON_ENTRY = import.meta.url.endsWith(".ts") ? "./daemon.ts" : "./daemon.js";
 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) {
+  return verdict === "reuse" || verdict === "reuse-despite-drift";
+}
+function classifyDaemon(expectedPairId, status, buildInfo) {
+  if (!status) {
+    return { verdict: "unreachable", reason: "daemon status is unavailable or unparseable" };
+  }
+  const reportedPairId = status.pairId;
+  if (!expectedPairId && reportedPairId != null) {
+    return {
+      verdict: "manual-conflict",
+      reason: `manual mode must not adopt registered pair ${reportedPairId}`
+    };
+  }
+  if (expectedPairId) {
+    if (reportedPairId == null) {
+      return {
+        verdict: "replace-foreign",
+        reason: `pair ${expectedPairId} found daemon without pair identity`
+      };
+    }
+    if (reportedPairId !== expectedPairId) {
+      return {
+        verdict: "replace-foreign",
+        reason: `pair ${expectedPairId} found daemon for pair ${reportedPairId}`
+      };
+    }
+  }
+  if (!sameRuntimeContract(status.build, buildInfo)) {
+    if (compatibleContractVersion(status.build, buildInfo) && status.tuiConnected === true) {
+      return {
+        verdict: "reuse-despite-drift",
+        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)} (${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`;
@@ -14577,55 +15041,40 @@ class DaemonLifecycle {
       return null;
     }
   }
-  isForeignDaemon(status) {
-    const expected = this.expectedPairId;
-    if (!expected)
-      return false;
-    if (!status)
-      return false;
-    const reported = status.pairId;
-    if (reported == null)
-      return true;
-    return reported !== expected;
-  }
-  isRegisteredPairDaemonInManualMode(status) {
-    return !this.expectedPairId && status?.pairId != null;
-  }
-  isBuildDrifted(status) {
-    if (process.env.AGENTBRIDGE_ALLOW_BUILD_DRIFT === "1")
-      return false;
-    const runtime = status?.build;
-    if (!runtime)
-      return true;
-    return !sameRuntimeContract(runtime, BUILD_INFO);
+  classifyDaemon(status) {
+    const classification = classifyDaemon(this.expectedPairId, status, BUILD_INFO);
+    if (process.env.AGENTBRIDGE_ALLOW_BUILD_DRIFT === "1" && (classification.verdict === "replace-drifted" || classification.verdict === "unreachable")) {
+      return { verdict: "reuse", reason: "build drift replacement disabled by AGENTBRIDGE_ALLOW_BUILD_DRIFT" };
+    }
+    return classification;
   }
-  canReuseDespiteDrift(status) {
-    if (!compatibleContractVersion(status?.build, BUILD_INFO))
-      return false;
-    return status?.tuiConnected === true;
+  manualConflictError(status) {
+    return new Error(`Control port ${this.controlPort} is owned by registered pair ${status?.pairId}. ` + `This session has no pair identity (manual mode) and will not reuse or replace it \u2014 ` + `start with \`agentbridge claude\` from that pair's directory, or set AGENTBRIDGE_CONTROL_PORT to a free port.`);
   }
   async ensureRunning() {
     if (await this.isHealthy()) {
       const status = await this.fetchStatus();
-      if (this.isRegisteredPairDaemonInManualMode(status)) {
-        throw new Error(`Control port ${this.controlPort} is owned by registered pair ${status?.pairId}. ` + `This session has no pair identity (manual mode) and will not reuse or replace it \u2014 ` + `start with \`agentbridge claude\` from that pair's directory, or set AGENTBRIDGE_CONTROL_PORT to a free port.`);
-      }
-      if (this.isForeignDaemon(status)) {
-        this.log(`Control port ${this.controlPort} held by a daemon for pair ${status?.pairId ?? "<none>"}, ` + `but this pair is ${this.expectedPairId} \u2014 replacing foreign daemon`);
-        await this.replaceUnhealthyDaemon(status?.pid);
-        return;
-      }
-      if (this.isBuildDrifted(status)) {
-        if (this.canReuseDespiteDrift(status)) {
-          this.log(`Daemon on control port ${this.controlPort} is running build ${formatBuildInfo(status?.build)} ` + `(launcher ${formatBuildInfo(BUILD_INFO)}) but a live Codex TUI is attached \u2014 reusing instead of ` + `replacing; the new build is picked up at the next restart (abg kill, then relaunch)`);
-        } else {
+      const classification = this.classifyDaemon(status);
+      switch (classification.verdict) {
+        case "manual-conflict":
+          throw this.manualConflictError(status);
+        case "replace-foreign":
+          this.log(`Control port ${this.controlPort} held by a daemon for pair ${status?.pairId ?? "<none>"}, ` + `but this pair is ${this.expectedPairId} \u2014 replacing foreign daemon`);
+          await this.replaceUnhealthyDaemon(status?.pid);
+          return;
+        case "replace-drifted":
+        case "unreachable":
           this.log(`Daemon on control port ${this.controlPort} is running build ${formatBuildInfo(status?.build)} ` + `but launcher is ${formatBuildInfo(BUILD_INFO)} \u2014 replacing drifted daemon`);
           await this.replaceUnhealthyDaemon(status?.pid);
           return;
-        }
+        case "reuse-despite-drift":
+          this.log(`Daemon on control port ${this.controlPort} is running build ${formatBuildInfo(status?.build)} ` + `(launcher ${formatBuildInfo(BUILD_INFO)}) but a live Codex TUI is attached \u2014 reusing instead of ` + `replacing; the new build is picked up at the next restart (abg kill, then relaunch)`);
+          break;
+        case "reuse":
+          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`);
@@ -14638,7 +15087,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`);
@@ -14652,18 +15101,21 @@ class DaemonLifecycle {
     }
     await this.withStartupLockStrict(async (locked) => {
       if (!locked) {
-        this.log("Another process holds the startup lock, waiting for readiness+identity...");
-        await this.waitForReadyAndOurs();
+        await this.waitForContendedStartupLock();
         return;
       }
       if (await this.isHealthy()) {
         const status = await this.fetchStatus();
-        if (this.isForeignDaemon(status) || this.isBuildDrifted(status) && !this.canReuseDespiteDrift(status)) {
-          this.log(`Daemon on control port ${this.controlPort} is not reusable under startup lock ` + `(pair=${status?.pairId ?? "<none>"}, build=${formatBuildInfo(status?.build)}) \u2014 replacing`);
+        const classification = this.classifyDaemon(status);
+        if (classification.verdict === "manual-conflict") {
+          throw this.manualConflictError(status);
+        }
+        if (!isReuseVerdict(classification.verdict)) {
+          this.log(`Daemon on control port ${this.controlPort} is not reusable under startup lock ` + `(pair=${status?.pairId ?? "<none>"}, build=${formatBuildInfo(status?.build)}, ` + `reason=${classification.reason}) \u2014 replacing`);
           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`);
@@ -14672,7 +15124,7 @@ class DaemonLifecycle {
         }
       }
       this.launch();
-      await this.waitForReady();
+      await this.waitForReady(this.timing.waitReadyRetries, this.timing.waitReadyDelayMs);
     });
   }
   async isHealthy() {
@@ -14699,7 +15151,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;
@@ -14707,11 +15159,15 @@ 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();
-        if (!this.isForeignDaemon(status) && (!this.isBuildDrifted(status) || this.canReuseDespiteDrift(status))) {
+        const classification = this.classifyDaemon(status);
+        if (classification.verdict === "manual-conflict") {
+          throw this.manualConflictError(status);
+        }
+        if (isReuseVerdict(classification.verdict)) {
           return;
         }
       }
@@ -14719,22 +15175,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(record3) {
+    writeDaemonRecord(this.stateDir.daemonRecordFile, record3);
+  }
+  removeDaemonRecord() {
+    try {
+      unlinkSync3(this.stateDir.daemonRecordFile);
+    } catch {}
+  }
   readStatus() {
     try {
-      const raw = readFileSync(this.stateDir.statusFile, "utf-8");
+      const raw = readFileSync2(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 = readFileSync2(this.stateDir.pidFile, "utf-8").trim();
       if (!raw)
         return null;
       const pid = Number.parseInt(raw, 10);
@@ -14744,28 +15213,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() {
@@ -14787,21 +15255,26 @@ 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) => {
       if (!locked) {
-        this.log("Another process holds the startup lock, waiting for readiness+identity...");
-        await this.waitForReadyAndOurs();
+        await this.waitForContendedStartupLock();
         return;
       }
       if (await this.isHealthy()) {
         const status = await this.fetchStatus();
-        if (!this.isForeignDaemon(status) && (!this.isBuildDrifted(status) || this.canReuseDespiteDrift(status))) {
+        const classification = this.classifyDaemon(status);
+        if (classification.verdict === "manual-conflict") {
+          throw this.manualConflictError(status);
+        }
+        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 {}
         }
@@ -14809,9 +15282,13 @@ 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(this.timing.waitReadyRetries, this.timing.waitReadyDelayMs);
+  }
   async withStartupLockStrict(fn) {
     const locked = this.acquireLockStrict();
     try {
@@ -14825,15 +15302,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();
       }
@@ -14841,7 +15318,7 @@ class DaemonLifecycle {
         if (reclaimed)
           return false;
         try {
-          const holderPid = Number.parseInt(readFileSync(this.stateDir.lockFile, "utf-8").trim(), 10);
+          const holderPid = Number.parseInt(readFileSync2(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();
@@ -14870,7 +15347,7 @@ class DaemonLifecycle {
   }
   releaseLock() {
     try {
-      unlinkSync2(this.stateDir.lockFile);
+      unlinkSync3(this.stateDir.lockFile);
     } catch {}
   }
   async kill(gracefulTimeoutMs = 3000, pidOverride) {
@@ -14916,6 +15393,7 @@ class DaemonLifecycle {
   cleanup() {
     this.removePidFile();
     this.removeStatusFile();
+    this.removeDaemonRecord();
   }
 }
 async function fetchWithTimeout(url, timeoutMs = HEALTH_FETCH_TIMEOUT_MS) {
@@ -14929,11 +15407,11 @@ async function fetchWithTimeout(url, timeoutMs = HEALTH_FETCH_TIMEOUT_MS) {
 }
 
 // src/config-service.ts
-import { readFileSync as readFileSync2, writeFileSync as writeFileSync2, mkdirSync as mkdirSync2, existsSync as existsSync4 } from "fs";
+import { readFileSync as readFileSync3, mkdirSync as mkdirSync3, existsSync as existsSync4 } from "fs";
 import { join as join2 } from "path";
 var DEFAULT_BUDGET_CONFIG = {
   enabled: true,
-  pollSeconds: 60,
+  pollSeconds: 300,
   pauseAt: 90,
   resumeBelow: 30,
   syncDriftPct: 10,
@@ -14962,9 +15440,52 @@ var DEFAULT_CONFIG = {
 };
 var CONFIG_DIR = ".agentbridge";
 var CONFIG_FILE = "config.json";
+var NOOP_LOGGER = () => {};
 function isRecord(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
+function isCoercibleNumber(value) {
+  if (typeof value === "number")
+    return Number.isFinite(value);
+  if (typeof value === "string")
+    return Number.isFinite(Number(value));
+  return false;
+}
+function findShapeViolation(raw) {
+  if ("idleShutdownSeconds" in raw && !isCoercibleNumber(raw.idleShutdownSeconds)) {
+    return "idleShutdownSeconds is present but not a number";
+  }
+  if ("budget" in raw) {
+    const budget = raw.budget;
+    if (!isRecord(budget)) {
+      return "budget is present but not an object";
+    }
+    const numericKeys = ["pauseAt", "resumeBelow", "pollSeconds", "syncDriftPct"];
+    for (const key of numericKeys) {
+      if (key in budget && !isCoercibleNumber(budget[key])) {
+        return `budget.${key} is present but not a number`;
+      }
+    }
+    if ("parallel" in budget) {
+      const parallel = budget.parallel;
+      if (!isRecord(parallel)) {
+        return "budget.parallel is present but not an object";
+      }
+      for (const key of ["minRemainingPct", "timeWindowSec"]) {
+        if (key in parallel && !isCoercibleNumber(parallel[key])) {
+          return `budget.parallel.${key} is present but not a number`;
+        }
+      }
+    }
+  }
+  return null;
+}
+function hasCustomDecisionValues(config2) {
+  const d = DEFAULT_CONFIG;
+  const b = config2.budget;
+  const db = d.budget;
+  return config2.idleShutdownSeconds !== d.idleShutdownSeconds || config2.turnCoordination.attentionWindowSeconds !== d.turnCoordination.attentionWindowSeconds || config2.codex.appPort !== d.codex.appPort || config2.codex.proxyPort !== d.codex.proxyPort || b.enabled !== db.enabled || b.pollSeconds !== db.pollSeconds || b.pauseAt !== db.pauseAt || b.resumeBelow !== db.resumeBelow || b.syncDriftPct !== db.syncDriftPct || b.parallel.minRemainingPct !== db.parallel.minRemainingPct || b.parallel.timeWindowSec !== db.parallel.timeWindowSec || b.codexTierControl !== db.codexTierControl;
+}
 function normalizeInteger(value, fallback) {
   if (typeof value === "number" && Number.isFinite(value))
     return value;
@@ -15000,35 +15521,35 @@ function normalizeCodexOverride(raw) {
     override.effort = raw.effort.trim();
   return Object.keys(override).length > 0 ? override : null;
 }
-function normalizeCodexTiers(raw) {
+function normalizeCodexTiers(raw, fallback = DEFAULT_BUDGET_CONFIG.codexTiers) {
   const tiers = isRecord(raw) ? raw : {};
   return {
     full: normalizeCodexOverride(tiers.full),
-    balanced: normalizeCodexOverride(tiers.balanced) ?? DEFAULT_BUDGET_CONFIG.codexTiers.balanced,
-    eco: normalizeCodexOverride(tiers.eco) ?? DEFAULT_BUDGET_CONFIG.codexTiers.eco
+    balanced: normalizeCodexOverride(tiers.balanced) ?? fallback.balanced,
+    eco: normalizeCodexOverride(tiers.eco) ?? fallback.eco
   };
 }
-function normalizeBudgetConfig(raw) {
+function normalizeBudgetConfig(raw, fallback = DEFAULT_BUDGET_CONFIG) {
   const budget = isRecord(raw) ? raw : {};
   const parallel = isRecord(budget.parallel) ? budget.parallel : {};
-  const codexTiers = normalizeCodexTiers(budget.codexTiers);
-  let pauseAt = normalizeBoundedInteger(budget.pauseAt, DEFAULT_BUDGET_CONFIG.pauseAt, 1, 100);
-  let resumeBelow = normalizeBoundedInteger(budget.resumeBelow, DEFAULT_BUDGET_CONFIG.resumeBelow, 0, 99);
+  const codexTiers = normalizeCodexTiers(budget.codexTiers, fallback.codexTiers);
+  let pauseAt = normalizeBoundedInteger(budget.pauseAt, fallback.pauseAt, 1, 100);
+  let resumeBelow = normalizeBoundedInteger(budget.resumeBelow, fallback.resumeBelow, 0, 99);
   if (pauseAt <= resumeBelow) {
     pauseAt = DEFAULT_BUDGET_CONFIG.pauseAt;
     resumeBelow = DEFAULT_BUDGET_CONFIG.resumeBelow;
   }
   return {
-    enabled: normalizeBoolean(budget.enabled, DEFAULT_BUDGET_CONFIG.enabled),
-    pollSeconds: normalizeBoundedInteger(budget.pollSeconds, DEFAULT_BUDGET_CONFIG.pollSeconds, 5, 3600),
+    enabled: normalizeBoolean(budget.enabled, fallback.enabled),
+    pollSeconds: normalizeBoundedInteger(budget.pollSeconds, fallback.pollSeconds, 5, 3600),
     pauseAt,
     resumeBelow,
-    syncDriftPct: normalizeBoundedInteger(budget.syncDriftPct, DEFAULT_BUDGET_CONFIG.syncDriftPct, 1, 100),
+    syncDriftPct: normalizeBoundedInteger(budget.syncDriftPct, fallback.syncDriftPct, 1, 100),
     parallel: {
-      minRemainingPct: normalizeBoundedInteger(parallel.minRemainingPct, DEFAULT_BUDGET_CONFIG.parallel.minRemainingPct, 1, 100),
-      timeWindowSec: normalizeBoundedInteger(parallel.timeWindowSec, DEFAULT_BUDGET_CONFIG.parallel.timeWindowSec, 60, 604800)
+      minRemainingPct: normalizeBoundedInteger(parallel.minRemainingPct, fallback.parallel.minRemainingPct, 1, 100),
+      timeWindowSec: normalizeBoundedInteger(parallel.timeWindowSec, fallback.parallel.timeWindowSec, 60, 604800)
     },
-    codexTierControl: normalizeBoolean(budget.codexTierControl, DEFAULT_BUDGET_CONFIG.codexTierControl) && codexTiers.full !== null,
+    codexTierControl: normalizeBoolean(budget.codexTierControl, fallback.codexTierControl) && codexTiers.full !== null,
     codexTiers
   };
 }
@@ -15042,13 +15563,13 @@ function normalizeConfig(raw) {
   return {
     version: typeof config2.version === "string" ? config2.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(config2.idleShutdownSeconds, DEFAULT_CONFIG.idleShutdownSeconds),
+    idleShutdownSeconds: normalizeBoundedInteger(config2.idleShutdownSeconds, DEFAULT_CONFIG.idleShutdownSeconds, 1, Number.MAX_SAFE_INTEGER),
     budget: normalizeBudgetConfig(config2.budget)
   };
 }
@@ -15065,20 +15586,62 @@ class ConfigService {
     return existsSync4(this.configPath);
   }
   load() {
+    let raw;
     try {
-      const raw = readFileSync2(this.configPath, "utf-8");
-      return normalizeConfig(JSON.parse(raw));
-    } catch {
-      return null;
+      raw = readFileSync3(this.configPath, "utf-8");
+    } catch (err) {
+      if (err?.code === "ENOENT") {
+        return { state: "absent" };
+      }
+      return { state: "corrupt", reason: `config.json is unreadable: ${err.message}` };
     }
+    let parsed;
+    try {
+      parsed = JSON.parse(raw);
+    } catch (err) {
+      return {
+        state: "corrupt",
+        reason: `config.json is not valid JSON: ${err.message}`
+      };
+    }
+    if (!isRecord(parsed)) {
+      return { state: "corrupt", reason: "config.json is not a JSON object" };
+    }
+    const violation = findShapeViolation(parsed);
+    if (violation) {
+      return { state: "corrupt", reason: `config.json is shape-invalid: ${violation}` };
+    }
+    const config2 = normalizeConfig(parsed);
+    if (!config2) {
+      return { state: "corrupt", reason: "config.json could not be normalized" };
+    }
+    return { state: "parsed", config: config2 };
+  }
+  loadOrDefault(log = NOOP_LOGGER) {
+    const result = this.load();
+    if (result.state === "parsed")
+      return result.config;
+    if (result.state === "corrupt") {
+      log(`config.json at ${this.configPath} is unusable (${result.reason}); ` + "falling back to defaults \u2014 your custom budget thresholds / idle-shutdown settings are NOT in effect. " + "Fix the file and restart to re-apply them.");
+    }
+    return structuredClone(DEFAULT_CONFIG);
   }
-  loadOrDefault() {
-    return this.load() ?? structuredClone(DEFAULT_CONFIG);
+  describeConfig() {
+    const result = this.load();
+    if (result.state === "absent") {
+      return { state: "absent", path: this.configPath, customValues: false };
+    }
+    if (result.state === "corrupt") {
+      return { state: "corrupt", path: this.configPath, reason: result.reason, customValues: false };
+    }
+    return {
+      state: "parsed",
+      path: this.configPath,
+      customValues: hasCustomDecisionValues(result.config)
+    };
   }
   save(config2) {
-    this.ensureConfigDir();
-    writeFileSync2(this.configPath, JSON.stringify(config2, null, 2) + `
-`, "utf-8");
+    atomicWriteJson(this.configPath, config2);
   }
   initDefaults() {
     this.ensureConfigDir();
@@ -15094,34 +15657,46 @@ class ConfigService {
   }
   ensureConfigDir() {
     if (!existsSync4(this.configDir)) {
-      mkdirSync2(this.configDir, { recursive: true });
+      mkdirSync3(this.configDir, { recursive: true });
     }
   }
 }
 
+// src/cli-invocation.ts
+import { basename } from "path";
+var CLI_NAMES = ["abg", "agentbridge"];
+var DEFAULT_CLI_NAME = "abg";
+function cliInvocationName(argv = process.argv) {
+  const raw = argv[1];
+  if (typeof raw !== "string" || raw.length === 0)
+    return DEFAULT_CLI_NAME;
+  const name = basename(raw).replace(/\.(ts|js|mjs|cjs)$/, "");
+  return isCliName(name) ? name : DEFAULT_CLI_NAME;
+}
+function isCliName(value) {
+  return CLI_NAMES.includes(value);
+}
+
 // src/pair-registry.ts
 import {
-  closeSync as closeSync2,
   existsSync as existsSync5,
-  fsyncSync,
   linkSync,
   lstatSync,
-  mkdirSync as mkdirSync3,
-  openSync as openSync2,
+  mkdirSync as mkdirSync4,
   readdirSync,
-  readFileSync as readFileSync3,
+  readFileSync as readFileSync4,
   realpathSync,
-  renameSync as renameSync2,
   rmSync,
   statSync as statSync3,
-  unlinkSync as unlinkSync3,
+  unlinkSync as unlinkSync4,
   writeFileSync as writeFileSync3
 } from "fs";
-import { createHash, randomUUID as randomUUID2 } from "crypto";
-import { basename, join as join3, resolve, sep } from "path";
+import { createHash, randomUUID as randomUUID3 } from "crypto";
+import { basename as basename2, join as join3, resolve, sep } from "path";
 var PAIR_BASE_PORT = 4500;
 var PAIR_SLOT_STRIDE = 10;
 var PAIR_ID_REGEX = /^[A-Za-z0-9._-]{1,64}$/;
+var RECLAIMABLE_MIN_AGE_MS = 24 * 60 * 60 * 1000;
 var REGISTRY_FILE_NAME = "registry.json";
 class PairError extends Error {
   code;
@@ -15157,7 +15732,7 @@ function readRegistry(base) {
     return { version: 1, pairs: [] };
   let parsed;
   try {
-    parsed = JSON.parse(readFileSync3(path, "utf-8"));
+    parsed = JSON.parse(readFileSync4(path, "utf-8"));
   } catch (err) {
     throw new PairError("PAIR_REGISTRY_CORRUPT", `Registry JSON is not parseable at ${path}: ${err.message}`, {
       path
@@ -15198,10 +15773,10 @@ function findPair(base, pairId) {
 }
 
 // src/pair-command.ts
-function pairScopedCommand(cmd) {
+function pairScopedCommand(cmd, name = cliInvocationName()) {
   const pairId = process.env.AGENTBRIDGE_PAIR_ID;
   if (!pairId)
-    return `agentbridge ${cmd}`;
+    return `${name} ${cmd}`;
   let selector = process.env.AGENTBRIDGE_PAIR_NAME;
   if (!selector) {
     try {
@@ -15210,10 +15785,13 @@ function pairScopedCommand(cmd) {
       selector = pairId;
     }
   }
-  return `agentbridge --pair ${selector} ${cmd}`;
+  return `${name} --pair ${selector} ${cmd}`;
 }
 
 // src/bridge-disabled-state.ts
+function shouldEmitReconnectSuccess(state) {
+  return !state.daemonDisabled;
+}
 function disabledReplyError(reason) {
   const claudeCmd = pairScopedCommand("claude");
   switch (reason) {
@@ -15226,7 +15804,7 @@ function disabledReplyError(reason) {
     case "auto_recovery_exhausted":
       return `AgentBridge auto-recovery gave up after exhausting its retry budget for the in-flight liveness probe contention. Retry manually with \`${claudeCmd}\`.`;
     case "killed":
-      return `AgentBridge is disabled by \`agentbridge kill\`. Restart Claude Code (\`${claudeCmd}\`), switch to a new conversation, or run \`/resume\` to reconnect.`;
+      return `AgentBridge is disabled by \`${pairScopedCommand("kill")}\`. Restart Claude Code (\`${claudeCmd}\`), switch to a new conversation, or run \`/resume\` to reconnect.`;
   }
 }
 
@@ -15305,9 +15883,27 @@ function nonEmpty(value) {
   return value && value.length > 0 ? value : null;
 }
 
-// src/trace-log.ts
-import { appendFileSync as appendFileSync2, mkdirSync as mkdirSync4 } from "fs";
+// src/control-token.ts
+import { chmodSync, readFileSync as readFileSync5 } from "fs";
 import { join as join4 } from "path";
+var CONTROL_TOKEN_FILENAME = "control-token";
+function resolveControlTokenPath(stateDir) {
+  return join4(stateDir, CONTROL_TOKEN_FILENAME);
+}
+function readControlToken(path) {
+  try {
+    const raw = readFileSync5(path, "utf-8").trim();
+    return raw.length > 0 ? raw : null;
+  } catch {
+    return null;
+  }
+}
+
+// src/trace-log.ts
+import { appendFileSync as appendFileSync2, existsSync as existsSync6, mkdirSync as mkdirSync5, readdirSync as readdirSync2, statSync as statSync4, unlinkSync as unlinkSync5 } from "fs";
+import { join as join5 } from "path";
+var TRACE_RETENTION_DAYS = 7;
+var TRACE_FILE_RE = /^trace-\d{4}-\d{2}-\d{2}\.jsonl$/;
 var SECRET_KEY_RE = /(token|secret|password|passwd|api[_-]?key|auth|cookie|session)/i;
 var SECRET_ARG_RE = /^--?(?:token|secret|password|passwd|apikey|api-key|api_key|auth|cookie|session)(?:=.*)?$/i;
 var RELEVANT_ENV_RE = /^(AGENTBRIDGE_|CODEX_)/;
@@ -15345,7 +15941,7 @@ function redactArgv(argv) {
 }
 function traceLogPath(cwd, timestamp) {
   const day = timestamp.slice(0, 10);
-  return join4(cwd, ".agentbridge", "logs", `trace-${day}.jsonl`);
+  return join5(cwd, ".agentbridge", "logs", `trace-${day}.jsonl`);
 }
 function appendTraceEvent(input) {
   const timestamp = input.timestamp ?? new Date().toISOString();
@@ -15359,11 +15955,39 @@ function appendTraceEvent(input) {
     ...input.env ? { env: pickRelevantEnv(input.env) } : {},
     ...input.data ? { data: redactData(input.data) } : {}
   };
-  mkdirSync4(join4(input.cwd, ".agentbridge", "logs"), { recursive: true });
+  const logsDir = join5(input.cwd, ".agentbridge", "logs");
+  const isNewDayFile = !existsSync6(path);
+  mkdirSync5(logsDir, { recursive: true });
+  if (isNewDayFile) {
+    pruneOldTraceLogs(logsDir, path, Date.parse(timestamp));
+  }
   appendFileSync2(path, JSON.stringify(event) + `
 `, "utf-8");
   return path;
 }
+function pruneOldTraceLogs(logsDir, keepPath, nowMs) {
+  if (!Number.isFinite(nowMs))
+    return;
+  const cutoff = nowMs - TRACE_RETENTION_DAYS * 24 * 60 * 60 * 1000;
+  let entries;
+  try {
+    entries = readdirSync2(logsDir);
+  } catch {
+    return;
+  }
+  for (const name of entries) {
+    if (!TRACE_FILE_RE.test(name))
+      continue;
+    const filePath = join5(logsDir, name);
+    if (filePath === keepPath)
+      continue;
+    try {
+      if (statSync4(filePath).mtimeMs < cutoff) {
+        unlinkSync5(filePath);
+      }
+    } catch {}
+  }
+}
 function isEnvSnapshot(key, value) {
   return /env$/i.test(key) && !!value && typeof value === "object" && !Array.isArray(value);
 }
@@ -15402,14 +16026,14 @@ var envGuardResult = guardAgentBridgeEnv({
 });
 var stateDir = new StateDirResolver;
 stateDir.ensure();
+var processLogger = createProcessLogger({ component: "AgentBridgeFrontend", logFile: stateDir.logFile });
 var configService = new ConfigService;
-var config2 = configService.loadOrDefault();
+var config2 = configService.loadOrDefault(processLogger.log);
 var CONTROL_PORT = parseInt(process.env.AGENTBRIDGE_CONTROL_PORT ?? "4502", 10);
-var processLogger = createProcessLogger({ component: "AgentBridgeFrontend", logFile: stateDir.logFile });
 var daemonLifecycle = new DaemonLifecycle({ stateDir, controlPort: CONTROL_PORT, log });
 var CONTROL_WS_URL = daemonLifecycle.controlWsUrl;
 var claude = new ClaudeAdapter(stateDir.logFile);
-var daemonClient = new DaemonClient(CONTROL_WS_URL, { identity: currentClientIdentity() });
+var daemonClient = new DaemonClient(CONTROL_WS_URL, { identity: currentClientIdentity });
 var shuttingDown = false;
 var daemonDisabled = false;
 var daemonDisabledReason = null;
@@ -15422,6 +16046,7 @@ var lastReconnectNotifyTs = 0;
 var disabledRecoveryTimer = null;
 var disabledRecoveryInFlight = false;
 var disabledRecoveryAttempts = 0;
+var nextSystemMessageId = 0;
 var DISABLED_RECOVERY_MAX_ATTEMPTS = 6;
 var DISABLED_RECOVERY_CONFIRM_TIMEOUT_MS = 1000;
 if (process.env.AGENTBRIDGE_TRACE === "1") {
@@ -15445,7 +16070,7 @@ if (process.env.AGENTBRIDGE_TRACE === "1") {
     });
   } catch {}
 }
-claude.setReplySender(async (msg, requireReply, onBusy) => {
+claude.setReplySender(async (msg, requireReply, onBusy, idempotencyKey) => {
   if (msg.source !== "claude") {
     return { success: false, error: "Invalid message source" };
   }
@@ -15455,7 +16080,10 @@ claude.setReplySender(async (msg, requireReply, onBusy) => {
       error: disabledReplyError(daemonDisabledReason ?? "killed")
     };
   }
-  return daemonClient.sendReply(msg, requireReply, onBusy);
+  return daemonClient.sendReply(msg, requireReply, onBusy, idempotencyKey);
+});
+daemonClient.on("turnStarted", ({ requestId, idempotencyKey, threadId, turnId }) => {
+  log(`Codex turn started for reply ${requestId} (turn=${turnId}, thread=${threadId}` + `${idempotencyKey ? `, idempotencyKey=${idempotencyKey}` : ""})`);
 });
 daemonClient.on("codexMessage", (message) => {
   log(`Forwarding daemon \u2192 Claude (${message.content.length} chars)`);
@@ -15513,6 +16141,16 @@ daemonClient.on("rejected", async (code) => {
       notificationId = "system_bridge_pair_mismatch";
       notificationContent = `\u26A0\uFE0F AgentBridge daemon rejected this session \u2014 pair/cwd identity mismatch (this daemon belongs to a different pair or directory). Do NOT kill it; start Claude Code from the pair's own directory, or pick another pair name with \`agentbridge --pair <name> claude\`. AgentBridge \u62D2\u7EDD\u4E86\u6B64\u4F1A\u8BDD\u2014\u2014pair/\u76EE\u5F55\u8EAB\u4EFD\u4E0D\u5339\u914D\uFF08\u8BE5 daemon \u5C5E\u4E8E\u5176\u4ED6 pair \u6216\u76EE\u5F55\uFF09\u3002\u65E0\u9700 kill\uFF1B\u8BF7\u5230\u5BF9\u5E94\u76EE\u5F55\u542F\u52A8\uFF0C\u6216\u6362\u4E00\u4E2A pair \u540D\uFF1A\`agentbridge --pair <\u540D\u5B57> claude\`\u3002`;
       break;
+    case CLOSE_CODE_TOKEN_MISMATCH:
+      reason = "rejected";
+      notificationId = "system_bridge_token_mismatch";
+      notificationContent = `\u26A0\uFE0F AgentBridge daemon rejected this session \u2014 control token mismatch (the daemon likely restarted and rotated its token). Start a fresh session with \`${pairScopedCommand("claude")}\` to pick up the current token. AgentBridge \u62D2\u7EDD\u4E86\u6B64\u4F1A\u8BDD\u2014\u2014\u63A7\u5236\u4EE4\u724C\u4E0D\u5339\u914D\uFF08daemon \u53EF\u80FD\u5DF2\u91CD\u542F\u5E76\u8F6E\u6362\u4EE4\u724C\uFF09\u3002\u8BF7\u7528 \`${pairScopedCommand("claude")}\` \u91CD\u65B0\u542F\u52A8\u4EE5\u83B7\u53D6\u6700\u65B0\u4EE4\u724C\u3002`;
+      break;
+    case CLOSE_CODE_CONTRACT_MISMATCH:
+      reason = "rejected";
+      notificationId = "system_bridge_contract_mismatch";
+      notificationContent = `\u26A0\uFE0F AgentBridge daemon rejected this session \u2014 protocol contract mismatch. The installed plugin and the running daemon are built from out-of-sync protocol versions. Run \`bun run install:global\` to rebuild + reinstall, then close and reopen Claude Code. Do NOT kill other pairs \u2014 this is local build skew, not a session conflict. AgentBridge \u62D2\u7EDD\u4E86\u6B64\u4F1A\u8BDD\u2014\u2014\u534F\u8BAE\u5951\u7EA6\u7248\u672C\u4E0D\u5339\u914D\u3002\u5DF2\u5B89\u88C5\u7684\u63D2\u4EF6\u4E0E\u8FD0\u884C\u4E2D\u7684 daemon \u534F\u8BAE\u7248\u672C\u4E0D\u4E00\u81F4\u3002\u8BF7\u8FD0\u884C \`bun run install:global\` \u91CD\u65B0\u7F16\u8BD1\u5E76\u5B89\u88C5\uFF0C\u7136\u540E\u5173\u95ED\u5E76\u91CD\u65B0\u6253\u5F00 Claude Code\u3002\u8BF7\u52FF kill \u5176\u5B83 pair\u2014\u2014\u8FD9\u662F\u672C\u5730\u6784\u5EFA\u7248\u672C\u6F02\u79FB\uFF0C\u4E0D\u662F\u4F1A\u8BDD\u51B2\u7A81\u3002`;
+      break;
     default:
       reason = "rejected";
       notificationId = "system_bridge_replaced";
@@ -15532,7 +16170,7 @@ daemonClient.on("rejected", async (code) => {
 claude.on("ready", async () => {
   log("MCP server ready (push delivery) \u2014 ensuring AgentBridge daemon...");
   if (daemonLifecycle.wasKilled()) {
-    await enterDisabledState("Killed sentinel found \u2014 bridge staying idle", `\u26D4 AgentBridge was stopped by \`agentbridge kill\`. Bridge is staying idle. Restart Claude Code (\`${pairScopedCommand("claude")}\`), switch to a new conversation, or run \`/resume\` to reconnect.`);
+    await enterDisabledState("Killed sentinel found \u2014 bridge staying idle", `\u26D4 AgentBridge was stopped by \`${pairScopedCommand("kill")}\`. Bridge is staying idle. Restart Claude Code (\`${pairScopedCommand("claude")}\`), switch to a new conversation, or run \`/resume\` to reconnect.`);
     return;
   }
   try {
@@ -15594,11 +16232,11 @@ var reconnectTask = null;
 async function notifyIfDaemonKilled(logMessage) {
   if (!daemonLifecycle.wasKilled())
     return false;
-  await enterDisabledState(logMessage, `\u26D4 AgentBridge was stopped by \`agentbridge kill\`. Bridge is staying idle. Restart Claude Code (\`${pairScopedCommand("claude")}\`), switch to a new conversation, or run \`/resume\` to reconnect.`);
+  await enterDisabledState(logMessage, `\u26D4 AgentBridge was stopped by \`${pairScopedCommand("kill")}\`. Bridge is staying idle. Restart Claude Code (\`${pairScopedCommand("claude")}\`), switch to a new conversation, or run \`/resume\` to reconnect.`);
   return true;
 }
 async function notifyIfPairRemoved(logMessage) {
-  if (existsSync6(stateDir.dir))
+  if (existsSync7(stateDir.dir))
     return false;
   await enterDisabledState(logMessage, `\u26D4 This pair's state directory was removed (\`abg pairs rm\` / \`prune\`). Bridge is staying idle. Start fresh with \`${pairScopedCommand("claude")}\` if you still need this pair. \u8BE5 pair \u7684\u72B6\u6001\u76EE\u5F55\u5DF2\u88AB\u5220\u9664\uFF08pairs rm / prune\uFF09\uFF0C\u6865\u63A5\u4FDD\u6301\u5F85\u673A\uFF1B\u5982\u4ECD\u9700\u8981\u8BF7\u7528 \`${pairScopedCommand("claude")}\` \u91CD\u65B0\u542F\u52A8\u3002`);
   return true;
@@ -15631,6 +16269,9 @@ function reconnectToDaemon() {
         }
         try {
           await connectToDaemon(true);
+          if (!shouldEmitReconnectSuccess({ daemonDisabled })) {
+            return;
+          }
           log("Reconnected to AgentBridge daemon successfully");
           const now = Date.now();
           if (now - lastReconnectNotifyTs >= RECONNECT_NOTIFY_COOLDOWN_MS) {
@@ -15749,13 +16390,14 @@ async function pollDisabledRecovery() {
 }
 function systemMessage(idPrefix, content) {
   return {
-    id: `${idPrefix}_${Date.now()}`,
+    id: `${idPrefix}_${++nextSystemMessageId}`,
     source: "codex",
     content,
     timestamp: Date.now()
   };
 }
 function currentClientIdentity() {
+  const controlToken = readControlToken(resolveControlTokenPath(stateDir.dir));
   return {
     pairId: process.env.AGENTBRIDGE_PAIR_ID ?? null,
     pairName: process.env.AGENTBRIDGE_PAIR_NAME ?? null,
@@ -15763,7 +16405,8 @@ function currentClientIdentity() {
     baseDir: process.env.AGENTBRIDGE_BASE_DIR ?? null,
     stateDir: stateDir.dir,
     clientPid: process.pid,
-    contractVersion: BUILD_INFO.contractVersion
+    contractVersion: BUILD_INFO.contractVersion,
+    ...controlToken ? { controlToken } : {}
   };
 }
 function shutdown(reason) {