@raysonmeng/agentbridge 0.1.12 → 0.1.14

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

@@ -13662,6 +13662,7 @@ 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";
@@ -13805,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;
@@ -13812,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;
@@ -13839,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,7 +13863,48 @@ class StateDirResolver {
   }
 }
 
+// src/budget/types.ts
+var STALE_MAX_AGE_SEC = 600;
+
+// src/budget/budget-state.ts
+function isDecisionGrade(usage, now) {
+  if (!usage)
+    return false;
+  const freshWindow = usage.fiveHour !== null && usage.fiveHour.resetEpoch > now || usage.weekly !== null && usage.weekly.resetEpoch > now;
+  if (!freshWindow)
+    return false;
+  if (usage.fetchedAt > 0 && now - usage.fetchedAt > STALE_MAX_AGE_SEC)
+    return false;
+  return true;
+}
+
+// src/budget/burn-view.ts
+function agentWeeklyFiveHourWindowsLeft(usage, now) {
+  if (!usage || usage.stale || !usage.ok)
+    return null;
+  if (!isDecisionGrade(usage, now))
+    return null;
+  const weekly = usage.weekly;
+  if (!weekly || weekly.resetEpoch <= now)
+    return null;
+  if (weekly.burnConfident !== true)
+    return null;
+  if (weekly.runwaySeconds === undefined)
+    return null;
+  return weekly.fiveHourWindowsLeft ?? null;
+}
+
 // src/budget/render.ts
+var DEFAULT_GUARD_HARD_PCT = 92;
+function resolveGuardHardHint(env = process.env) {
+  const raw = env.AGENTBRIDGE_GUARD_HARD_HINT;
+  if (raw === undefined || raw.trim() === "")
+    return DEFAULT_GUARD_HARD_PCT;
+  const parsed = Number(raw);
+  if (!Number.isFinite(parsed) || parsed < 1 || parsed > 100)
+    return DEFAULT_GUARD_HARD_PCT;
+  return parsed;
+}
 function formatEpoch(epochSeconds) {
   if (!epochSeconds || epochSeconds <= 0)
     return "\u672A\u77E5";
@@ -13893,17 +13938,98 @@ function formatAgent(name, usage, snapshotAt) {
   }
   return `${name}\uFF1A${parts.join(" \xB7 ")}`;
 }
+var WINDOW_LABELS = {
+  fiveHour: "5h \u7A97\u53E3",
+  weekly: "\u5468\u7A97\u53E3"
+};
+var RESET_TRUNCATION_EPSILON_SEC = 60;
+function formatDuration(seconds) {
+  const totalMinutes = Math.max(0, Math.round(seconds / 60));
+  const hours = Math.floor(totalMinutes / 60);
+  const minutes = totalMinutes % 60;
+  if (hours === 0)
+    return `${minutes}\u5206\u949F`;
+  return `${hours}\u5C0F\u65F6${minutes}\u5206\u949F`;
+}
+function formatClockTime(epochSeconds) {
+  const date4 = new Date(epochSeconds * 1000);
+  const hh = String(date4.getHours()).padStart(2, "0");
+  const mm = String(date4.getMinutes()).padStart(2, "0");
+  return `${hh}:${mm}`;
+}
+function formatWindowRate(label, rate) {
+  if (!rate)
+    return null;
+  if (!rate.confident)
+    return `${label} \u91C7\u6837\u4E2D`;
+  return `${label} \u2248${rate.pctPerHour.toFixed(2)}%/h`;
+}
+function formatRunwaySegment(runway, basisWindow, snapshotAt) {
+  const truncatedByReset = basisWindow !== null && basisWindow.resetEpoch > 0 && snapshotAt + runway.seconds >= basisWindow.resetEpoch - RESET_TRUNCATION_EPSILON_SEC;
+  const clock = runway.depletedAtEpoch ? formatClockTime(runway.depletedAtEpoch) : null;
+  let clockNote;
+  if (clock) {
+    clockNote = truncatedByReset ? `\u81F3 ${clock} \u7A97\u53E3\u5237\u65B0\u5373\u622A\u65AD\uFF0C` : `\u81F3 ${clock}\uFF0C`;
+  } else {
+    clockNote = truncatedByReset ? "\u7A97\u53E3\u5237\u65B0\u5373\u622A\u65AD\uFF0C" : "";
+  }
+  return `\u7EA6\u53EF\u518D\u5DE5\u4F5C ${formatDuration(runway.seconds)}\uFF08${clockNote}${WINDOW_LABELS[runway.basis]}\u4E3A\u7EA6\u675F\uFF09`;
+}
+function formatBurnRateLine(name, usage, rates, runway, snapshotAt, guardHardPct) {
+  const parts = [
+    formatWindowRate("5h", rates.fiveHour),
+    formatWindowRate("\u5468", rates.weekly)
+  ].filter((part) => part !== null);
+  if (parts.length === 0 && !runway)
+    return null;
+  if (runway) {
+    const basisWindow = usage ? usage[runway.basis] : null;
+    parts.push(formatRunwaySegment(runway, basisWindow, snapshotAt));
+  }
+  if (guardHardPct !== null) {
+    parts.push(`\u5916\u5C42 guard \u786C\u7EBF ${guardHardPct}%\uFF08v3 \u4E0D\u53EF\u8D8A\u8FC7\uFF1Brunway \u4E3A\u4E2D\u6027\u53E3\u5F84\uFF0CClaude \u4F1A\u5148\u5728\u786C\u7EBF\u88AB\u5916\u5C42\u505C\u4F4F\uFF09`);
+  }
+  return `${name} \u71C3\u5C3D\u7387\uFF1A${parts.join(" \xB7 ")}`;
+}
+function formatFiveHourWindowsLeftLine(snapshot) {
+  const values = [];
+  const claude = agentWeeklyFiveHourWindowsLeft(snapshot.claude, snapshot.updatedAt);
+  const codex = agentWeeklyFiveHourWindowsLeft(snapshot.codex, snapshot.updatedAt);
+  if (claude !== null)
+    values.push(["Claude", claude]);
+  if (codex !== null)
+    values.push(["Codex", codex]);
+  if (values.length === 0)
+    return null;
+  const unique = [...new Set(values.map(([, value]) => value.toFixed(1)))];
+  if (unique.length === 1)
+    return `\u6309\u5F53\u524D\u8282\u594F\uFF0C\u5468\u989D\u5EA6\u8FD8\u591F ~${unique[0]} \u4E2A 5h \u7A97\u53E3`;
+  const byAgent = values.map(([name, value]) => `${name} ~${value.toFixed(1)}`).join(" / ");
+  return `\u6309\u5F53\u524D\u8282\u594F\uFF0C\u5468\u989D\u5EA6\u8FD8\u591F ${byAgent} \u4E2A 5h \u7A97\u53E3`;
+}
 var PHASE_LABELS = {
   normal: "normal\uFF08\u6B63\u5E38\uFF09",
   balance: "balance\uFF08\u9700\u5747\u8861\uFF09",
   parallel: "parallel\uFF08\u5EFA\u8BAE\u5E76\u884C\u63D0\u901F\uFF09",
   paused: "paused\uFF08\u9884\u7B97\u5E72\u9884\u4E2D\uFF09"
 };
-function renderBudgetSnapshot(snapshot) {
+function renderBudgetSnapshot(snapshot, options = {}) {
+  const guardHardPct = options.guardHardPct ?? resolveGuardHardHint();
   const lines = [];
   lines.push(`\u3010\u9884\u7B97\u5FEB\u7167 \xB7 \u8D26\u53F7\u7EA7\u3011\u9636\u6BB5\uFF1A${PHASE_LABELS[snapshot.phase]} \xB7 \u66F4\u65B0\u4E8E ${formatEpoch(snapshot.updatedAt)}`);
   lines.push(formatAgent("Claude", snapshot.claude, snapshot.updatedAt));
   lines.push(formatAgent("Codex", snapshot.codex, snapshot.updatedAt));
+  if (snapshot.burnRate) {
+    const claudeLine = formatBurnRateLine("Claude", snapshot.claude, snapshot.burnRate.claude, snapshot.runway?.claude ?? null, snapshot.updatedAt, guardHardPct);
+    if (claudeLine)
+      lines.push(claudeLine);
+    const codexLine = formatBurnRateLine("Codex", snapshot.codex, snapshot.burnRate.codex, snapshot.runway?.codex ?? null, snapshot.updatedAt, null);
+    if (codexLine)
+      lines.push(codexLine);
+  }
+  const fiveHourWindowsLeftLine = formatFiveHourWindowsLeftLine(snapshot);
+  if (fiveHourWindowsLeftLine)
+    lines.push(fiveHourWindowsLeftLine);
   if (snapshot.claude && snapshot.codex) {
     const abs = Math.abs(snapshot.driftPct);
     if (abs > 0) {
@@ -13943,6 +14069,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.",
   "",
@@ -13991,10 +14121,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 });
@@ -14005,7 +14145,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": {} },
@@ -14032,10 +14176,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({
@@ -14044,7 +14190,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,
@@ -14052,39 +14199,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 `---
@@ -14093,14 +14294,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}`
+`)
         }
       ]
     };
@@ -14256,11 +14468,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;
 }
@@ -14273,15 +14511,23 @@ 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.14", "0.0.0-source"),
+  commit: defineString("f5a9562", "source"),
   bundle: defineBundle("plugin"),
-  contractVersion: defineNumber(1, CONTRACT_VERSION)
+  contractVersion: defineNumber(1, CONTRACT_VERSION),
+  codeHash: defineString("e05d18c3cc72", "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)
@@ -14291,7 +14537,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
@@ -14302,12 +14549,84 @@ 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;
 
@@ -14317,7 +14636,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;
@@ -14363,82 +14683,73 @@ 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)
       return;
@@ -14456,21 +14767,19 @@ class DaemonClient extends EventEmitter2 {
       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." });
-      }, CLIENT_REPLY_TIMEOUT_MS);
-      this.pendingReplies.set(requestId, { resolve, timer });
-      this.send({
-        type: "claude_to_codex",
-        requestId,
-        message,
-        ...requireReply ? { requireReply: true } : {},
-        ...onBusy && onBusy !== "reject" ? { onBusy } : {},
-        ...idempotencyKey ? { idempotencyKey } : {}
-      });
+    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) => {
@@ -14486,12 +14795,7 @@ 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({
+          this.pendingReplies.settle(message.requestId, {
             success: message.success,
             error: message.error,
             ...message.code !== undefined ? { code: message.code } : {},
@@ -14522,7 +14826,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");
@@ -14532,11 +14836,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) {
@@ -14552,9 +14852,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];
@@ -14603,12 +14938,144 @@ 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) {
@@ -14646,22 +15113,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`;
@@ -14718,7 +15196,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`);
@@ -14731,7 +15209,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`);
@@ -14759,7 +15237,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`);
@@ -14768,7 +15246,7 @@ class DaemonLifecycle {
         }
       }
       this.launch();
-      await this.waitForReady();
+      await this.waitForReady(this.timing.waitReadyRetries, this.timing.waitReadyDelayMs);
     });
   }
   async isHealthy() {
@@ -14795,7 +15273,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;
@@ -14803,7 +15281,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();
@@ -14819,22 +15297,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);
@@ -14844,28 +15335,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() {
@@ -14887,8 +15377,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) => {
@@ -14904,7 +15396,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 {}
         }
@@ -14912,12 +15404,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();
@@ -14932,15 +15424,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();
       }
@@ -14948,7 +15440,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();
@@ -14977,7 +15469,7 @@ class DaemonLifecycle {
   }
   releaseLock() {
     try {
-      unlinkSync2(this.stateDir.lockFile);
+      unlinkSync3(this.stateDir.lockFile);
     } catch {}
   }
   async kill(gracefulTimeoutMs = 3000, pidOverride) {
@@ -15023,6 +15515,7 @@ class DaemonLifecycle {
   cleanup() {
     this.removePidFile();
     this.removeStatusFile();
+    this.removeDaemonRecord();
   }
 }
 async function fetchWithTimeout(url, timeoutMs = HEALTH_FETCH_TIMEOUT_MS) {
@@ -15036,7 +15529,7 @@ 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,
@@ -15053,7 +15546,8 @@ var DEFAULT_BUDGET_CONFIG = {
     full: null,
     balanced: { effort: "medium" },
     eco: { effort: "low" }
-  }
+  },
+  strategy: "conserve"
 };
 var DEFAULT_CONFIG = {
   version: "1.0",
@@ -15131,6 +15625,9 @@ function normalizeBoundedInteger(value, fallback, min, max) {
     return fallback;
   return parsed;
 }
+function normalizeStrategy(value, fallback) {
+  return value === "conserve" || value === "maximize" ? value : fallback;
+}
 function normalizeBoolean(value, fallback) {
   if (typeof value === "boolean")
     return value;
@@ -15179,7 +15676,8 @@ function normalizeBudgetConfig(raw, fallback = DEFAULT_BUDGET_CONFIG) {
       timeWindowSec: normalizeBoundedInteger(parallel.timeWindowSec, fallback.parallel.timeWindowSec, 60, 604800)
     },
     codexTierControl: normalizeBoolean(budget.codexTierControl, fallback.codexTierControl) && codexTiers.full !== null,
-    codexTiers
+    codexTiers,
+    strategy: normalizeStrategy(budget.strategy, fallback.strategy)
   };
 }
 function normalizeConfig(raw) {
@@ -15192,13 +15690,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)
   };
 }
@@ -15217,7 +15715,7 @@ class ConfigService {
   load() {
     let raw;
     try {
-      raw = readFileSync2(this.configPath, "utf-8");
+      raw = readFileSync3(this.configPath, "utf-8");
     } catch (err) {
       if (err?.code === "ENOENT") {
         return { state: "absent" };
@@ -15270,9 +15768,7 @@ class ConfigService {
     };
   }
   save(config2) {
-    this.ensureConfigDir();
-    writeFileSync2(this.configPath, JSON.stringify(config2, null, 2) + `
-`, "utf-8");
+    atomicWriteJson(this.configPath, config2);
   }
   initDefaults() {
     this.ensureConfigDir();
@@ -15288,34 +15784,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;
@@ -15351,7 +15859,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
@@ -15392,10 +15900,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 {
@@ -15404,10 +15912,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) {
@@ -15420,7 +15931,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.`;
   }
 }
 
@@ -15499,9 +16010,25 @@ function nonEmpty(value) {
   return value && value.length > 0 ? value : null;
 }
 
-// src/trace-log.ts
-import { appendFileSync as appendFileSync2, existsSync as existsSync6, mkdirSync as mkdirSync4, readdirSync as readdirSync2, statSync as statSync4, unlinkSync as unlinkSync4 } 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;
@@ -15541,7 +16068,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();
@@ -15555,9 +16082,9 @@ function appendTraceEvent(input) {
     ...input.env ? { env: pickRelevantEnv(input.env) } : {},
     ...input.data ? { data: redactData(input.data) } : {}
   };
-  const logsDir = join4(input.cwd, ".agentbridge", "logs");
+  const logsDir = join5(input.cwd, ".agentbridge", "logs");
   const isNewDayFile = !existsSync6(path);
-  mkdirSync4(logsDir, { recursive: true });
+  mkdirSync5(logsDir, { recursive: true });
   if (isNewDayFile) {
     pruneOldTraceLogs(logsDir, path, Date.parse(timestamp));
   }
@@ -15578,12 +16105,12 @@ function pruneOldTraceLogs(logsDir, keepPath, nowMs) {
   for (const name of entries) {
     if (!TRACE_FILE_RE.test(name))
       continue;
-    const filePath = join4(logsDir, name);
+    const filePath = join5(logsDir, name);
     if (filePath === keepPath)
       continue;
     try {
       if (statSync4(filePath).mtimeMs < cutoff) {
-        unlinkSync4(filePath);
+        unlinkSync5(filePath);
       }
     } catch {}
   }
@@ -15633,7 +16160,7 @@ var CONTROL_PORT = parseInt(process.env.AGENTBRIDGE_CONTROL_PORT ?? "4502", 10);
 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;
@@ -15646,6 +16173,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") {
@@ -15740,6 +16268,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";
@@ -15759,7 +16297,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 {
@@ -15821,7 +16359,7 @@ 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) {
@@ -15858,6 +16396,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) {
@@ -15976,13 +16517,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,
@@ -15990,7 +16532,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) {